AOE Workspace

Status

The date this page was last touched is the modified: date at its very top — stated once there, enforced at commit, never repeated here (the old header said "last updated 2026-08-01" beneath entries dated 2026-08-02; the boot test caught it — and its "Session 1" label later went stale the same way, caught by round 8: the working session changes, so this page no longer names it). Newest first within each list.

Done

• **The webpage has a Files page now, because you couldn't find 08 —

and you were right (2026-08-02, D50). The dropdown's invented names ("For you") never told you which file was which. Second item in the dropdown now: Files** — the documentation folder listed under real filenames, sorted by number, tap to open, with edit dates, sizes, and a filter box; the For-you tab is relabelled "For you (08)". Adopted from the old build's viewer: the Files-tab idea, the filter, and its honesty about unrendered files. Declined with reasons in D50: its graph view (that's deferred row 14, waiting on ~25+ pages), its Flow tab (our Map page owns that), its Settings tab, and its bundle-everything approach (a 3.5MB page; our inventory page covers the workspace instead).

• **Your phone page is now fully hands-off (2026-08-02, D49, row 20

closed).** You granted "always auto push" for the Cloudflare folder: every loop now copies the freshly built standalone page into aos-8.3.1-docs, commits, and pushes — Cloudflare deploys on push, so https://aos-8-3-1-docs.pages.dev updates itself (URL verified by fetching it). The mobile fix went out with the first auto-push. The claude.ai artifact is retired, frozen at today's state as a fallback. The never-push rule stays for both work repos — the boot file, the procedure, and the loop all state the one-repo exception in the same breath as the rule.

• **You asked whether the last session tracked everything — the audit

ran, and the honest answer is: almost (2026-08-02, D48).** Twelve agents in a workflow: four checkers re-derived the previous session's record from its transcript, its 15 commits across both repos, and the docs — then every finding was attacked by an independent verifier before reaching you. What held: all but one of your messages traced faithfully into the record (including seven the first extraction missed, whose recovery proved two decision entries' owner-attributions genuine rather than fabricated); 13 of 15 commit attestations were true; the app's imports, lock, and analyses all verify on disk. What failed, all now fixed: one directive of yours (the 15:13 staleness concern) was dropped entirely — recorded and answered in D48; this page's own bottom sections were five hours stale (the sweep rule now names them); two false attestations sat outside the previously recorded containment windows (now in the audit receipts); two miscounts in D46 (corrected in place, visibly); and the app's seed-lessons file was missing the failure-mode line the filing rule demands (added). Receipts: working/state/audits.md, docs-verification r2. Also today: your Cloudflare page wasn't mobile — real bug, the served file lacked its own viewport wrapper; the builder now writes a standalone index.html, and the fix reaches the site when you push.

• **The first unit is done and the app build now waits at your gate

(2026-08-02).** The slide documentation you set as the stop point (D45) is written in the app: three pages, macro to micro — what the slide is and what governs it, the thirteen-component catalogue (never a template), and how analysts build it (research routes and selection judgement, marked as reconstruction; six confirmed cross-slide findings, led by the missing-takeaway defect). Every material claim cites the persisted analyses, the per-slide evaluations, or the specs; the seven benchmarks are each dated and none is current. A fresh-context verifier attacked the pages against the evidence before you see them: 20 findings — including two overgeneralised "all seven" claims and a swapped attribution — 19 fixed, 1 overturned on recheck. The app repo holds it all (commits 0a820fe → f6a1720); the pages are in your actions queue, and nothing derives from them until your review.

• **Your context meter exists and is wired everywhere it should be

(2026-08-02, deferred row 21 — one step from closed).** The gauge you asked for — orange at 55%, red at 60% — now reads this session's real token usage from the transcript file Claude Code itself writes (the one record a chat cannot rewrite), filters out subagent noise, and reports a color. It reports and never blocks, exactly as designed: a red tells the session to close its loop and offer handover — blocking would trap the very commit that hands over. You see it as a chip on the phone dashboard's receipt strip, and every loop report states it. Proof it works: pointed at your last session's handover transcript it reads RED (771,884 tokens); this session reads GREEN. The one honest gap: nobody knows the window's true size — the meter assumes 1,000,000 tokens and says "uncalibrated" in every reading; the evidence hints the truth is nearer 1.13 million, so the assumption warns early, the safe direction. Closing it takes you 30 seconds — the ask is on your actions page.

• **The rename you asked for is complete, end to end (2026-08-02,

deferred row 19 closed).** You renamed the folder to aos-8.3.1 and opened this fresh chat in it; the session then finished the checklist: the app's lock file and its CLAUDE.md now point at the renamed kernel (declared edits, app commit 0a820fe; the kernel tether re-verified all 18 locked files against the new path), the cross-session memory your last session pre-copied was confirmed loaded at this boot, and these docs were swept for the old name — current claims updated, historical mentions in the decision log kept as that log's convention requires. Both boot files changed only in name and path strings (the app's two kernel paths; this repo's title line), so each repo carries a visible waiver in its audit receipts instead of a fresh boot test. Your actions page also lost its rename row (done) and its session link now points at this session.

• **The first app is alive, sourced, and analysed — and the machinery

earned its keep three times on the way (2026-08-02, D46, D47).** ../company-overview exists with its own gate, tether (18 locked files), and management pages. Getting it born took three attempts — the first two stopped honestly by a gate, the third succeeding (wording corrected 2026-08-02, docs-verification r2): a template skeleton one rule behind (fixed), and frozen reference evidence that must never be edited colliding with the timestamp rule (the kernel gained a narrow exemption — and adopting it in the app was deferred row 15's predicted event: the first hand kernel upgrade, done by re-copy and re-lock so the tether shows it openly). Inside the app now: the analyst specs, all seven benchmark slides with your notes preserved, the per-slide reconstructions, the canonical La Caisse emblem, your audit's lessons as seed lessons, your producer toggle — and the seven element-by-element slide analyses with rebuilding analyses, persisted verbatim so the next session writes your review copy without redoing anything. Also wired from your messages: the Cloudflare publishing route is prepared (deferred 20 — your 5-minute setup remains), the folder rename has its checklist (row 19), and this session hands over at your call — the checkpoint is the handover, by design.

• **The analysis design is settled and the app build is go

(2026-08-02, D45).** Your direction question answered: the analysis runs bottom-up — every element of every benchmark slide evaluated (each bullet's purpose, how it serves the slide's goal), then commonalities across all seven — while the documentation you'll read is written top-down. Your rebuilding analysis is in: per slide, reconstruct how the analysts likely found the information and how they chose what earned a place out of everything found. Your review gate is set where you put it: the build stops at the human-facing slide documentation; nothing derives from it until you've read it. Benchmarks additionally marked not-up-to-date, each to be dated. Your "For you" catch fixed: the dashboard and session rows were done — links moved to Standing.

• **The app plan absorbed your design and your rulings the hour they

arrived (2026-08-02, D44).** Build macro to micro: first our own readable documentation of how the slide works (header to component to font size, derived from the seven reconstructed benchmark slides and the specs), then the AI wiki and procedures derived from it — components catalogued, never whole-slide templates, because the goal is simulating how a real analyst composes, not copying old slides. Your authority ruling: the analyst's brief is encoded as defaults a run may depart from with a logged, reviewable reason — never silent — with only a small hard floor (the strict header, furniture, font floors, never inventing facts or graphics); the benchmarks are noted imperfect. Your entry point stays this workspace: the app lives as a sibling repository with its own commits, gate, and complete management layer, wired to the kernel by locked copy and tether — your modular idea with the drift-safety you accepted. Open: your go to spawn, and the first target company.

• **The first app has its plan, built from your own audit of the last

attempt (2026-08-02, D43).** Everything in the old repo's company-overview folder was read — your forensic audit first, per its own instruction, then the old skill, its one real test run, and the analyst specs and seven benchmark slides. The plan is docs/13-company-overview-plan.md, one sitting's read: what the slide product is, the six expensive lessons your audit paid for (headline: verification must be anchored to the sources and check presence, not just correctness — the old build's every-gate-green slide failed exactly there), what the old build got right and keeps (honest research closure, takeaway-as-content, one traceable fact store), and how it runs governed on this kernel from its first commit. It ends with the six product questions only you can answer — the sources genuinely contradict each other on them — each with my recommendation. Your verdict there is what spawns the workspace.

• **The enforcers themselves got audited, and the audit caught me twice

(2026-08-02, D42).** The enforcement-review audit's first run verified the hooks are truly wired (it planted an illegal file and the gate blocked it by name, then restored everything), found no writes in your read-only old repo, and sampled four commits' attestation lines against their actual changes. Two were false — one in the already-known morning window, and one of mine from midday: a receipt-only commit claiming a status update it didn't contain. That claim is now checked by machine (a commit saying "status=y" is rejected unless the status page is actually in it), and the map now admits, in its blind-spots list, the subtler thing the audit proved: a freshness fingerprint can be dutifully updated while the prose next to it goes stale, so the scheduled meaning-checks — not the fingerprint — are what guard the account. With this, every audit in the table has now run for real at least once.

• **The audit layer had its first full day in court, and it drew blood

on purpose (2026-08-02, D41).** The two audits that argue against the system ran for real. Function-fitness found the hardest thing: this morning, nine commits carried attestations claiming no deviations while declared steps silently didn't happen — possible because a commit that never touched the checkpoint inherited the previous loop's green run line. That door is now closed by the gate itself (every commit must rewrite the checkpoint; every docs change must carry a derivation verdict). It also argued three of the five functions haven't earned their keep yet — zero runs for retrieve, one for add-system, all-default classifications for evaluate-panel — and rather than deleting functions you ratified this morning on 15 hours of evidence, each now carries a dated sunset test at the next audit cycle: prove useful by then or be demoted, exactly the retirement half of the learning loop you accepted. Gap-analysis closed one deferred row as already met (the dashboard exists), added a secrets-policy row for the future apps, gave the inbox and the retrieval system their missing places on the map, and named two real absences now watched: what a chat should do with a half-finished loop it inherits, and the fact that nothing ever re-checks facts fetched from the web. Boot test round 8 passed on the changed rules. Receipts for all of it: working/state/audits.md.

• **Your stopping rule is law now (2026-08-02, D39), and build item 3

is closed (D40).** The rule: I stop only when something needs your review — named — or a question blocks me; otherwise the next item starts immediately. It's in the procedure, proven readable by a fresh chat, and saved to memory beyond this workspace. Build item 3 (the wiki-write system) closed as what it honestly was: mostly already built — what was missing was written criteria for what deserves a wiki node versus deferral versus nothing, now distilled from the day's real decisions into the derive-wiki function, with the two small amendments to the accepted proposal recorded as decisions, the way the proposal itself requires.

• **Build item 2 is done: retrieval is designed, not interim

(2026-08-02, D38).** The retrieve function now carries the three things the accepted proposal required: routing (when a specialised retrieval like the boot path fits better, a chat uses it and says so openly), a permanent miss log (a failed retrieval writes a row in the wiki index that survives every loop — the old checkpoint notes vanished at each overwrite, so the "add search tools when misses cluster" rule could never actually fire), and the cluster trigger itself (three misses on one area, counted the moment the third is written, then evaluated through the research gate — never built pre-emptively). A fresh-context verifier checked it against the proposal before it was called done; its findings — including a page still calling retrieval an "interim rule" — are fixed. Honest limit: no miss cluster has ever occurred, so the trigger is untested until real retrieval load arrives with the apps.

• **The chat-to-chat inbox works — its first delivery proved itself

(2026-08-02, D37).** The previous session deposited two files into working/inbox/ (the channel you designed: a non-owning chat may add new files, never edit or commit), and the commit gate caught them exactly as designed — a deposit cannot be missed, because an undescribed file blocks the next commit. Both were integrated and deleted the same loop: the protocol is ratified and lives at working/inbox/README.md, and the session-spawning recipe you asked to have saved is in the lessons folder in full. Promoting that recipe to a function waits for its second successful run — that's the promotion rule you ratified this morning, applied to its first tempting exception (deferred row 17; your call to override).

• **Your "should we edit the functions?" — done, and it was the

learning loop's first live improvement (2026-08-02, D36).** The docs/00 staleness happened because the work loop's record step never said to sweep the other user-facing pages for claims a loop's events made stale. The loop function now ends its record step with exactly that sweep, the root page named first, and a clean sweep must say "none stale" in the checkpoint — a skippable habit became a checked step. This is the improvement path you ratified in D33 working as designed: a gap surfaced by real failure, written back into the function the same day.

• **Build item 1 is real: one command now births a governed app

workspace (2026-08-02, D34).** The template you accepted exists as working machinery: a spawn script copies the living kernel into a fresh folder, fills ready-made page blanks, writes a lock recording exactly what was copied from which kernel version, arms the commit gate, and refuses to finish unless the new workspace's own gate passes — tested live on a throwaway app, including the failure paths (a silent edit to a copied kernel file blocks the app's next commit; a change with its reason written beside it passes; changing the file again trips it again). An adversarial fresh-context reviewer attacked the build before it was called done and won three real improvements, the biggest being that last property — reasons are pinned to the exact change they excuse, so one recorded reason can never quietly cover future edits. Your plain-language account: docs/12-app-template.md (also on your phone). What was deliberately not built: the kernel-upgrade procedure (deferred row 15 — the promotion rule you just ratified says procedures come from real work, and no app has needed an upgrade yet).

• **Your verdict landed and is law: the proposal accepted in full,

recorded, and its immediate consequences executed (2026-08-02, D33).** Your message — "i accept the proposal 3 items" — is read as accepting all three menu items (the kernel claim; the six build items, including the template rule that every new app copies the kernel while an audit watches the copies for silent drift, and the rule that procedures come only from real work; the anti-scope); D33 preserves your exact words so the reading is correctable if I read it wrong. Executed on it: all five functions dropped their provisional "pilot" mark for owner-ratified "active"; the learning-loop rules (how procedures are born from real work, improved through deviations, and retired by the audit that argues against them) became a wiki node chats can retrieve; and the wiki-lint audit — whose first run the proposal made part of acceptance — actually ran, as did a fresh boot test (the rulebook changed, so the tether required one). The two fresh checkers earned their keep: between them they caught me recording the wiki-lint run before it happened (the workspace's premature-record disease, fifth instance, caught pre-commit and filed in the lesson), my edit deleting your only written route back to the working session (restored), two wiki claims newer decisions had overtaken, and a rule that was supposed to be folded into a wiki node and never was (folded). Receipts: working/state/audits.md. Next: build item 1, the template.

• **Your "is everything tracked?" question — audited by three fresh

agents, honest answer: mostly, with real gaps, all now fixed (2026-08-02, D32).** What they caught: the dropdown navigation was never recorded user-facing (it is now — you asked, it was built, commit cb818b1); the successor session's location and how you reach it existed only in AI-facing files (now on your actions page); five decision-grade events since D31 had no decision entries (now D32); the blind-spot governance had no status entry (this is it, with P6's trail in the map); and two false claims stood — the map's loop.md fingerprint matched no committed version, and the D30 run-line device had lapsed one commit after it was built, passing vacuously because a checkpoint rewrite silently failed to apply. Both are now mechanically impossible to repeat: the gate verifies every map fingerprint against the real file per commit, and a checkpoint with no loop run-line blocks the commit. The child-session transcript discovery is filed as a lesson, and the commit-gate wiki node caught up with the three rules it was missing.

• **Nothing can exist unconnected, and gaps have a schedule

(2026-08-02, your asks).** A wiring check now runs inside the gate: any checker that nothing invokes or schedules blocks the commit — aos-8.3's headline failure (nineteen gates nothing ran) is now structurally impossible here, tested with a planted orphan. And a gap-analysis audit (21-day alarm) runs the what-is-missing pass: orphan pages, systems without when-rows, the retrieval-miss backlog, met-but-unclosed deferrals, and the free question of what is absent entirely — its findings feed the deferred table, so gap-to-work uses the existing pipe.

• **Two more pilot functions, both extracted under the promotion rule

(2026-08-02):** add-system — the six wiring moves every new system gets, answering your "how do we ensure it is properly wired without me remembering" (the answer is now a procedure with a mechanically counted run line, not a habit); and evaluate-panel — your debate question wired: whether a judgement call gets no agents, one fresh checker, a jury, or a debate is now decided by named criterion with an artifact, never by habit. Also on the map: the full when-things-fire schedule with the two things that still depend on your memory (opening the docs; pushing — the second now mitigated by an unpushed-commits counter on your phone page), and the scripts-check-form / AI-checks-meaning explanation you asked for. Successor session spawned: Fable, xhigh, remote-control, clean.

• Handover-ready (2026-08-02). The phone dashboard gained real

back/forward history with scroll restore in both directions (agent-built, syntax-verified) and the Proposal tab; republished. The checkpoint marks the handover point: your verdict on docs/11-aos-proposal.md is the next session's first input.

• **Track 2 started on your go and its proposal is ready for you

(2026-08-02, D31).** docs/11-aos-proposal.md — what AOS is, the candidate-kernel claim with its evidence boundary disclosed, six build items (template-with-tether, designed retrieval, the wiki-write system, the learning loop, three-kind evaluation, the grounding check), a seven-item anti-scope, and your three-item decision menu. An adversarial fresh-context review ran before you: it caught a missing deliverable, a strawman, an undisclosed evidence boundary, five evidence defects, and me claiming the review had happened before it had — all fixed, trail in D31. Computer-use check deferred at your instruction (deferred row 7).

• You corrected me, and the correction is mechanism (D30). My D29

threw out the working half of aoe-8.3's step logging with the broken half. Restored on your evidence: every function run now writes a run line (steps done / steps declared, with artifact pointers) and the commit gate mechanically blocks incomplete runs that state no deviation — misses are visible again, exactly the device you described. Still out: self-graded truth verdicts; the count is mechanical, the truth stays with artifacts and audits.

• Turns tracking, the right way round (2026-08-02, D29). Your

per-step-logging question answered from the old repo's own evidence: agent-written step rows invited fabrication there (rows batched 17 to a second against their own rule), so tracking here derives from what chats cannot rewrite — step artifacts, gated commits, and a new Turns tab on your phone dashboard built from git history, each row showing that loop's attestation chips. The old turns-page idea, new data source.

• **The system map exists, ruled by a debate, and everything is on your

phone (2026-08-02).** docs/10-system-map.md: four layered diagrams — context, layers, the enforcement chain, what-updates-when — with solid arrows for enforced links, dashed for discipline-only, and the blind spots named in plain text (D28). Timestamps are now full, real, script-derived clocks, spot-verified by independent Haiku agents 6/6 (D27). The whole docs set, map included, is published as a private page you can read on your phone — the link is in 08-your-actions.md.

• **Your seven-point message of 2026-08-02, each point ruled and wired

(D26).** Highlights: the wiki now has real retrieval content — four system/ nodes derived by the derive-wiki function's first live run, so a fresh chat retrieves the design instead of reading everything; functions are declared open with deviations reported in every commit's attestation line; a function-fitness audit periodically argues against the functions (your status-quo-bias concern); your reading queue is live in docs/08; the dashboard and JSONL conversions are deferred with concrete conditions, not dropped.

• The first three functions exist, on your yes (D25). loop,

retrieve, and derive-wiki now live in working/functions/ in the form you designed — split steps, an artifact proving each step, when-to-use clauses, script bindings, a gate-enforced index. Marked pilots: provisional until the Track 2 proposal rules on the form. Their plain-language accounts are in docs/09-reference-library.md.

• Two more catches of yours, conceded and wired (D23, D24). The

retrieve function was undesigned (boot retrieval existed; mid-task retrieval ran on judgement) and the wiki-write trigger was half-designed (updates on change, but nothing said when new nodes get created). Interim rules are now in the procedure — retrieval failures become recorded demand signals, derivation runs as a split-step at loop close per your own ruling — and the designed versions are named deliverables of the Track 2 proposal. Plus the research gate you asked for: research runs only against a named decision, builds-first when cheap and reversible, researches-first for infrastructure, stops at saturation, and files everything so no question is bought twice.

• **Your three catches of 2026-08-02, answered with mechanisms (D21,

D22).** The two reference documents now live inside the user-facing layer at docs/reference/ — and a markdown file outside every layer is now impossible to commit (the gate caught a planted test file). The boot test re-ran fresh against the changed workspace: every probe answered correctly, five record defects caught and fixed — including a decision cited before it existed and a count that disagreed between two pages. Two new mechanisms: the boot-contract tether (changing CLAUDE.md or the procedure turns the gate red until the boot test re-runs or a visible waiver is recorded — it fired today, correctly), and the Loop attestation (a commit is rejected unless its message names the loop's step evidence, checkable against the commit's own diff).

• The docs now have the wiki shape you asked for — the macro layer.

00-big-picture.md is the top-down root (AOE → AOS → applications → this workspace → its systems), the read order splits into understand-the-system versus follow-the-work, and the micro layers (system pages, page-per-function) grow as Track 2 builds what they will describe (D20; deferred row 5 updated). Alongside it: the Dex Horthy notes you pointed at were verified against his published document — three convergences with what we built, one adopted rule (research briefs carry questions, never my hypothesis), one real discrepancy in your notes' "40% dumb zone", and a role mapping written into CLAUDE.md: your attention goes where his own leverage ranking puts it — readable research, plans, and these docs — while research, evaluation, and direction stay mine to supply (docs/06-source-readings.md).

• Your design inputs of 2026-08-02 are wired as Track 2 requirements

(five of them, listed in docs/05-direction.md), and one thing I had endorsed is corrected in the open: "your role is comprehension" does not survive the evidence in your 07-ai-dev-workflows-v2.md file (sections 4–5, read at your pointer) — what survives is you explaining the system back and having that checked, standing rules written in advance, and disagreements forced open instead of verdicts requested. The correction is marked in docs/06-source-readings.md; the decision trail is D17.

• Track 1 built (2026-08-02), on your yes: the state layer. A fresh

chat now boots from always-current state with no handoff document — the checkpoint file, the boot read-order, the directive inbox, claim marks everywhere, and a mechanical tether that blocks commits when the AI wiki drifts from these docs (tested red and green live). One component was rejected by the baseline rule and that rejection is recorded. Full description: docs/07-state-system.md. App order recorded as you gave it: company-overview → crypto-pairs → rental → trading (D15).

• Frontmatter on every page, enforced (2026-08-02, your directive).

All 24 markdown files now open with created: and modified: dates; the commit gate blocks any commit where an edited file's date was not bumped — so no one has to remember, which was your question. Per-doc change logs: decided against (git already keeps that history with reasons); the readable view of it goes to the future dashboard. Schema, what was left out, and the cost of changing it: docs/07-state-system.md.

• Boot acceptance test: passed, with three real catches (2026-08-02).

A fresh-context agent given nothing but the workspace read the boot path and correctly stated what this place is, what was open, what it would do next, and the rules it must not break. It also caught: this page promising a test result "below" that was not there yet (now it is — you are reading it); the boot read order not covering files the checkpoint points at (fixed: the read order now says to follow the checkpoint's pointers); and this page's old header carrying a stale "last updated" line (fixed: the date now lives only in the frontmatter).

• Your review, worked through. Both source files read directly, with

the earlier evaluation's over- and under-reads filed (docs/06-source-readings.md); how-fable-works.md rewritten without the cap, on guide + launch page, with a source-disagreements section; an agent-teams section added to how-claude-works.md from nine fetched sources; the docs→wiki derivation tested on three real nodes (wiki/); the deferred tracker created (docs/04-deferred.md); the three-track direction proposal written for your yes (docs/05-direction.md); and commits are now blocked by a deterministic inventory check, wired into both Claude Code and git and tested red and green live (D13).

• Deliverable (a) — how-fable-works.md, 296 words (cap 300). Two

rounds of fresh-context checking by separate agents that saw only the document and Anthropic's guide. Round 1 caught three dropped hedges, two claims not traceable to the guide, and no guidance on when not to act. Round 2, on the fixed version, found no contradictions and no untraceable claims, and three sentences a fresh chat could misread — reworded, paid for by trims elsewhere under the word cap.

• Deliverable (b) — how-claude-works.md. Every claim marked docs

(fetched documentation, with the address), observed (seen working in this session), or unverified. Five of the cited pages were fetched twice by independent readers; every quote matched. Its checker confirmed all spot-checked facts and caught real gaps, all fixed: routines (scheduled cloud runs) require the work to live on GitHub; a shared dashboard page cannot use live connector data; and a section on permissions was missing entirely.

• Deliverable (c) — this folder. Its own fresh-context checker verified

three decision entries against their sources (all matched word for word), confirmed the status claims against git history, and caught five defects: two lesson files missing from the inventory page, a stale word count (this page and the inventory had drifted apart — the count now lives only here), a broken "two files above" pointer, and technical terms used in docs/ without plain-language explanations. All five fixed.

• **Answered a question nobody had checked: computer use — the feature

where Claude sees your screen and clicks and types like a person — is not switched on for this Fable session, and the switch is yours to flip.** This session is Fable 5 on macOS with your Max plan; its tool registry (the list of every tool a session can call) contains no computer-use tool. Anthropic's documentation then explained why: it ships as a built-in server that is off by default. The ten-second test is in how-claude-works.md section 13. Evidence trail: working/lessons/2026-08-01-computer-use-fable-evidence.md.

• Read both big investigation reports end to end (FALSIFICATION-2026-08-01.md,

AOE-AUDIT-2026-08-01.md in your old repo's fable-space/external-inputs/) — required before I propose anything about rebuilding AOS.

• Read the required briefing, all under your read-only repo's

fable-space/external-inputs/ folder: CLAIM-STATUS.md (the map of which claims are settled, contested, or never checked), both index READMEs, the session record's sections 4, 5 and 7, User-prompt.md (the downstream task), and seven of the eight numbered files in its reference/ subfolder — the project description, the workspace guide, your open questions, the evidence index, the what-to-distrust file, the ai-dev-workflows evaluation, and your information-architecture decisions.

• Set up the working system: CLAUDE.md, working/procedure.md (with the

explicit commit rule you asked for), working/writing-check.md, and this docs/ folder.

In progress

Nothing mid-build here: the kernel's Track 2 items are delivered (template D34, retrieval D38, wiki-write D40, learning loop and evaluation live in the functions and audits), and the app build sits at your D45 review gate in ../company-overview. What runs on calendars: the audit cycles (due from 2026-08-16) and the deferred rows waiting on your replies.

(This section previously still said "the wiki-write system (build item 3) is next" — five hours after D40 closed it, surviving eight commits that edited this very page. Your staleness message and the audit that answered it are D48; the loop's sweep now names these bottom sections explicitly.)

Waiting on you

One page owns the list — docs/08-your-actions.md. As of now: the slide-documentation review (the app's gate), the context-meter calibration reply, and the Cloudflare push + two answers.

Known open questions

• Whether a Fable session can drive computer use after you enable it — the

one remaining unknown in that story.

• The company-director app's Slack design: Claude's own Slack product needs

a Team/Enterprise plan you don't have; the alternative is a custom integration nobody has scoped. Your call, flagged in how-claude-works.md section 11.

Your actions — the one page listing everything only you can do

Your ask, 2026-08-02: a tracked list of what the user must remember to do. Rule: obligations live only here — other pages point here instead of repeating them (repeating is how two pages disagreed about one fact before). This page is on the boot path, so every chat sees it every session.

Open now

(You marked the dashboard and session rows done 2026-08-02 — you're using both. The links live under Standing below.)

Your reading queue (you asked for this, 2026-08-02)

You said you haven't read the docs yet — in the zone, responding in chat. This queue is the system: what to read, why, in priority order, with honest time estimates. Tell me what you've finished and I strike it; when I write or change a page that needs your eyes, it appears here (that is a step of the work loop now). The queue's length is also your capacity meter — if it grows faster than you clear it, the system is producing beyond its cap, and that is a signal we act on, not ignore.

Standing — always yours, never mine

How this list stays honest — the meta-question you asked

"How will a chat ensure it does this every time?" Three layers, weakest to strongest, stated honestly:

1. Procedure with a proof-output (your aoe-8.3 principle): the loop's close step writes into the checkpoint which files it swept for new obligations — an output producible only by doing the sweep. Weakest layer: a lazy chat could fake it; your own falsification report showed proof-outputs raise the cost of faking without making it impossible. 2. The boot path: this page is read at every session start, so an omission is exposed to the next chat and to you, not buried. 3. The staleness alarm (mechanical): periodic audits — including a re-sweep of this list — have maximum ages; the commit gate itself turns red when one is overdue, which is how "raise it to the chat if too long since an audit" happens without anyone remembering. See docs/07-state-system.md and working/state/audits.md.

The big picture — AOE, top down

The page the whole documentation hangs from. Everything here links one level down; every level down links further, until — as the system grows — you reach a page for every function. Built and planned parts are marked; nothing pretends to exist yet.

AOE — the whole thing

AOE (AI Organisation Ecosystem) is your project: an AI organisation — procedures, memory, applications, and the operators running them — built so that AI work accumulates instead of dying with each chat, and so that you, a non-technical owner, can follow and steer all of it through documentation. Its one-line theory: a real organisation runs on procedures and systems; an AI organisation writes those procedures down as explicit, evaluable steps, without the people-management overhead.

AOS — the operating system inside it (kernel running; proposal accepted, gaps closing)

AOS is the reusable core: the memory-and-evaluation layer any AOE application runs on. Your tightest framing, quoted: "This system is memory + evaluation" — telling a chat "this is how we did this before; use it, change it, or beat it," with improvements persisting and every claim carrying its evidence. A previous full build exists (aos-8.3, read-only case study); its honest audit and falsification are why the rebuild was proposal-first. The proposal (11-aos-proposal.md) was accepted by you in full on 2026-08-02 (D33): this workspace is AOS's first running instance, and the remaining work is closing the named gaps in the accepted build order. Where things stand: 02-status.md.

The applications (planned, in your order)

1. Company-overview app — for a La-Caisse private-equity analyst; rebuilt on the function design that fixes your diagnosed defect in earlier versions. The procedure used to analyse a company and create the overview is itself a deliverable to extract (your 2026-08-02 directive): it becomes a learning source for the crypto app. 2. Crypto app — technical analysis reports (your 2026-08-02 directive; the earlier framing was a most-searched-pairs report — your further info and sample reports will settle the exact shape, deferred row 16). It learns from the company-overview procedure but, your words, "may not be the same": transfer is expected learning, never assumed reuse — each app's procedure earns its own form. 3. Rental-management startup — the agent organisation you can talk to, with the evidence-backed tenant-review design. 4. Trading simulator (AOET) — simulates a person learning to trade, with a learning dashboard and daily updates.

Each gets its own workspace and repository when its turn comes (05-direction.md, Track 3).

This workspace — the current build (running)

aos-8.3.1 (renamed from aos-8.3-blank at your ask, 2026-08-02, to match its GitHub home) is where AOS is being rebuilt properly. What already runs:

• The state system — how any fresh chat continues the work with no

handoff: checkpoint, boot path, claim marks, wiki tether → 07-state-system.md.

• The commit gate — deterministic checks that block commits when the

inventory is incomplete, dates are stale, wiki nodes drifted, or an audit is overdue → described in 07-state-system.md and inventoried in 01-what-is-here.md.

• The two documentation layers — these user-facing docs (the source

of truth, written for you) and the AI-facing wiki derived from them → 09-reference-library.md.

• The reference documents — how the Fable model behaves and what the

Claude platform offers → 09-reference-library.md.

How to read everything

This page is the map's context level. The full layered map — the enforcement chain, what-updates-when, and what nothing watches — is 10-system-map.md; this page stays the one-paragraph-per-thing overview and owns no diagram, so the macro story has one home each per level.

To understand the system, go top-down from this page — each link above goes one level deeper, and as AOS is built, system pages and then function pages extend the tree to full coverage (your rule: you must be able to understand everything).

To follow the work as it happens, read chronologically: 02-status.md (now), 03-decisions.md (why), 04-deferred.md (later), 08-your-actions.md (you).

The state system — how a fresh chat continues the work

Built 2026-08-02 (Track 1, approved by you). This is the first subject-organised page — it describes a part of the system, not a session. It settles the job handed to the Fable chat on 31 July: tracking and working memory, with every stored claim able to tell an assertion from an evidenced one.

The design in one paragraph

There is no handoff document. The durable record — git history plus the docs/ pages — is the source of truth; a small checkpoint file is the cache a fresh chat reads first; the AI wiki is derived and mechanically tethered to its sources; and the commit gate refuses to let any of it drift silently. A new chat boots by reading state that is always current, which was your own framing on 31 July: "there is no handoff system — but a function that ensures working memory state is always kept constant such that new chats can boot."

The pieces

• working/state/checkpoint.md — what is open right now, what comes

next, open questions to you, and directives received but not yet wired into the rules. Small, overwritten at every loop close, never authoritative: if it disagrees with git or docs, they win. This is the Q57 fix — a checkpoint, not a narrative report.

• The boot path — CLAUDE.md (loaded automatically at session start)

sends a fresh chat: checkpoint → status → decisions and deferred → procedure → lessons. This is the Q46 fix: boot reads the always-current state, so there is nothing for a handoff object to patch.

• The directive inbox — your instructions that are not yet wired into

procedure or CLAUDE.md sit in the checkpoint's last section until they are wired or declined-with-reasons. This is the Q25 split: current work and standing directives no longer share one growing file.

• Claim marks — everything stored says how it knows: *docs / observed

/ unverified* in the reference documents, sources or "nobody has checked this" in decisions, could-be-wrong: lines on wiki nodes and memory. This is the assertion-versus-evidence rule from the 31 July job.

• The wiki tether — every AI-wiki node records a fingerprint

(source-sha) of the page it was derived from. The commit gate recomputes it: if a source page changed and its nodes were not updated, the commit is blocked with "wiki node STALE". Tested live 2026-08-02: editing how-fable-works.md turned both derived nodes red; reverting cleared it. (Design carried from the one drift problem your old repo actually solved — its 84/84 source-hash tether.)

What was deliberately not built

A separate append-only log file. The null-procedure test killed it: git already records every loop (one gated commit each, with a descriptive message), and docs/02-status.md already gives you the readable version. A third copy would be maintenance without new information. This is the first component rejected by the baseline rule — recorded so the rule visibly does work.

The frontmatter system (added 2026-08-02, your directive)

Every markdown file in both layers opens with a small labelled block — "frontmatter" — of machine-readable facts about the file itself.

The schema, version 2 (your 2026-08-02 directive: full timestamps) — still deliberately minimal:

• created: — the full timestamp (to the second, with timezone) of the

file's first git commit — derived by script from history, never typed, so it cannot be fabricated.

• modified: — the full timestamp of the last change: the last commit

touching the file, or the filesystem's own clock for a file edited since. Bumped by working/checks/stamp_timestamps.py --touch; enforced, not remembered: the commit gate rejects any staged markdown whose modified: is not a full ISO timestamp from today. (Milliseconds exist only in the filesystem and do not survive cloning; seconds is git's native precision, so seconds is the honest maximum — a finer number would be decoration.)

• AI-wiki nodes additionally carry source:, source-sha: (the tether)

and could-be-wrong: — already described above.

What was considered and left out, so the schema stays screenable: status: (draft/final — invites permanently-stale drafts), author: (everything is model-written; git records which session), version: (git is the version history), tags:/type: (useful for retrieval at a scale we have not reached; the folders are the taxonomy today).

Per-doc change logs: none, decided. Git already records every change to every file with a reason (the gated commit message), and docs/03-decisions.md holds the "why" for anything that mattered. A hand-maintained log in each file would be a third copy of the same facts — the exact duplication that made two pages disagree about one word count yesterday. The readable version of per-doc history belongs in the future web dashboard, tracked as deferred item 11.

How the schema evolves, and what changing it costs. The schema in force is the check script (working/checks/inventory_check.sh) — one consumer, one place to change. Policy: new fields arrive optional by default (old files stay valid; cost near zero). Making a field required is a migration: a scripted pass over every file (minutes at today's ~25 files, still scripted-minutes at hundreds) — but the real cost is yours, because a migration touches every file and you screen diffs, so required-field changes are batched, rare, and get a decision entry. Renaming or removing a field is the most expensive kind once dashboards or other tools read the frontmatter — every consumer must move in step — so names are chosen as if permanent.

The acceptance test

Your own test from the old workspace, adapted: no handoff exists — a fresh-context session boots from the state alone and correctly states what this workspace is, what is open, and what it would do next. Run after every change to the state system. First run: 2026-08-02, result in docs/02-status.md.

The system map — how everything works together

You asked to see all the systems as one picture, macro to micro. This page is that picture, built to the ruling of a three-position debate (recorded in D28): layered diagrams with prose, one concern per diagram, every arrow labelled with what enforces it — and a plain section on what nothing watches, because a map that hides its own blind spots is a dashboard with better manners.

How to read the diagrams: solid arrows are mechanically enforced (a script blocks or a fingerprint check turns red). Dashed arrows are procedure-only — a written rule with no mechanism, held up by discipline and periodic audits. The dashes are the honest part.

As-of markers: the enforcement diagrams describe working/checks/inventory_check.sh @ ea39b8e68642 and working/functions/loop.md @ 6fd3ad745573. If those fingerprints no longer match the files, this page is stale and the docs-verification audit is charged with catching it.

Level 0 — who and what (the context)

You, one working chat at a time, and three outside places. No technology detail at this level, on purpose.

flowchart LR
    J[Josh - owner, screens everything]
    C[The working chat - director]
    W[(This workspace)]
    G[(GitHub - lotivus/aos-8.3.1)]
    A[Cloudflare Pages - phone dashboard]
    O[(aos-8.3 - old repo, read-only)]
    J -->|directs, reads docs, catches| C
    C -->|writes, commits| W
    J -.->|push - yours alone| G
    C -->|publishes snapshot - commit+push, owner grant D49| A
    J -->|reads on phone| A
    O -->|evidence only| C

The old repository is read from, never written — an honour rule, and the map says so below rather than pretending otherwise.

Level 1 — the layers inside the workspace

Everything lives in exactly one layer (a markdown file outside all of them cannot be committed — you caught the two files that once sat nowhere, and that class of error is now blocked).

flowchart TD
    D[docs/ - user-facing, source of truth]
    R[docs/reference/ - the two reference works]
    K[wiki/ - AI-facing atomic notes]
    S[working/state/ - checkpoint + audit receipts]
    F[working/functions/ - the five functions]
    X[working/checks/ - scripts, hooks, builders]
    GT[(git history - the durable record)]
    D -->|derives, sha-tethered, gate-enforced| K
    R -->|derives, sha-tethered, gate-enforced| K
    X -->|update-triggers node derives from the gate script| K
    D -.->|renders into phone snapshot| A2[dashboard page in working/artifact/]
    F -->|governs each loop| GT
    X -->|blocks bad commits| GT
    S -->|receipts read by gate| X

Two wiki nodes derive from AI-facing sources rather than docs/ — a D28 ruling: research-gate from working/procedure.md, update-triggers from the gate script itself, so the machine account of the gate cannot silently drift from the code.

Level 2 — the enforcement chain (what blocks a commit)

One script is the gate; three hooks wire it so it cannot be skipped by forgetting. working/checks/inventory_check.sh @ ea39b8e68642:

flowchart TD
    E[chat edits files] --> GA{inventory_check.sh}
    GA -->|every file described| I1[docs/01 inventory]
    GA -->|every node indexed + sha fresh| I2[wiki/index + tethers]
    GA -->|every function indexed| I3[functions/index]
    GA -->|layer rule: every .md in one layer| I4[layers]
    GA -->|full ISO timestamps, bumped today| I5[frontmatter]
    GA -->|no audit overdue, boot contract unchanged| I6[audits.md]
    GA -->|no unwired checkers, run counts complete| I7[wiring + runs]
    GA -->|red = commit refused| H1[Claude Code hook + git pre-commit]
    H2[git commit-msg hook] -->|Loop: attestation required| GT2[(commit lands)]
    H1 --> GT2

Level 2 — what must update when you change something

The question behind your "how will chats know what to update": here is every trigger, with its truth told by the line style.

flowchart LR
    DE[edit a docs page] -->|tether turns red until node reviewed| WN[wiki node]
    DE -.->|rebuild + publish to the Cloudflare repo - procedure only| DA[phone dashboard]
    DE -.->|queue row for Josh - procedure only, weakest link| Q[reading queue in docs/08]
    NF[new file] -->|gate red until described| INV[docs/01]
    BC[edit CLAUDE.md or procedure] -->|contract fingerprint red until boot test| BT[fresh boot test]
    AU[audit overdue] -->|gate red names it| CH[the chat, forced]
    LP[close a loop] -.->|status, decisions, deferred, checkpoint - attested, self-declared| REC[the record]

When things fire — every trigger by occasion

Your question: not just what connects, but when — and whether you must remember anything. The full schedule:

Two kinds of check, on purpose — scripts for form, AI for meaning. inventory_check.sh is exactly what it looks like: a shell script (a program a computer runs the same way every time), and scripts can only check what is mechanical — a file exists, a count matches, a fingerprint is fresh, a date was bumped. You are right that this cannot cover everything: whether a page is stale in meaning, whether the wiki contradicts itself, whether a function deserves to exist — those need judgement, so they are AI-run checks: the boot tests (a fresh agent grades the workspace), docs-verification (it caught three meaning-staleness defects the script could never see), wiki-lint, obligations-sweep, function-fitness, and the fresh-context reviews of deliverables. The trick that joins the layers: the AI checks are on the audits table with maximum ages, and the script blocks commits when an AI check is overdue — so the mechanical layer forces the judgement layer to keep happening, and neither pretends to do the other's job.

And the honest answer to "do I have to remember anything": yes, two things — both named as gaps, one now mitigated:

1. Opening the docs or dashboard at all. The system maintains your queue and your actions page, but nothing pushes to you — you ruled the Telegram channel deferred until a real use case existed (deferred row 6). By your own criterion in this question, a system that relies on you remembering to check it has a gap: this may be that use case. Your call, row 6 unchanged until you make it. 2. Pushing to GitHub. Nothing is lost locally if you forget, but nothing is backed up either. Mitigated now: the dashboard's receipt strip shows the count of commits not yet pushed, so the reminder is in the page you already open — not in your memory.

What nothing watches — the blind spots, named

The debate's judge required this section, and the graph extraction found these; each is real today:

• The enforcement layer does not watch itself. The gate script, the

hook wiring in .claude/settings.json, and the one-line git configuration on a fresh clone are outside every check. A change to the checker is caught by no checker — only by boot tests and your reading.

• The reading-queue feed is procedure-only. If a loop forgets to

queue a changed page for you, nothing turns red — and the queue is the system's only feed to its one human check. This is the weakest link on the map.

• The attestation is self-declared. The Loop: line must exist

(enforced) but its claims are the chat's own word, checkable against the diff but only sample-audited. Narrower since D30: each function run's step count is now checked mechanically against its declared list (incomplete runs with no stated deviation block the commit); what remains self-declared is the truth of the pointers, not the count.

• wiki-lint first ran 2026-08-02 (receipt in

working/state/audits.md): it caught two contradictions, two superseded claims, and one lapsed derivation — all fixed that loop. Between runs, under-derivation still rests on judgement.

• The map's as-of fingerprint proves version, not completeness. A

chat can bump the fingerprint after editing a gate script without updating this page's prose — the mechanical guard passes while the account goes stale. It happened once (enforcement-review r1 caught the gate row missing four live rules, added the same loop); docs-verification's diagram-vs-script charter is the standing catch.

• Template skeletons can drift from kernel rules. The page blanks

in working/template/ are not tethered to the rules they mirror; the kernel-tether audit's charter reviews them on its 21-day cycle (judgement, not a gate). Same class: the writing check is copied into apps unlocked, so its rules could drift there between audits.

• Honour rules: the old repo's read-only status and never-pushing

to GitHub have no mechanism at all.

Since 2026-08-02, at your suggestion, the watchable parts of these are governed by scheduled checks: an enforcement-review audit (21-day cycle — reads the gate and hooks against this page's account, plants a red to prove the block, samples commit attestations against their diffs, and reports any writes in the read-only old repo), and the obligations-sweep audit's charter now requires diffing changed pages against your queue (AI-run on the alarm, per this page's own distinction). Two limits stay stated: the review rides the same alarm system it audits (boot tests are the independent layer), and the external watcher — a cloud routine or CI examining the repo from outside — becomes possible exactly when you push to GitHub. Deferred row 13 narrows to that external half.

Where the micro levels live

Below this page, the map hands over to the pages that own each part: 07-state-system.md (state and boot), 09-reference-library.md (reference works, functions, wiki), 01-what-is-here.md (every file), and — for chats, not for you — the wiki's system/ nodes, including update-triggers, which is derived from the gate script itself so the machine version of this page cannot silently drift from the code.

The AOS proposal — what to build, what exists, what never to build

Verdict: accepted in full, all three menu items, 2026-08-02 — your message in the successor session; recorded as D33. This page is now a ruled document: its body stays as you accepted it, and changes to what it decided need a new decision entry, not an edit here. Point-in-time claims in the body (e.g. "wiki-lint has never yet run") are as of acceptance; working/state/audits.md and the decision log carry the current truth.

Track 2's deliverable, started on your go of 2026-08-02. This is the document you approve, amend, or reject before AOS construction goes further. Target: readable in one sitting. Every part cites its evidence; parts resting on my judgement say so. Before reaching you, this page was adversarially reviewed by a fresh-context agent against your standing requirements: it found a missing deliverable, a strawman in the template argument, an undisclosed evidence boundary on the central claim, and five evidence defects — all fixed in what you are reading; the findings and fixes are itemised in D31, so you can see what the review changed.

The one-line theory, unchanged

AOS is memory + evaluation: the layer that makes AI work accumulate without being trusted — "this is how we did it before; use it, change it, or beat it," with improvements persisting and every claim carrying its evidence. Your line, and nothing this session found argues against it. What the session's evidence did change is the how, below.

The central finding: the kernel already exists — Track 1 built it

This is the proposal's most important claim, so it comes first: AOS is not a blank-page design. The workspace you are reading is its first running instance. What Track 1 and your review-driven loops produced is not preparation for AOS — it is AOS's kernel, live and tested:

• State without handoffs — checkpoint + boot path; five fresh-boot

tests passed (receipts: working/state/audits.md; design: docs/07-state-system.md).

• Functions in your form — split steps, forced artifacts, matching

by when-to-use clauses, bindings to the scripts they use, open (a chat may deviate, reporting why in the commit), run completeness checked mechanically (working/functions/, D25, D30) — with code underneath for what AI does badly (clocks, counts, hashes), per the three-actor rule.

• A derived wiki with tethers — nodes fingerprinted to sources;

drift blocks commits (D12, D21).

• Enforcement that costs something — one gate, three hooks, audits

with staleness alarms; red blocks, tested repeatedly (D13, D18).

• The human layer — docs as source of truth, the reading queue as

your capacity meter, obligations on one page, explain-back and forced disagreements as your role (D16–D19, docs/06).

The evidence boundary on that claim, disclosed: everything above was proven on a self-hosting workload — the kernel tested itself while building itself — and the two audits designed to argue against it (wiki-lint, function-fitness) have never yet run. The honest form is: a candidate kernel, proven only on itself; the first application is its real test. The reviewer pressed exactly this ("calling one session's conventions a kernel converts 'approve a design' into 'ratify what I already built'"), and the answer is to put the claim on your decision menu below rather than smuggle it as a finding.

So Track 2's real question — if you accept the candidate-kernel claim — is not "what should AOS be" but "what is missing between this kernel and the applications, and what must never be added." My judgement; yours to reject.

What is missing, in build order

1. The template: how an application workspace inherits AOS

Each app gets its own repository (ruled in 05-direction.md, Track 3). What it inherits from here: the checks and hooks, the functions folder, the CLAUDE.md skeleton, the docs skeleton (00/01/02/03/04/08 pages, empty), the wiki schema, and the audits table with baselines. Three mechanisms exist, and you should see all three (the reviewer caught me presenting only two):

• Live-shared kernel (all apps import it, changes apply everywhere

at once) — rejected: a change in one place silently changing every app is aos-8.3's auto-updating canon with better plumbing.

• Pinned shared kernel (one copy, each app pinned to a version;

upgrades are an explicit pin-bump) — the engineering-standard middle; strongest on no-duplication, but it adds git-submodule-style friction you would feel directly, and the cloud routines that run apps clone one repository per run, which a shared kernel complicates.

• Template-by-copy with a version file and a kernel tether — each

app copies the kernel, records the kernel version it copied, and a periodic audit compares each app's copy against the source and turns red on unexplained divergence. The tether answers the reviewer's strongest objection (N diverging copies of the gate scripts with a known bug re-fixed N times, detected by nothing): divergence stays possible — apps may legitimately differ — but it is visible and reasoned, never silent.

Recommended: the third. (My judgement; the reviewer's attack improved it; your call.)

One rule of yours added while you were reading (2026-08-02): every app's spec and prompts name their target model, and Fable-targeted specs draw on Anthropic's Fable prompting guide plus reference/how-fable-works.md — adjusted, not copied, when the target is another model.

2. Retrieval, designed (currently an interim rule + pilot)

The step-split form already exists as the pilot (working/functions/retrieve.md: state the need as a question → read the indexes → judge each candidate with a reason → read what matched → found/partial/missing verdict, an artifact at every step). The designed version adds: routing (booting is a specialised retrieval already served by the boot path; other specialised retrievals route the same way, chosen by context and said so in the attestation), and scale triggers — index-scanning is claimed workable to roughly hundreds of pages by your llm-wiki source (an assertion in a deliberately abstract file — weak support, marked as such), so the real trigger is recorded retrieval misses: search machinery (ranked text-search — a tool that scores pages against the question — or similar) is added only when misses cluster, never pre-emptively. aos-8.3 built retrieval machinery below the scale where it pays; that mistake is named in docs/06.

3. The wiki-write system (the review caught this missing entirely)

When knowledge gets created, not just kept fresh — the half the tether does not cover. The rule, from your own ruling plus the pilot: at the close of accepted work, the loop itemises what changed that a chat would later need to retrieve (the list is mandatory; a verdict without the list is the rubber-stamp), then per item: derive now into a tethered node, or defer with the reason written beside it. What catches under-derivation: the wiki-lint audit — contradictions between nodes, orphans, claims newer sources superseded, and derivation debt (deferrals that never converted) — which has never yet run; its first real run is due inside its 14-day window and is part of accepting this proposal.

4. The learning loop: promotion and retirement

The half of "memory + evaluation" that is genuinely yours to prove — the positioning research found no vendor documenting agent-improved procedures across a roughly nine-vendor sample, with one adjacent exception it first dropped (Anthropic's memory-versioning beta); the narrower claim survives, marked. Concretely:

• Promotion: a procedure enters working/functions/ only from real

work — extracted after something was done successfully at least twice, never designed speculatively. (Your dogfooding rule; the 30-functions-in-5-days failure is the counter-example.)

• Improvement: a chat that deviates from a function and does better

writes the improvement back — the deviation trail (deviations= + run lines) is exactly where improvements surface. Fable's documented strength at updating procedures mid-task is the tailwind here.

• Retirement: the function-fitness audit argues against every

function on a cycle — null-procedure comparisons (does the function beat plain chatting — "doing without it" — on real work), unused functions, silent deviations. aos-8.3 added 30 and deleted 0; the deletion mechanism is not optional equipment.

5. Evaluation, with its three kinds kept separate (D26)

Fitness-before-use (cheap check against an artifact), execution completeness (mechanical — built, D30), and architecture quality — which only outcome-grading catches: boot tests, audits, baselines, and your reading. Agent debates are reserved for judgement calls where the judge cannot read the primary material (the evidence-backed boundary in the agent-teams research); everything else uses one fresh-context verifier. Switching any check off is a logged, costly act.

6. The grounding check for application outputs

Every output claim traces to a fetched source or is marked unverified — machine-checkable, and the generalisation that survived your demolition of my crypto-grader argument (D14). This is the apps' honesty floor from day one; quality grading comes later and is workload-specific.

What is deliberately never built (the anti-scope)

Each of these died on evidence this session; building it again needs new evidence, not enthusiasm:

1. Agent-written truth verdicts over agent-written logs (the CONFIRMED machine) — falsified at source; D29/D30 hold the line: count mechanical, truth from artifacts and audits. 2. A separate episodic store — session transcripts and git history are the episodic record: not written by the graded party (transcripts) or unrewritable in silence (git), though commit contents are still the chat's own words; distill into wiki/functions on demand. 3. Handoff documents — five boot tests say the state layer replaced them. 4. Per-doc change logs, duplicate "doc versions", parallel copies of any fact — the drift machine, caught three times in this workspace (D19's count) plus once in the checkpoint (D22). 5. Search/RAG infrastructure below the scale that pays — misses first, machinery after. 6. A dashboard as the primary anything — always a derived renderer with receipts (the judge's anti-dashboard ruling, D28). 7. More functions than the screening capacity bears — the queue is the meter; past the cap, retirement before addition.

Sequencing and cost

1. Close the kernel gaps (template + designed retrieve): one to two sessions here. 2. First app: company-overview (your order, D15) in its own repo from the template — the dogfood that tests promotion for real. Days to weeks, with your domain guidance. 3. Crypto-pairs report follows, learning from the company-overview research procedure with you guiding the extraction (deferred 10).

Costs stay bounded by the same rule as ever: your reading queue is the budget; anything that outgrows it waits or retires something else.

How we will know AOS works (its own acceptance tests)

• A fresh chat in a new app workspace boots from the template and

does real work correctly — the boot test, exported.

• A procedure demonstrably beats the null procedure on a real

workload at least once — the first evidence the evaluation half earns its cost.

• An improvement made mid-task by one chat **survives into the next

chat's run** — the learning loop observed end to end.

• Every app output passes the grounding check mechanically.
• You can explain the system back from the docs alone — and the

explain-back is checked against the system, per docs/06.

What this proposal asks of you

Approve, amend, or reject, item by item:

1. The candidate-kernel claim — that this workspace is AOS's first instance and Track 2 is gap-closing (the reviewer's counter-position is quoted above; rejecting it means commissioning a fresh design). 2. The six build items, especially the template mechanism (copy-with-tether recommended over pinned-shared and live-shared — it shapes every app) and the promotion-from-real-work-only rule (the discipline aos-8.3 lacked; it will sometimes feel slower than designing functions up front, and that feeling is the failure mode wearing productivity's clothes). 3. The seven-item anti-scope.

How an application workspace is born — the template

Build item 1 of the proposal you accepted (D33). This page is the user-facing account of the system that turns "each app gets its own repository" (your Track 3 ruling) into a mechanical act instead of a from-scratch rebuild each time.

What it is, in one paragraph

One command creates a complete, working app workspace: a script named make_app_workspace.py (in working/checks/) copies the living kernel — the commit gate, the hooks, the five functions, the working rules — into a fresh folder, fills in ready-made page skeletons (a boot file, empty docs pages, a fresh checkpoint, an audits table with its alarms already ticking), writes down exactly what it copied and from which kernel version, arms the commit gate, and makes the workspace's first commit. That first commit must pass the new workspace's own gate — if it cannot, the spawn refuses to finish. So there is no moment where an app workspace exists ungoverned.

The mechanism you chose, and how each part shows up

You accepted template-by-copy with a version file and a kernel tether over the two alternatives (live-shared and pinned-shared — docs/11 §1 has the argument). Concretely:

• Copy — the app gets its own physical copy of every kernel file;

nothing is shared live, so a kernel change never silently changes a running app (the old repo's auto-updating-canon failure, kept dead).

• Version file — working/state/kernel.lock in each app records

the kernel version copied (the exact commit), when, and a fingerprint of every copied file.

• Tether — kernel_tether.py (copied into every app, run by the

app's own commit gate at every commit, and re-run deliberately by the app's audits table) re-checks those fingerprints. A copied file that changed with no written reason blocks the commit; a change with its reason recorded beside it in the lock is fine — divergence stays possible, but visible and reasoned, never silent. Each reason is pinned to the exact state of the file it excuses, so a file that changes again turns red again — this workspace's adversarial reviewer caught the unpinned version quietly excusing every future edit, and the pin is the fix. This answers the strongest objection to plain copying: N diverging copies with a known bug re-fixed N times, detected by nothing. The tether also reports when the kernel has moved ahead of the app's copy, so upgrades are a visible choice, not an ambush.

What an app inherits, exactly

The checks and hooks (the whole gate), the five functions, the working rules (procedure.md), the writing check (with an empty usage log — the log is the app's own history), the wiki schema (with this workspace's history paragraph stripped — kernel history is false in an app), ready-made empty docs pages (big picture, inventory, status, decisions, deferred, your actions), a fresh checkpoint, an audits table whose staleness alarms start on spawn day — including its own kernel-tether and enforcement-review rows — and the app's default target model, recorded at spawn per your naming rule. Deliberately not inherited: this workspace's task-specific content (its decisions, lessons, wiki nodes), and the permission mode of the AI harness — that is set by you per workspace.

Proven, not promised

Tested live on 2026-08-02 by spawning throwaway apps into a scratch folder: the spawn produced a green gate, a green tether over the locked files, and a passing initial commit; editing a locked file without a reason turned the tether red naming the file; a pinned reason turned it green; editing the file again turned it red again. An adversarial fresh-context reviewer then attacked the whole system and its findings were fixed and re-tested the same loop (the trail is in the decision entry). The first test spawns ran with the template still uncommitted (marked +dirty in their lock), so after the template was committed the spawn was re-run against the clean tree: green end to end, and this time the lock names a kernel commit that verifiably contains exactly what was copied. The spawn also failed honestly during development — its own gate refused a workspace with a malformed audits table, which is the refusal doing its job. Receipt: the kernel-tether row in working/state/audits.md.

What nothing watches, said plainly

• Skeleton drift: the ready-made page skeletons live in

working/template/ and nothing mechanical forces them to evolve when kernel rules evolve — the kernel-tether audit's charter includes reviewing them, which is a scheduled judgement check, not a gate.

• The writing check in apps is copied but not locked (its log must

stay writable), so its rules could drift in an app unnoticed until an audit reads it.

• The lock itself is unguarded: a chat that edits a locked file and

then edits the lock's fingerprint to match would stay green — the perfect silent divergence. Git history records the lock edit; the kernel-tether audit's charter samples app git logs for exactly that move, and the check is run with the kernel's copy of the tether script, not the app's possibly-edited one. Judgement-layer defence, stated as such.

• The upgrade path is one real run old, not yet a procedure — the

first hand upgrade happened 2026-08-02 (the gate script re-copied into company-overview and re-locked, hours after the app's birth — D46); the written procedure waits for the second run, per the promotion rule (deferred row 15).

• Apps the kernel cannot see: the tether runs inside each app; from

this repo it reaches sibling folders only while they exist on this machine. Once apps live on GitHub alone, the external-watcher story (deferred row 13) applies to them too.

The company-overview app — plan for building it on our kernel

Written 2026-08-02 on your pointer to company-overview-app-info in the old repo. Everything below rests on a full read of that folder: your forensic audit (read directly), the old skill and its one real test run, and the authoritative specs and benchmark slides (each read end-to-end by a scoped fresh agent, quotes verified). This is the page you rule on before the app workspace is spawned.

What the product is

A one-page, investor-facing company profile slide, produced for a named client firm (currently La Caisse — your own note on the benchmarks asks for a settings toggle so the producing firm is configurable). The analyst's tier-1 spec fixes the content: a 3-to-5-bullet company description capped at 100-150 words, a segments table, sector-adaptive operating KPIs, and a financials block with declared currency and fiscal-year-end. The tier-2 brief fixes the presentation register: company name only in the header, a 15-25-word one-liner, "founded in" not "incorporated", charts that carry a takeaway ("KDDI will roll over 20% equity post-transaction"), investor-ready — "not a raw research summary". Seven real analyst slides are the benchmarks, explicitly below the specs in authority.

What the previous build taught us — the expensive lessons

Your audit of the old build is the most valuable asset in the folder, and its verdict maps almost exactly onto what this kernel was built to prevent. The one-line version: a genuinely good content pipeline failed because its verification only ever checked the pipeline's own derived artifacts — so a requirement that lived only in the sources (the La Caisse mark on every slide) was lost at extraction, demoted to "optional", invented as a placeholder graphic at render, and then waived by an audit whose prompt the producer itself had written. Six links broke; every gate was green; the slide was wrong.

What we carry forward as standing requirements for the rebuild (from your audit's fixes, generalised):

1. Verification anchors to the sources, never only to derivatives. Every audit of a slide gets the tier-1/tier-2 specs and a benchmark image as inputs, and runs a presence-diff — PRESENT/ABSENT by id — against a required-elements floor. Correctness checks catch wrong content; only a presence-diff catches missing content. 2. House furniture is first-class. A required-on-every-slide list (firm emblem as a real image asset, company logo, header divider, one-liner, source strip) that never yields under space pressure, with an ASK-don't-fallback rule when an asset is missing. 3. The producer never authors, scopes, or waives its auditors' prompts. Audit prompts come from fixed templates; a waiver that exists only in a prompt is itself a FAIL; blocking verdicts are closed only by a fresh agent or by you. (Our kernel already lives this rule — the enforcement-review audit checks who closed what.) 4. "Never invent" covers graphics and assets, not just numbers. An unresolved placeholder at ship time is a hard FAIL or an ASK. 5. Hedged identity never weakens a confirmed requirement. A mark present on 7/7 benchmarks is REQUIRED even while unidentified — escalate the identity to you; never quietly demote to "optional". 6. Mine the predecessor's failure ledger. The old lineage had already fixed this exact bug once; the rebuild discarded the fix with the architecture. Our version: the old audit's findings become the new app's seed lessons, imported at spawn.

And what the old build got right, worth re-deriving (not porting): situation-first research that classifies the use-case early and re-prioritises everything; the two honest closure states (SOURCED vs UNAVAILABLE-AFTER-SEARCH with sources-tried recorded); takeaway lines decided at content-selection, not design; one machine-checkable fact store where every on-slide number traces to a claim with source, tier, and verdict; a pre-committed yield order with a no-yield floor and logged drops; rules that cite the benchmark defect that motivated them.

Not carried: the character-count fit model (it blew its own repair budget 6-cycles-to-2 — fit needs real measurement, not estimation), the six-file cross-referencing knowledge lattice, and the toolchain whose geometry contradicted its own typography rules.

The build approach — macro to micro (your design, 2026-08-02)

Your directive, and it becomes the build's shape: simulate how a real analyst works, and build the understanding before the machinery.

1. First, our own documentation of the slide — user-facing pages explaining how the product works. Your question — macro to micro, or micro to macro? — the answer is both, one per stage. The analysis runs micro to macro: every element of every benchmark slide is evaluated on its own (each bullet point's purpose, how it works with everything else toward the slide's goal), then the commonalities are found across the seven — which is also exactly the cross-slide pass whose absence lost the La Caisse mark last time. Alongside it runs your rebuilding analysis per slide: to build this slide, how did they likely find that information, and how did they decide what made the slide out of everything they must have found — the selection judgement, reconstructed. The documentation is then written macro to micro for you: slide → header/body/footer → components → formatting detail (the strict header — La Caisse logo left, company name, company logo right; main font ~12, references ~10, big title fine), each claim citing its slide evidence. Raw material exists: a recon.yaml per benchmark image (your recollection is right), plus the specs. Components, never whole-slide templates: parts and the evidence for how they combine, so a new slide is composed the way an analyst would compose it — a real analyst might choose a different format, and the system must be able to. This is your stop point (your directive): the app build halts at this human-facing documentation for your review. Nothing below starts until you've read it. 2. After your review: the AI wiki, then the procedures — the same docs-to-wiki derivation this kernel runs on, applied inside the app. The macro procedure first — your research loop: research → evaluate the research and ask what's missing → research more → until the information and its evaluation are good enough for the slide's goal — then the micro procedures it calls (logo retrieval, component selection, per-component design under the visual constraints). 3. Then the first real run grades it all. The procedures derive from evidence (the analysts' actual output, rebuilt), not from speculation — but they are still provisional until a real company run has used them, the same pilot-then-ratify pattern this kernel itself went through. What the run teaches gets written back before anything is called standing.

Authority — ruled by you, 2026-08-02

• The tier-2 brief is your analyst's experienced judgement, not law

(your words: ten years of judgement, "doesn't mean we should make rules that it can't be done"). Encoded as defaults with declared deviation: a run follows the brief unless the company genuinely warrants departing, and every departure is logged with its reason and surfaced for your (or the analyst's) review — never silent. This is the same open-functions rule the kernel runs on: not-following leaves the same trace as following. Reviewed departures become feedback that improves the defaults — the learning loop, applied to slide-making.

• A small floor stays hard (mechanical FAIL, not judgement): the

strict header format, house-furniture presence, font floors, the source strip, and never inventing facts or graphics.

• **The benchmarks are evidence, not perfection, and not current —

noted, at your instruction. They sit below the specs, they contain known defects (the old evaluations catalogued them: six of seven charts lacked takeaway lines, one had an accounting-impossible chart), and they are not up to date** — the slide documentation dates each one and treats its conventions as evidence of practice at that time, not as today's standard. Copying them wholesale is exactly what the component decomposition exists to avoid.

How the app sits next to this workspace (your entry-point question)

Your chat entry point stays here — one cockpit. The app lives as a sibling folder with its own repository (../company-overview): its own commits, its own gate, and its own management layer — a fresh status page, decisions log, deferred table, your-actions page, checkpoint, and audits table all exist from the moment of spawn; that is what the template creates. I work in both folders from this one conversation; each repo keeps its own history. The app is wired to AOS exactly the modular way you described, with the safety you accepted in the proposal: it copies the kernel's functions and machinery (locked, with the tether watching for silent divergence) rather than sharing them live — so kernel improvements reach the app as visible upgrades, never as silent mutation, and the app's own procedures and knowledge grow in the app, not here. Later, if you want a dedicated chat living inside the app folder, its boot file already exists; that is a convenience decision for you, not a rebuild.

How it runs on our kernel

• Its own workspace, spawned by make_app_workspace.py (D34): it

inherits the gate, the functions, the audits with alarms, the state layer — governed from its first commit. The authoritative specs and benchmarks copy in as read-only references; your audit's findings seed working/lessons/; the la-caisse asset ships as a real file.

• **The app's procedures are derived from evidence, then earned by

running** — the macro-to-micro build above derives them from the analysts' real output (not speculation), they enter as provisional pilots, and the first real company run — done as ordinary loop work with you guiding — is what ratifies, corrects, or retires them: the same pilot-then-ratify path this kernel took, and the discipline the old build's 30-functions failure teaches.

• The grounding check is the honesty floor from day one (docs/11

§6): every claim on a slide traces to a fetched source or is marked unavailable-after-search — the old build's factpack idea, kept.

• Evaluation uses our existing instruments: fresh-context

verifiers with template prompts the producer cannot edit, the presence-diff as a mechanical check in the app's gate, and your reading as the outcome grade. The old build's V1/V2/V3 pattern (facts, design, pixels) survives as the shape of the app's checks — re-anchored to the sources per requirement 1.

Cost, honestly: days to weeks, across multiple sessions, with your domain guidance at the start (the decision menu below) and your eye on the first slides. The first run is deliberately slow — it is also the extraction run the crypto app will later learn from (deferred 10), and you said the procedures "may not be the same"; nothing will be assumed to transfer.

What the authority ruling settles, and what stays open

Your defaults-plus-declared-deviation ruling dissolves most of the old decision menu: the management section defaults to OFF (the brief), layout is derived with two-column as the prior (never four-quadrant by default), the investment thesis stays deferred, and the word cap counts everything in the block — and in each case a run may depart for a company that warrants it, with the departure logged and shown to you. The producer-identity settings file ships at spawn, defaulting to La Caisse (your benchmark note).

Still open, yours:

1. The go to spawn — the workspace is created the loop you say so. 2. The first company — name a target, or I propose one from a fresh screen once the workspace exists.

Direction — the three tracks, sequenced

Written 2026-08-01 in answer to your review message; status updated since. Track 1: you said yes on 2026-08-01, and it is built (see docs/07-state-system.md). Track 2: awaiting your go, and now carries six standing requirements you set on 2026-08-02 (listed under Track 2). Track 3: waits for Track 2, app order fixed in D15. Costs are honest ranges, not quotes — I cannot see token prices from here, so cost is given in sessions and in what you have to read.

Where the work happens — your question, answered first

We design in this workspace. Nothing gets fixed in aos-8.3. Reasons, so you can disagree: your brief made aos-8.3 read-only and everything I create lands here; the falsification report showed the old system's verification cannot be trusted from inside, so patching it means inheriting what nobody can currently grade; and its useful parts are ideas and evidence (the verdict vocabulary, measure-don't-predict, the source-hash tether, the case history), which carry over as designs, not as code copied across. aos-8.3 stays what it has become: the best-documented case study we have. If you want something in it changed, that is a separate decision you make explicitly.

Track 1 — tracking and working memory, designed here

What it is. The job you handed the Fable chat on 31 July, lost, and recovered from STATE.md rows Q57, Q46 and Q25: a state layer such that a fresh chat boots from always-current state instead of a handoff document (Q46), the working record is a resumable checkpoint rather than a narrative report (Q57), a chat's current work lives in a per-chat working document separate from the directive inbox (Q25) — and every stored claim is marked assertion or evidenced (the claim-quarantine rule, which this workspace's decisions log already practises).

What you get. A fresh chat resumes work with no handoff prompt (your own acceptance test: delete the handoff, boot, continue); a docs page per component so you can follow it; the substrate Tracks 2 and 3 write into.

Cost. One to two focused sessions. Reading for you: the design page plus one decision per component (roughly 30 minutes).

Track 2 — the AOS direction proposal, panel-reviewed

What it is. The propose-first rebuild decision your brief requires: a design document arguing what AOS should be (drawing on the case study, the positioning research, and the source files I have now read myself), then a review before it reaches you — one fresh-context verifier at minimum, a mixed-model jury on the contested judgements. Full opposed-position debate only if the proposal ends up making a claim I cannot check any cheaper (the research on when panels pay for themselves is in how-claude-works.md, agent-teams section).

On your plan of "more Fable chats" for evaluation: partly right. Where it is right: an evaluation chat must not share context with the thing it evaluates — that is the fresh-context principle, and separate chats guarantee it. Where I would amend it: subagent panels inside one session give the same fresh context at far lower cost per reader, and the one thing a full separate Fable chat adds — independence from my framing — is only needed once, at the end, on the finished proposal. So: subagents during, at most one independent Fable review chat after, scoped to a written review brief with the proposal and the sources, not to "evaluate everything".

What you get. A document that says what to build, what not to build, and which parts of the old system's ideas survive on evidence — the thing you approve or reject before any construction.

Requirements already set by you (2026-08-02), which the proposal must satisfy rather than reopen:

1. Split steps with forced artifacts. Never one step that both produces and judges — "recommend and evaluate research" collapses into a rubber-stamped "don't need". The form is yours: a = recommend_research() then evaluate_if_research(a) — the recommendation must exist as an artifact before the judging step runs, so skipping it is visible. (Same cure as the credence-goods research in 07-ai-dev-workflows-v2.md: separate diagnosis from treatment.) 2. An index document per AI-facing folder — every document listed with its purpose, so a per-turn step can match work to the right function by reading indexes rather than guessing. (This is the AI layer; the user layer keeps its single inventory page — different audiences, different rule.) Index completeness is already gate-enforced for wiki/; the same mechanism extends. 3. Functions are written procedures with agentic power — not code themselves, but bindable to tools, scripts, and whole programs (your 2026-08-02 clarification: "they can be attached to tools, scripts, even programs"), with code underneath for what AI does badly (time, counts, hashes, diffs), per the three-actor split. 4. The evaluation step survives; its enforcement is redesigned. aos-8.3 has evaluation brackets on 27 of 30 functions — and its own falsification showed a chat could exempt 97–98% of steps with a free flag. The redesign: evaluations produce artifacts, and switching a check off is itself a costly, logged, reviewable act. 5. Your role, per the evidence in 07-ai-dev-workflows-v2.md §§4–5: standing conditions written in advance; explain-back ("state what this does and what happens if it is wrong") checked against the system; disagreements forced open rather than verdicts requested; process facts and domain truth. Not per-case approval. 6. Proof-of-work outputs (your aoe-8.3 principle, 2026-08-02): a step is proven by an output producible only by doing it — an evaluation step outputs the evaluation, a read step outputs what was read — backed by wired checks and periodic audits with staleness alarms. With the honest caveat your falsification report earned: such outputs raise the cost of faking, they do not zero it; the audits are the second layer.

And two named deliverables inside the proposal, from your 2026-08-02 catches — gaps in the current system the proposal must close, not reopen:

• The retrieve function — the defined, step-split procedure by which

a chat finds mid-task context (question → indexes → match → read → found/missing verdict, each step with its artifact). Delivered 2026-08-02 (D38): the designed form added routing, a permanent miss log, and the cluster-based scale trigger — this deliverable is closed.

• The wiki-write system — when derivation happens (your ruling:

at the close of accepted work), what must be derived versus deferred, and the coverage audit that catches under-derivation. The update-on-source-change half already exists (the tether); the creation half is now a split-step in my loop and needs its designed form.

Cost. One session to write, roughly one session's worth of subagent review. Your reading: the proposal itself (target: short enough to read in under an hour, because you are the bottleneck it must fit).

Track 3 — the applications, each in its own workspace

Where. Not here, and not aos-8.3. Each application gets its own fresh workspace and git repository. Reasons: your User-prompt.md line 5 points at aos-8.3 but you wrote it before the read-only ruling — it is stale on that point by your own account; scheduled cloud runs (routines) clone one GitHub repository per run, which fits one-repo-per-app; and the old repo's central failure was one workspace being system, applications, and record at once. How an app workspace inherits the system (copied files, a template, something else) is a Track 2 design question.

Which first. I proposed the crypto most-searched-pairs report for its "external grader" and you pushed back: isn't the check just reading the same source the report reads? You are right, and the argument as I stated it was too strong. What re-deriving from the source actually catches is fabrication and staleness — the report claiming numbers the source does not show. That is precisely the disease documented across this project, so the check is worth having, but it grades honesty, not intelligence: it cannot tell a useful pairs report from a technically-accurate useless one. No candidate first app has a free intelligence-grader. What every app can have from day one is the honesty check in general form: every claim in an output must trace to a fetched source or be marked unverified — and that is machine-checkable. With the external-grader advantage downgraded to that, the ordering argument between crypto-report and rental app weakens to: smaller first workload versus the one you actually care about. That is a business priority, and it is yours.

Cost. The largest by far: multiple sessions per app over days to weeks, plus real decisions from you (Slack route, plan upgrades, what "good" means per app).

Recommended order, and the gates

1 → 2 → 3. Track 1 first because it is small, already specified by your own three STATE rows, and both other tracks write into it. Track 2 second because Track 3's shape (how apps inherit the system) is one of its outputs. Gates: you say yes before Track 1 construction starts; you approve Track 2's proposal before anything it proposes is built; Track 3 waits for both.

Parallel chats — answered

One chat at a time in this workspace for now; parallelism comes from subagents inside the chat (this session ran up to three at once today). When apps live in their own repositories, chats parallelise naturally — one per repo, no shared docs/. If two concurrent chats in this repo become genuinely necessary, the protocol is tracked as deferred item 2: git worktrees per chat, docs/ written only at merge. The old workspace's inter-chat messaging channel solved a coordination problem that files, git, and one-writer-per-folder solve more simply; I would not rebuild it.

Is the working system robust enough for the three applications?

No — and it was not built to be. Judged against each application:

• The trading simulator needs scheduled runs, a dashboard, market-data

connections, and a knowledge base that compounds daily. My system has none of that; it has a docs discipline and a verification habit.

• The rental-startup organisation needs standing agents, Slack, and state

that outlives every session. Nothing here outlives a session except files and git — which is the right foundation but not yet a system.

• The company-overview app needs the function/knowledge layer (your

flowchart diagnosis) that does not exist here yet.

What the system already is: the screening layer — docs you can follow, decisions you can check, claims that carry their evidence, checks that catch fabrication (they caught me twice on day one). That layer is what makes building the rest auditable.

Build-first or grow-from-use? Grow from use, on one condition: the deterministic floor exists first. That is Track 1 plus at least one check that runs unasked and can block — the first is now wired (see docs/03-decisions.md D13). Everything above the floor gets added when a real workload demands it and must beat the null procedure (doing without it) to stay.

What catches your bad steer — since "you review it" is banned:

1. The grounding check, mechanical. Every output claim traces to a source or is marked unverified. A steer that injects a wrong "fact" produces a claim that fails tracing. This generalises the crypto-grader idea and survives your objection to it. 2. Claim quarantine on your own directives. A steer containing a factual claim gets the claim checked before it becomes canon — the same rule the decisions log already applies (D2 checked your git claim before adopting it). Your words route through the same gate as the repo's. 3. Deterministic checks wired to hooks — they hold regardless of who ordered the change that broke them. 4. Baselines. The null procedure: any process a steer adds must beat not having it, measured on real work. Bad process-steers die by comparison, not by argument. 5. A director that argues. Your brief licenses me to push back; today's crypto-grader concession ran the other way — the mechanism is symmetrical, and it is the same loop this page is part of.

None of these requires you to be right. That is the design point.

Decisions

Each entry: what I concluded, the source, and the argument joining the two — written so you can check the source and disagree. Where I relied on my own judgement, the entry says so and says "nobody has checked this". Newest at the bottom.

D1 — The two documents live at the workspace top level, not inside docs/

SUPERSEDED 2026-08-02 by D21 — you caught that root placement left them in no layer at all; they now live in docs/reference/. Original kept below, as this log's convention.

Concluded: how-fable-works.md and how-claude-works.md sit in the root of aos-8.3-blank. Source: your brief (START-HERE.md line 47): "I find them myself and paste them into fresh chats with none of this context." Argument: you find them by opening the folder; the root is the first thing you see. Placement was left to me — this is my judgement and nobody has checked this.

D2 — Git: I commit at a defined point in my loop; only you push

Concluded: I commit whenever a unit of work completes with docs updated and the writing check passing — the exact rule is written in working/procedure.md. I never push to GitHub. Source: the workspace was already a git repository (command: git log → one commit, "first commit", 2026-08-01, remote lotivus/aos-8.3.1), which the briefing's description of the folder (two files) did not mention. Asked you; your answer, 2026-08-01: "yes and define clearly when you commit as a step in your procedure". Argument: small commits give receipts that git grades, not me — the one pattern your audit found measurably worked (AOE-AUDIT via CLAIM-STATUS.md: commit receipts resolved against real git). Pushing publishes; that stays a human act.

D3 — One decisions file, not one file per decision

Concluded: decisions live in this single file. Source: none — my judgement, nobody has checked this. Argument: you screen this folder; one chronological page is easier for one non-technical reader to follow than a folder of fragments. If it outgrows what you can scan, I split it and record that here.

D4 — Workspace split into user-facing docs/ and AI-facing working/

Concluded: two layers, per your decided information architecture: docs/ is the source of truth written for you; CLAUDE.md and working/ are AI-facing, terse, and derived from the same events. Source: reference/08-information-architecture.md (your rulings, quoted there: "i screen. you write."; two writing standards). Argument: the brief says to evaluate this design, not just implement it. For this session's own work the design holds up: the two audiences genuinely need different registers, and keeping them in separate folders is the cheapest way to never mix the standards. Whether it scales to a full AOS (a page per function against what one person can screen) is a separate, still-open question — I have not resolved it and will not bury it here.

D5 — Deliverable (a) is written to the model, not about it

Concluded: how-fable-works.md addresses the fresh Fable chat that reads it ("you are..."), rather than describing Fable to you in the third person. Source: brief line 43: "Orientation for a fresh Fable chat." Argument: the reader at paste time is the chat; orientation works best in second person. My judgement on the reading — nobody has checked this.

D6 — What I skipped in the briefing material, and why

Concluded: I read everything the brief marked required, and skipped, for now: 07-ai-dev-workflows-v2.md (990 lines — its own index says skip unless designing the human's role); all of SESSION-RECORD-2026-08-01.md outside sections 4, 5, 7 (the brief forbids the rest); and the optional history (working/chats/, the 27 earlier builds, ~7.4 GB) — the brief calls it optional, and nothing in the three deliverables depends on it. The two big investigation reports, first deferred, have now been read in full. Source: brief lines 21–37 and 99–104; reference/README.md rows 7–8. Argument: deliverables first, and each skip is either instructed or deferred to the point where it is load-bearing. The deferrals are my judgement — nobody has checked this.

D7 — How how-claude-works.md is sourced, and the three evidence marks

Concluded: every claim in deliverable (b) carries one of three marks: docs (a page fetched from Anthropic on 2026-08-01, with the URL), observed (it happened in this live session in front of me), or unverified. Research agents supplied the fetched quotes; I re-fetched the two most consequential pages myself (computer use, Claude Tag) and the quotes matched exactly. Source: your brief's evidence rules (fetch the page; five strengths of evidence) and the verbatim agent reports, which are quoted in the file. Argument: the marking scheme is my design — nobody has checked this — but it is the same discipline your CLAIM-STATUS.md uses, applied at write time instead of during a later audit.

D8 — Computer use: the earlier "MCP hypothesis disconfirmed" was wrong

Concluded: in Claude Code, computer use is an MCP server — built-in, named computer-use, off by default, enabled via /mcp; documented gates are macOS + Pro/Max + claude.ai sign-in + interactive session, with no model requirement stated. Your reference folder's note that the MCP hypothesis was "disconfirmed" by claude mcp list was a false negative — that command doesn't surface disabled built-in servers. Source: code.claude.com/docs/en/computer-use.md, fetched by me 2026-08-01 (quotes in how-claude-works.md section 12 and working/lessons/2026-08-01-computer-use-fable-evidence.md); plus a direct search of this live Fable session's tool registry, which contains no computer-use tool — consistent with off-by-default. Argument: the docs state the mechanism; my session shows the default state on your exact configuration. What remains genuinely unchecked is whether a Fable session can drive it after you enable it — the ten-second test (/mcp → enable → ask for a screenshot) is yours, and I have written the expected result rather than guessed it.

D9 — Claude Tag can't serve app 3 on your current plan; flagged, not solved

Concluded: the company-director app's "agents reachable over Slack" cannot use Claude in Slack (Claude Tag) today, and I flagged this in deliverable (b) rather than picking a workaround. Source: claude.com/docs/claude-tag/overview.md, fetched by me 2026-08-01: "Claude Tag is available on Team and Enterprise plans... It isn't available on individual plans (Free, Pro, or Max)." You are on Max (your reference folder, 02-workspace.md). Argument: whether to upgrade plans or build a custom Slack integration is a cost decision about your business — intent, not disk — so it goes to you rather than into a design. Nobody has checked the custom-integration route's effort.

D10 — The source files are now read directly; the evaluation of them had real over- and under-reads

Concluded: ai-dev-workflows.md and llm-wiki.md read in full on 2026-08-01 after your correction. The earlier evaluation's headline synthesis mis-attributed its "on a schedule / runs unasked" halves to the source, and missed the source's router and bake-off ideas; the llm-wiki reading missed its Lint operation, its answers-filed-back mechanism, its index/log split, and its scale claim. Source: the two files themselves; full reading with quotes in docs/06-source-readings.md. Argument: each miss is checkable by searching the source for the words the evaluation used — the schedule language appears nowhere in ai-dev-workflows.md. My re-reading can carry its own biases; the page marks its one novel interpretation (provenance vs authority) as unchecked.

D11 — The four [X] values: decided by me, bridge tracked

Concluded: lessons live in working/lessons/ of whatever workspace a chat runs in; the self-check is fresh-context verification of each finished unit plus a re-check when the working system changes. Applied here already; carried to the applications prompt when Track 3 opens. Source: your answer 2026-08-01 ("think forward... the decision itself has to be tracked — so once we are at the bridge, we remember to cross it"); the bridge condition is docs/04-deferred.md row 4, which sits on every future chat's boot path via CLAUDE.md. Argument: the values are the regime that caught real errors this session (usage log in working/writing-check.md). The remembering system is the boot path, not anyone's memory — your rule, applied. Whether these values fit workflows unlike this one is exactly what row 4 forces a future chat to re-ask; nobody has checked them beyond this session's work.

D12 — Docs→wiki derivation: tested small, works, one gap found

Concluded: your ruled direction (user docs as source, AI wiki derived) was exercised on a real artifact: three atomic nodes derived from the two reference documents into wiki/, each carrying source:, derived: date, and a could-be-wrong: line. The derivation itself was cheap and clean. The gap: nothing yet detects when a node's source page changes — the staleness problem. The old repo solved exactly this with its source-hash tether (84/84 green in its audit, one of its few working parts); a mechanical freshness check belongs in Track 1's design. Source: the wiki/ folder as built; AOE-AUDIT-2026-08-01.md WORKS item 4 for the tether precedent. Argument: one small test is evidence the direction is workable, not that it scales — three nodes prove mechanics, not economics. Nobody has checked how the derivation behaves at a hundred nodes.

D13 — Commits are now gated by a deterministic check, wired twice

Concluded: inventory_check.sh (every file described where you can find it; folder-size thresholds) blocks commits two ways: a Claude Code PreToolUse hook, and a git pre-commit hook via core.hooksPath=working/checks/githooks. Source: live test 2026-08-01 — the check printed red with eight real gaps on first run; the hook then blocked two commit attempts while red (the error output is in the session record) and passed the commit once green, with the git hook printing "inventory check: green" on the same commit. Argument: this is the "one deterministic check that runs unasked and can turn red" floor, chosen because inventory-drift is the failure my own (c) verifier actually caught, and it removes the largest depends-on-me-remembering item in my setup. One correction kept visible: I first reported the Claude hook "arms next session" — the second test proved it active mid-session; the first test's commit had raced the settings write. Residual gap, tracked: a fresh clone needs one git config line (in CLAUDE.md) until someone automates it.

D14 — The crypto-pairs "external grader" argument, downgraded after your objection

Concluded: you objected that checking the pairs report against search data just re-reads the report's own source. Correct — the check catches fabrication and staleness, not quality. The general form survives: every output claim traces to a fetched source or is marked unverified, which is machine-checkable for any app. The first-app choice therefore reverts to business priority — yours. Source: your answer 2026-08-01; the revised argument in docs/05-direction.md Track 3. Argument: conceding the over-claim and keeping the checkable core is the same move the reference folder applied to the 94.5% statistic: measurement stands, inference narrows.

D15 — Application order: yours, recorded

Concluded: company-overview app first, then crypto-pairs report, then rental app, then trading simulator. The crypto-pairs work should learn from the earlier company-overview build's research procedure — not investigated now, at your instruction; you will guide that extraction (deferred row 10). Track 1 approved to start in this workspace, designing new rather than patching aos-8.3. Source: your answers, 2026-08-01: "company overview app > crypto pairs report > rental app > trading… dont check now - ill guide the creation"; Track 1 option "Yes — design here, start now". Argument: business priority is intent, which is yours; the order is recorded here so no future chat re-litigates it without new input from you.

D16 — Frontmatter on every doc, enforced at commit; per-doc change logs declined

Concluded: every markdown file in both layers now opens with created: and modified: dates (24 files stamped 2026-08-02, created: recovered from each file's git history). The commit gate enforces both presence and freshness — a staged file whose modified: is not today's date blocks the commit. Per-doc change logs: none; git commit messages and the decisions page already carry the why, and the readable per-page view belongs in the future dashboard (deferred 11). Schema evolution policy and its costs are written in docs/07-state-system.md. Source: your directives 2026-08-02 ("date created and modified... defined clearly by a step by step procedure... directives must live in functions, not user remembered"; "decide what it should have, or if it should evolve over time - and the cost of changing the system"). Live tests: stale-date red and corrected-date green in the session record; the tether also fired when stamping changed the two source documents, and was re-stamped after review. Argument: your "how will the chat remember" is answered structurally: it does not have to remember — the commit refuses until the dates are right, the same mechanism that already blocks inventory gaps and stale wiki nodes. The frontmatter beats plain git dates for exactly one reader: you, who reads files rather than git. For AI-only files git would have sufficed; they are stamped anyway so one rule covers everything — a uniformity-over-minimalism call, my judgement, nobody has checked this.

D17 — Your step-atomicity and per-folder-index directives are Track 2 requirements; the comprehension-role idea is corrected

Concluded: three of your 2026-08-02 inputs are now standing requirements on the Track 2 proposal (recorded in docs/05-direction.md): split steps whose produced artifact must exist before its judging step runs; an index document per AI-facing folder for per-turn function-matching; functions as written procedures over code that handles the deterministic parts. Alongside them, I read reference/07-ai-dev-workflows-v2.md sections 4–5 at your pointer (reversing part of the D6 skip) and corrected my own earlier endorsement of "his role is comprehension": the surviving form is explain-back plus standing conditions plus forced disagreements — the correction is visible in docs/06-source-readings.md. Source: your messages of 2026-08-02 (the a = recommend_research(); evaluate_if_research(a) form; "chats just rubber-stamp"; "directives must live in functions, not user remembered"); 07-ai-dev-workflows-v2.md lines 413–777 (Khan 88%-vs-60% forced disagreement, the illusion-of- competence literature, Green's standing-conditions replacement for per-case oversight, the credence-goods mechanisms). Argument: your split-step rule and the research's separate-diagnosis-from-treatment rule are the same mechanism at two scales — the falsification report showed the merged form fails inside the old system (vagueness was the winning strategy; a free flag exempted 97–98% of steps), and the oversight literature shows it fails at the human approval point. One design principle covers both: no judgement without a materialized artifact to judge, and no exemption without a logged cost.

D18 — User obligations get one owned page; audits get receipts and a staleness alarm in the gate

Concluded: everything only you can do lives in docs/08-your-actions.md and nowhere else (other pages point). Periodic audits (boot test, docs verification, wiki lint, obligations re-sweep) have receipts with dates in working/state/audits.md; audit_staleness.sh runs inside the commit gate and turns it red when any audit exceeds its maximum age — your "raise it to chats if too long since an audit", implemented as a block rather than a reminder. Wiki-lint's row is a baseline: it has never actually run, and the gate will force its first run within 14 days. Source: your message 2026-08-02; live tests in the session record (backdating the boot-test receipt to 2026-07-01 turned the gate red with "audit OVERDUE: boot-test (32d > 14d)"; restoring cleared it). Argument: the completeness of the obligations list cannot be fully mechanised — noticing that prose implies an obligation is judgement — so it gets three layers: a proof-of-work sweep line per loop (weakest, your principle, fakeable at nonzero cost), the boot path making the page unavoidable, and the periodic re-sweep audit whose absence blocks commits (strongest). Stated honestly rather than claimed watertight. One correction to your recollection, with the evidence: aoe-8.3's checks were real but mostly not wired at hooks — its audit found the three registered hooks run no gate, turn_guard.py:21 says "It never blocks", and turn.py end exits 0 whether gates pass or fail; gates ran because chats voluntarily typed the command (181 recorded runs), and the only thing firing automatically was the dashboard. The dashboard's turns and gate-health pages showed real data about checks nothing enforced. Ours differ exactly there: red blocks, tested.

D19 — Reference works are categorised and linked, not duplicated; the docs-currency audit ran and caught three

Concluded: the docs get a reference-library page (docs/09) that categorises and links everything outside the reading flow — the two reference documents and the wiki derivations — each with a user-facing account. Your "doc version of those files" idea is declined for now: both reference documents already meet the user-facing writing standard, so a doc-version would be a second copy of the same text, and duplicated text is the drift mechanism this workspace has now caught three times. The rule adopted: every artifact gets an account (paragraph or page, sized to it), never a parallel copy. Separately, your "have the docs always been updated?" audit ran: every one of the nine commits moved docs/ alongside non-docs work (cadence held, gate-forced), and a content-level sweep found three stale spots the mechanical gate cannot see — two pages still describing deliverable (a) by its abolished 300-word cap, and the direction page still calling built work "a proposal". All three fixed; receipt recorded in working/state/audits.md. Source: your message 2026-08-02; the Diátaxis framework (diataxis.fr/reference-explanation/, fetched 2026-08-02): "Reference is what a user needs in order [to] help apply knowledge and skill, while they are working… Explanation is what someone will turn to to help them acquire knowledge and skill"; mixing "is bad for the reference, interrupted and obscured by digressions… bad for the explanation too". The audit evidence: git show --name-only per commit, and the grep for the stale cap references, both in the session record. Argument: your categorise-and-link instinct matches the one established framework for exactly this split; the declined duplicate is my judgement on drift risk — nobody has checked this, and if a future artifact is genuinely unreadable to you, its account grows into a full page, which is your page-per-function rule doing the work the duplicate would have pretended to.

D20 — The docs get their wiki shape now (macro layer); the Dex Horthy material is verified, adopted in part, and reshapes your role

Concluded: docs/00-big-picture.md is the top-down root you asked for (AOE → AOS → applications → workspace → systems), with the read order split into understand-the-system (top-down) and follow-the-work (chronological); micro layers grow as Track 2 builds parts to document. From the Horthy material: intentional-compaction and research-plan-implement are verified against his published document and converge with what we built independently; the ticket-withholding move is adopted as a subagent rule (research briefs carry questions, never my hypothesis) regardless of its unverified provenance, because our own reference folder documents the failure it prevents; and his verified leverage ranking — reviewing research and plans beats reviewing code — becomes the definition of your role: your attention goes to readable research, plans, and docs; code-level verification is sourced from gates and fresh-context agents, and the director supplies the technical thinking. Written into CLAUDE.md as a standing rule at your instruction ("i need the ai to remember that it needs to research, evaluate, and direct"). Source: your messages 2026-08-02; the notes file (working/user/external-sources/more-ai-workflows-info/dex-horthy.md, 36 lines, dead citations — treated as unverified summary); verification fetch of github.com/humanlayer/advanced-context-engineering-for-coding-agents (quotes in docs/06-source-readings.md, including the discrepancy: his doc says keep context "in the 40%-60% range", not a 40% cliff). Argument: the restructure timing honours both your ask and the waste-avoidance concern — the stable macro is documented now, the micro mirrors construction so nothing is documented twice. The role mapping is the strongest available answer to "I'm not the smart engineer Dex is talking about": his own ranking puts the human where you can actually operate. Nobody has checked the mapping against a real build yet — the first application is its test.

D21 — The reference documents move into docs/reference/; every markdown file must live in a layer, gate-enforced

Concluded: you caught that how-fable-works.md and how-claude-works.md sat in no folder and no layer ("what you're saying implies those two files are BOTH user AND ai-facing"). Resolution: they are user-facing reference works — the "addressed to a model" style of (a) is rhetoric, not a layer; the AI-facing versions are precisely the wiki derivations, which is why the wiki exists. Both moved to docs/reference/; the layer rule is now mechanical: the commit gate rejects any .md outside docs/, wiki/, working/, or CLAUDE.md (tested: a planted root file was caught and named). D1 superseded, marked in place. Your find-at-root convenience is traded away knowingly — the brief fixed the filenames, not the paths, and you asked for system over convenience. Source: your message 2026-08-02; the layer definitions in reference/08-information-architecture.md and docs/09; the live gate test in the session record. Argument: a taxonomy with unclassified members isn't a taxonomy. The deeper point you made — "you should be catching these, but i had to catch" — is answered structurally, not with a promise: the class of error (a file outside every layer) is now impossible to commit, and the boot-test tether (below) forces fresh-eyes re-checks when the boot contract changes. What no check yet catches: layer-misassignment (a user-facing text filed under working/) — that stays judgement, sample-audited by the periodic docs-verification.

D22 — Boot test round 2: passed, five record defects caught and fixed; two new mechanisms from your questions

Concluded: a second fresh-context boot test ran against the changed workspace (your catch: I had changed the boot contract repeatedly without re-testing). It answered every probe correctly — open work, all gates (it ran the check scripts itself and found the mid-loop red), the moved documents' layer with reasons, the directive-handling flow, the never-bring rules — and caught five defects, all fixed: a decision (D21) cited before it was written; D1 false with no superseded mark; the commit-msg hook missing from the inventory; the checkpoint saying "five requirements" where the direction page lists six (the duplicate-fact disease, in the cache meant to be reliable — the checkpoint now names no count, just the page); and an audit receipt left mid-sentence. Two mechanisms added: the boot-contract tether (audits carry a fingerprint of CLAUDE.md+procedure.md; the gate turns red if they change after the last boot test — with waivers allowed only as visible, reasoned entries in the receipt), and the Loop attestation (the commit-msg hook rejects any commit whose message lacks a Loop: line naming that loop's step evidence — your aos-8.3 "log an output you could only know by doing it", bound to the diff a reader can check it against). Source: the boot-test transcript (session record, 2026-08-02); your messages of the same day; live red/green tests of both new hooks. Argument: the boot test is the working system's real examination — both rounds caught defects self-reading missed, which is the fresh-context principle from the Fable guide paying out on the system itself. The waiver design answers your old open question ("should AI turn off checks?") the way finding 4 of the falsification demanded: exemption as a costly, visible record, never a free flag.

D23 — You caught two undesigned pieces: the retrieve function and the wiki-write trigger

Concluded: conceded on both. Mid-task retrieval had no designed function — boot retrieval was designed and tested, but "how does a chat find context mid-work" ran on my judgement. And the wiki had only half its write system: the tether forces updates when a source changes, but nothing defined when new derivation happens — three nodes existed as a test while dozens of derivable facts sat underived. Now: an interim retrieval rule and a split-step derivation trigger (your own ruling — wiki updates at the close of accepted work) are wired into working/procedure.md, retrieval failures are recorded as demand signals, and both designed versions are named deliverables inside the Track 2 proposal (docs/05-direction.md). Source: your message 2026-08-02 ("did you miss designing the retrieve function? did you define when ai-facing wiki is written?"); your periodic-update ruling in the old repo's reference/03-owner-open-questions.md ("At the end of work done, and user is happy, can update the wiki"). Argument: the honest half of the concession: these gaps were invisible to every mechanical check because checks only catch what is encoded — they were caught by your reading, which is the human-attention layer doing the one thing it can do that machinery cannot. The interim rules are stopgaps and marked so; nobody has checked them against real retrieval load.

D24 — The research gate: research serves a named decision, bounded by saturation

Concluded: a standing rule in working/procedure.md: research runs only against a named decision it could change, after stating what we would do with no research; cheap-and-reversible defaults build first and research on failure; infrastructure and irreversible choices research first, timeboxed, stopping at saturation (new sources repeating filed ones); all research is filed so no question is bought twice; and research that changed no decision is recorded as a catch, because too-much-research is a real failure with a quieter cost than too-little. Source: your question 2026-08-02; the evidence behind the rule's two halves — aoe-8.3 building retrieval machinery below the scale where the filed research said it pays (docs/06-source-readings.md, llm-wiki scale claim), and this session's own useful researches, each of which changed a named decision (agent-teams → how the panel is used; Diátaxis → the docs structure; Horthy verification → your role). Argument: the rule is my synthesis of those cases — nobody has checked it beyond them. Its test is mechanical enough to audit: every research artifact in working/ should name the decision it served; ones that name none are the "too much" pile.

D25 — Three pilot functions, on your yes; the constraint question answered by piloting

Concluded: working/functions/ now holds loop, retrieve, and derive-wiki in the function form your requirements define — split steps, an artifact proving each step, when: matching clauses, script bindings, their own gate-enforced index. working/procedure.md slimmed to standing rules pointing at them (one owner per fact — the loop text was about to exist twice). All three carry status: pilot: provisional, graded by boot tests and audits until Track 2's evaluate-function design exists — which answers your "without a clear evaluate-function system we build badly-infrastructured systems" concern the only honest way available before that design: the evaluation they get now is named, and its weakness is written on them. Source: your question and approval, 2026-08-02 ("was the reason you have not defined these functions… you dont want to be constrained?" → pilot option chosen); boot test round 4 receipt in working/state/audits.md. Argument: your suspicion had a true core — the designer was exempting himself from the form he mandated, and every prose-procedure loop deepened the retrofit debt. Piloting on my own workflow tests the form on real work before Track 2 generalises it, which is your dogfooding rule pointed at the system itself. Risk, named: pilots can ossify into canon without the owner noticing — prevented by their status: pilot marks, this decision, and Track 2's explicit mandate to re-rule the form.

D26 — Your seven points of 2026-08-02, each ruled

Concluded, point by point: 1. Retrieval routing: adopted — boot is a specialised retrieval already routed by CLAUDE.md; the functions index carries the routing rule. Your harder question — will an evaluate step catch a badly-architected function? — answered honestly: no. Fitness evaluation (does this function match this need) is catchable by an artifact-producing check; architecture quality is only catchable by outcome-grading — audits, baselines, boot tests — which graded my boot design four times today and caught defects every time. Conflating the two is how aos-8.3's evaluate brackets became theatre. 2. Computer use: stays on your page, not urgent; becomes relevant at Track 3 (GUI testing for the apps). 3. JSONL for tracking: right idea, right trigger — adopted for the moment parallel writers exist (deferred row 2 now specifies it); converting the single-writer files today is churn without a second writer. User-facing pages stay prose regardless — you read them. 4. Your reading system: the queue now lives in docs/08, priority -ordered with time estimates; new pages needing your eyes enter it via the loop; you clear items by telling me. Its growth rate is the visible measure of the capacity cap. 5. Dashboard: evaluated and deferred with a condition (row 12) — at today's scale it would render pages you can open, and aoe-8.3's dashboard-that-watched-while-nothing-enforced is the cautionary case. The attestation and receipt data are structured so the dashboard is later a rendering job. 6. Retrieval now: conceded urgent and acted on — derive-wiki ran its first real pass; the wiki now holds system/ nodes (function form, commit gate, state and boot, research gate) so a fresh chat of any model retrieves the design instead of reading the whole workspace. 7. Openness and bias: functions are declared open in their own index — deviation is legitimate and must leave the same trace as following, via the new deviations= field in every commit's Loop line. Against status-quo bias: the new function-fitness audit (21-day cycle) argues against the functions — null-procedure comparisons, silent deviations, unused functions as retirement candidates. Source: your message 2026-08-02; the round-4 boot test receipt; the gate output after the derivation pass. Argument: each mechanism is the smallest that makes the behaviour structural rather than remembered; the fitness audit is the one most likely to be theatre (an audit can rubber-stamp too) — its honest floor is that it must produce named artifacts (the comparison, the deviation list), and nobody has checked whether that floor holds until it first runs.

D27 — Timestamps are real clocks: full ISO, edit-time semantics, script-derived, Haiku-verified

Concluded: every page's created:/modified: is a full timestamp (seconds + timezone — git's native precision; milliseconds live only in the filesystem and do not survive cloning, so finer would be decoration). Semantics, per your question: modified: = the actual edit time, captured by stamp_timestamps.py reading the clock at the loop's stamp step — never typed by hand; git's commit time remains its own separate fact. Historical files carry last-commit time as the nearest honest bound. The gate rejects non-ISO or unbumped stamps. Source: your directives 2026-08-02; the stamp script's output; a three-agent Haiku workflow that independently re-derived six sampled files' timestamps from git and the filesystem — 6/6 matched (worst deviation 1 second of write-lag). Argument: deriving from git/fs makes fabrication impossible rather than forbidden; the verification agents were used where they add value (checking the script) and not where they subtract it (doing arithmetic a script does better) — the three-actor rule applied to your own request, and said so.

D28 — The system map: debate-ruled, built as a layered docs page; the dashboard stays a delivery vehicle

Concluded: a six-agent workflow (research with fetched sources, full graph extraction of this workspace with per-edge enforcement labels, three fixed-position debaters, a judge) ruled: the map is docs/10-system-map.md — C4-style levels in Mermaid with interleaved prose, every arrow labelled enforced-vs-procedure-only (dashed), as-of fingerprints naming the script versions described, and a mandatory "what nothing watches" section. The interactive-app position lost (unscreenable JS, unwatched deployed copy); the no-visualization position lost the primary ask but won two grafts: the update-triggers wiki node is tethered to the gate script itself, and docs/00 stays the context level so the macro story has one home per level. The phone dashboard (published today for your mobile need, URL in docs/08) is a snapshot renderer with receipts — explicitly not the map's home, per the judge's anti-dashboard warning. New: gate rule — every docs page must appear in the README read order; deferred row 13 — the unwatched enforcement layer, yours to commission. Source: the workflow ruling and graph (session record; extraction quotes in the ruling); the judge's eight requirements, all implemented this loop; the map's own as-of marker catching its first staleness before publication. Argument: the judge's key finding stands on the fetched evidence — step-by-step IS the layered document, and interactivity shifts sequencing work onto the novice; the residual risk it named (diagrams under audit-only coverage in a workspace where wiki-lint has never run) is accepted and printed on the page itself.

D29 — Per-step self-logging rejected; tracking is derived from stores the chat cannot rewrite

Concluded: procedures do not gain agent-written per-step log rows. Execution tracking is layered instead: (1) each function step already proves itself with an artifact (a list, a node, a green check output) — evidence, where a log row is only a claim; (2) each loop lands as one gated commit whose Loop: attestation is parseable and diff-checkable; (3) the dashboard now has a Turns view derived from git history — one row per loop with its attestation chips, carrying over the old app's turns-page idea without its data source; (4) when true step-grain tracking is needed (Track 3 apps), it derives from the harness session transcripts in ~/.claude/projects/ — the one store the graded party does not write — never from agent-authored rows. Source: your question 2026-08-02; the falsification and audit evidence on aos-8.3's per-step system: every verdict input written by the graded party, vagueness the dominant strategy, and the step log batched against its own rule (892 steps across 225 timestamps, bursts of 17 in one second — rows written retroactively in bulk); your reference/02's observation that transcripts are "the only records in the system the graded agent did not write." Argument: aos-8.3 already ran the experiment you are asking about, at 6,387 rows, and its own falsification showed fine-grained self-logging invites the theater it is meant to prevent — the finer the grain, the cheaper each fabricated row. Deriving from git and the harness inverts authorship, which is the entire game. Cost accepted: between commits, sub-loop activity is invisible except in the live transcript; that blind window is bounded by loop size and printed on the map's blind-spots list by the attestation entry.

D30 — Correction of D29: you were right about what the step logs did well; the completeness device is restored, re-scoped

Concluded: D29 conflated two things and over-rejected. What the falsification broke was the truth-grading of step logs — CONFIRMED verdicts from self-written inputs. What it never falsified — and what the record supports you on — is the behavioral device: steps that must log an output knowable only by doing them kept chats on the declared list, and the completeness check (declared steps minus logged steps) made misses visible — aos-8.3's verify refused turns with unlogged declared steps, and that needed per-step records to exist. My pilot functions demanded per-step artifacts but nothing enumerated them against the declared list: I had dropped the working part. Restored, re-scoped: each function run now writes one run line in the checkpoint (run: <fn> <k>/<n> — artifact pointers), and a new mechanical check inside the gate verifies the declared count against the function file and blocks incomplete runs that state no deviation — tested red and green live. Completeness is mechanical; truth stays with artifacts, audits, and git; still rejected from D29: self-graded truth verdicts over self-written rows. Source: your pushback 2026-08-02 ("it was proven... they stuck to the function steps and we could see what they missed"); corroboration in the record — CLAIM-STATUS row on verify refusing unlogged declared steps, Q57's derived-to-do design, the flat-step contract that makes counting checkable; live red/green test of working/checks/run_completeness.py in the session record. Argument: the straight-line step contract (aos-8.3's one enforced form) exists precisely so a checker can know what "complete" means — your design, doing here what it was built for. The blind spot that remains, stated: run lines are still self-written; the count is checked, the pointers' truth is sample-audited. That boundary — count mechanical, truth audited — is the honest maximum without harness-derived tracking (D29's Track 3 path, unchanged).

D31 — Track 2 go received; the proposal written, adversarially reviewed, and corrected before you read it

Concluded: on your "start track 2" (2026-08-02), the AOS proposal was written this session — where the assimilated evidence lives — as docs/11-aos-proposal.md, then put through a fresh-context adversarial review before reaching you. The review's findings, all fixed in place: the wiki-write system was missing entirely (one of the two deliverables the direction page ordered — now build item 3); the template argument defeated a strawman (only copy-vs-auto-sync; the pinned-shared-kernel option now appears, and the recommendation became copy-with-tether, taking the reviewer's divergence-detection point); the central kernel claim hid its evidence boundary (self-hosted workload only; the two adversarial audits never run — now disclosed and moved onto your decision menu as item 1); and five evidence defects (a wrong citation, an inflated "tested" for an abstract source's assertion, a dropped exception on the no-vendor claim, "unfakeable" overclaiming git, a miscount of drift catches). Also caught: the proposal's opening claimed this review had already happened before it had — the premature-record disease, fourth instance, now recorded in the lesson file. Source: the reviewer's full findings (session record, 2026-08-02); the diff of docs/11 this loop; your go message ("all settled, defer computer use check / start track 2"). Argument: the review did exactly what the role exists for — its strongest finding was structural (a missing deliverable I could not see because I wrote the structure), which is the fresh-context principle paying out a sixth time. What it could not check: whether the candidate-kernel framing survives contact with the first application — nobody can check that before Track 3, and the proposal now says so.

D32 — The coverage audit's findings, and the five decisions since D31 entered late

Concluded: three fresh agents audited whether your recent prompts all landed in docs, tracking, and working memory. Mostly yes; the gaps are fixed and two failure classes are now mechanically unrepeatable: every as-of fingerprint on the map is verified against the real file at every commit, and a checkpoint without a loop run-line blocks the commit (the D30 device had lapsed one commit after it was built — a checkpoint rewrite no-opped silently and the check passed vacuously; lesson filed). Five decision-grade events since D31 lacked entries and enter here with their existing arguments' locations: add-system (the six-move wiring procedure; argument in the function file and the map's when-row) and evaluate-panel (the agent-team selection criteria; argument in the function file, sourced to the agent-teams research) — both extracted under the promotion rule, and that rule itself is not yet owner-ruled: it is item 3 of the proposal, so your proposal verdict rules it, and these two pilots stand or fall with it; the wiring rule (unwired checkers block commits; scope limited to working/checks/, "wired" = referenced in the six enforcement files — substring matching can false-green on a mere mention, stated); the gap-analysis audit (charter and 21-day cycle as filed); the blind-spot governance (enforcement-review audit with its accepted self-reference limit; deferred 13 narrowed to the external watcher that your push unlocks); and the successor spawn (screen + clean environment + remote-control; chosen over cold-boot for continuity of your remote access — the state layer makes it optional, not necessary, and the single-writer rule transfers authorship to it). Source: the three agents' findings (session record, 2026-08-02, workflow wn4ryk4k4); the fix-batch diff of this commit; live red tests of both new mechanisms in the session record. Argument: the audit demonstrates both halves of the design — the mechanical gate could not see meaning-level gaps (a lapsed habit, a fingerprint matching nothing, an unrecorded decision), and fresh-eyed AI checks found them; each finding then became either a mechanism or a record, which is the only durable form of "fixed".

D33 — The proposal accepted in full: kernel claim, six build items, anti-scope

Concluded: your verdict on docs/11-aos-proposal.md, given 2026-08-02 in the successor session: "i accept the proposal 3 items" — all three menu items accepted, none amended. What that settles: (1) the candidate-kernel claim — this workspace is AOS's first instance and Track 2 is gap-closing, not fresh design; (2) the six build items, with the template mechanism ruled as copy-with-tether and promotion-from-real-work-only now your standing rule; (3) the seven-item anti-scope in force — rebuilding any of its items needs new evidence recorded as a decision. Consequences executed in this loop: the five functions drop pilot for active (loop, retrieve, derive-wiki were provisional since D25 pending exactly this ruling; add-system and evaluate-panel, which D32 said stand or fall with the promotion rule, stand); the learning-loop rules are derived into the wiki (wiki/system/learning-loop.md); the wiki-lint first real run — which the proposal makes part of acceptance — is executed this same loop, receipt in working/state/audits.md. Build order starts at the template, then designed retrieval, then the wiki-write system. Source: your message, 2026-08-02, quoted verbatim above; the menu in docs/11 ("Approve, amend, or reject, item by item"); D31 (the reviewed proposal); D32 (the pilots riding this verdict). Argument: the verdict names "3 items" against a menu of exactly three, so it is read as full acceptance. If you meant something narrower — say, item 3 alone — this entry is the visible thing to correct: the record states its reading instead of silently acting on one. Could-be-wrong: that reading is mine; the quote is preserved so the correction, if needed, is one message.

D34 — Build item 1 built: the template, tested red and green, adversarially reviewed, hardened

Concluded: the app-workspace template exists and works — built to the mechanism you accepted (copy + version file + tether, D33), in the same loop as its own adversarial review. The parts: working/checks/make_app_workspace.py (one command spawns a complete governed workspace; the spawn aborts unless the new workspace's own gate, tether, and initial commit all pass), working/template/ (the skeletons it fills), working/checks/kernel_tether.py (the divergence check), and docs/12-app-template.md (your account). Live tests, all run today in a scratch workspace: spawn green end to end; silent edit to a locked file red; commit carrying that silent divergence blocked by the app's own gate; pinned reasoned divergence green; a second edit after the reason red again; stale and malformed divergence entries red; audit alarms verified to trip on schedule from spawn day. A fresh-context adversarial reviewer attacked the build mid-loop and materially changed it: divergence reasons are now pinned to the exact file state they excuse (its strongest finding — unpinned reasons excused every future edit, quietly re-opening the N-diverging-copies hole); the tether now runs at every app commit (it found the gate otherwise blind for up to 21 days); the skeletons carry real timestamps (it found the template literally uncommittable through the kernel's own gate); the app audits table regained the enforcement-review row it had silently dropped; app boot files no longer point at documents apps don't have; and the lock-rewrite attack it named is now a sampled check in the kernel-tether audit charter plus a stated blind spot in docs/12. Deferred with a condition, not built: the upgrade procedure (row 15 — promotion rule forbids designing it before a real upgrade exists). Source: the reviewer's findings and the test outputs (session record, 2026-08-02); the diff of this commit; receipts in the kernel-tether row of working/state/audits.md; docs/11 §1 as the spec. Argument: the build honoured the research gate (mechanism already owner-ruled; remaining choices cheap and reversible → build first) and add-system's six moves; the reviewer's findings demonstrate why the review step is not optional — three of them were invisible from inside the build. Boundary stated: today's spawn tests ran with the template uncommitted (--allow-dirty, disclosed in the lock and docs/12); the clean-tree spawn re-test follows this commit and lands in the audit row.

D35 — Track 3 directives received: crypto app = technical analysis reports; the company-overview procedure is a learning source, not a template

Concluded: your message of 2026-08-02, recorded the day it arrived. (1) The company-overview app's procedure — how a company is analysed and the overview created — is itself a deliverable to watch: it "can be learnt to use for the crypto thing" "but may not be the same" — transfer is expected learning, never assumed reuse; each app's procedure earns its own form (the same discipline as the promotion rule, D33). Deferred row 10 now carries both learning sources (the earlier build's procedure and the new app's). (2) The crypto app's outputs are technical analysis reports; you will supply "more info and samples later" — deferred row 16 holds that condition so nothing depends on either of us remembering. docs/00's application list now says both things. Source: your message, 2026-08-02, quoted phrases verbatim. Argument: recorded immediately because the record layer is the procedure's answer to your closing question ("does your current procedure define adding this to the docs now") — yes: the loop's record step files a directive the loop it arrives in (D-entry, docs updates, deferred rows with closing conditions), the checkpoint's directive inbox holds anything not yet wired, and the prompt-coverage audit later diffs your messages against the record to catch anything that slipped. Nothing here was left to memory.

D36 — Your "should we edit the functions" — yes, and it is the learning loop's first live improvement

Concluded: the docs/00 staleness (the root page said "proposal pending" for two loops after your verdict) was a gap in the loop function itself: its record step named the four record surfaces but never said to sweep the other user-facing pages for claims the loop's events had made stale — and docs/00 is the one page nothing tethers. Fixed in the function: working/functions/loop.md step 2 now ends with that sweep, docs/00 named first with the reason, and a clean sweep must say "none stale" in the checkpoint's proof-of-work line (a proof-output, not a silent skip). Step count unchanged, so run-line checking is unaffected; the map's loop.md fingerprint is updated with it. Source: your question 2026-08-02 ("should we edit the functions so this error doesn't happen again?"); the miss itself (docs/00 corrected in commit ff321c7, caught by the writing check two loops late). Argument: this is the improvement half of the learning loop you ratified in D33, doing its first live work: a procedure gap surfaced by real failure, written back into the function file the same day — not a new mechanism invented speculatively. The backstops that caught it late (writing check, docs-verification charter) stay; the fix moves the catch from "eventually" to "the loop that causes it". Limit stated: the sweep is judgement, procedure-layer — a lazy chat could still write "none stale" falsely; the boot tests and docs-verification audit remain the layers that would expose that.

D37 — The inbox arrived and is ratified; the spawn recipe is saved, its promotion deferred by the rule you set

Concluded: mid-loop, the commit gate turned red on two files no one in this session wrote — working/inbox/ deposits from the outgoing session, exactly as the protocol inside them predicted ("undescribed files turn the owner's inventory gate red — a deposit cannot be silently missed"; it did, first try). (1) The protocol — your design, 2026-08-02: a non-owning chat deposits new uniquely-named files only, never edits, never commits — is ratified with two amendments: the protocol text lives permanently as working/inbox/README.md, and deposits are treated as relays, not evidence (a directive arriving second-hand is said to be second-hand until you confirm or the record corroborates). It is the first ratified piece of the parallel-chats protocol (deferred row 2). (2) The deposited spawn-session candidate function — your ask that the session-spawning method be saved: the full proven recipe already lives in working/lessons/2026-08-02-spawning-and-silent-noops.md and now carries the step order too; promotion to a function waits, per the promotion rule you ratified this morning (twice-proven; it has run cleanly once) — deferred row 17, yours to override. Both deposits deleted after integration, per the protocol. Source: the two deposit files (fs-created 12:45, integrated within minutes); the gate output that surfaced them; the lesson file's pre-existing recipe (corroborates the relay); D32's spawn account. Argument: ratifying was easy because the mechanism had just proven itself on its own delivery. Declining to fast-track the function is the promotion rule three hours after you ratified it — bending it for a convenient case today is how aos-8.3 got thirty functions; the lesson file gives every future chat the recipe regardless, so nothing is lost by waiting for the second run.

D38 — Build item 2 built: retrieval designed — routing, a permanent miss log, and the cluster trigger

Concluded: the retrieve function's designed form exists (working/functions/retrieve.md), delivering exactly what the accepted proposal's §2 promised. Routing: retrieve is declared the general form, with the specialised retrievals named (boot path, wiki-node lookup, git archaeology) and the duty to say in the attestation when one of them is used instead. The miss log: a partial-or-missing verdict now appends a permanent row to the "Retrieval misses" section of wiki/index.md — replacing the old rule of noting misses in the checkpoint, which is overwritten every loop, so recorded misses vanished and the scale trigger could never have fired (the same structural flaw wiki-lint found for derivation deferrals, fixed the same way). The scale trigger: search machinery is considered only at three or more misses on one area — counted at append time by the chat that hits the miss, recounted by the gap-analysis audit, no time window (a slow cluster still counts) — and then through the research gate; never pre-emptively (anti-scope 5). A fresh-context verifier checked the build against §2 before this entry was written: spec fit confirmed on both promises, the 5-step run-line contract confirmed intact, and its real findings fixed in place — a stale line in docs/05 still calling retrieval an interim rule, a section-name mismatch a grepping chat would miss on, an unwired claim that wiki-lint reads the backlog (it does not; gap-analysis does), and two design risks now closed in the text: the trigger is counted at append time (a slow cluster cannot hide between audit cycles), and wiki/index.md's header now protects its non-node sections from a future index cleanup. Source: docs/11 §2 (the spec, owner-accepted D33); the verifier's report (session record, 2026-08-02); the diffs of retrieve.md, wiki/index.md, functions/index.md, docs/09, docs/05 in this commit. Argument: the design work was mostly already owner-ruled (D23, D24, D33); what this build added — the persistent home, the named threshold, the append-time count — follows the workspace's own evidence (vanishing checkpoints, the anti-scope). Untested by construction, stated: the miss log has never accumulated a cluster, so the trigger has never fired; its first real test arrives with real retrieval load (Track 3).

D39 — Your stopping rule, wired: a turn ends only on your review or a blocking question

Concluded: your directive of 2026-08-02 ("i thought you only stop when i need to review stuff or you have questions") is now a standing rule in working/procedure.md: a turn ends only when (a) you must review or decide something — named in the reply — or (b) a question blocks the work; otherwise the chat continues down the checkpoint's Next list, because a loop-closing report is a report, not a pause. An empty Next list is said aloud, then the chat stops. Also saved to my cross-session memory so it survives outside this workspace. The rule change touched the boot contract, so boot test round 8 ran against it: a fresh chat quoted the rule and stated its concrete consequence correctly (receipt: audits.md). Source: your message, 2026-08-02, quoted verbatim; the stop it corrected (my previous turn ended with build item 3 and three audits still runnable without you). Argument: the rule was already implicit in how you run this session remotely; making it a written rule moves it from my judgement to the boot path, where round 8 proved a fresh chat picks it up.

D40 — Build item 3 closed: the wiki-write system, mostly already built — what was added, and two amendments recorded

Concluded: docs/11 §3's requirements were checked one by one by a fresh-context verifier: the mandatory derivation list (derive-wiki step 1 + the loop calling it), derive-or-defer with reasons (step 2), the persistent deferral home (wiki/index.md), and the under-derivation catch (wiki-lint, first run done) all existed; what was missing was criteria — step 2 said "derive now, or defer" but never said what deserves a node. Added, distilled from the day's real verdicts: DERIVE when a future chat would plausibly retrieve it and no existing indexed home serves that retrieval; DEFER with the converting condition when content is unstable or its home is about to be built; DROP with reason when an existing page already serves it. Two amendments to the ruled proposal, recorded here per its own banner rule: the DROP verdict (docs/11 §3 is binary derive-or-defer; a third honest outcome existed in every real run), and the criteria themselves. The verifier also confirmed from checkpoint history that every committed derive-wiki run carried its itemised list — the form has not been rubber-stamped — and its two design risks are closed mechanically this loop (see D41: the gate now demands a derive-wiki line on docs-touching commits, and gap-analysis explicitly owns the deferral conditions). Source: docs/11 §3; the verifier's requirement-by-requirement report (session record, 2026-08-02); the checkpoint history it quoted (f150950, 18a9b5a, ff321c7, 3153ebe run lines with lists). Argument: the honest form of "build item 3" was always closure, not construction — the pieces were built under D23-D26 and hardened by wiki-lint r1; pretending otherwise would inflate the build. The verifier's catch that the closure claim ran ahead of the record was correct at the time it looked — this entry and this commit are the record catching up, written after the artifacts.

D41 — The three remaining audits ran for real; the fitness audit drew blood, and the response is sunsets plus two new gate rules

Concluded: gap-analysis and function-fitness had their first real runs, and boot-test round 8 ran on the changed contract (receipts with full findings: audits.md; every mechanical fix landed this loop). The consequential parts: (1) Two gate rules from the fitness audit's strongest finding — a nine-commit window this morning carried Loop attestations claiming deviations=none while declared steps silently did not happen, possible because a commit that never touches the checkpoint inherits the previous loop's green run line. Now: every staged commit must rewrite the checkpoint, and every docs-touching commit must carry a derive-wiki run line — both mechanical, both in run_completeness.py. The historical false attestations stay in git history; this entry is their record. (2) Sunsets, not deletions: the audit recommended retiring retrieve (zero runs ever, redesigned at zero load — its words: the aos-8.3 anti-pattern one level up), merging add-system (one run, two silently-skipped triggers), and probation for evaluate-panel (four runs, all default classifications). Ratified functions get dated tests instead: conditions in the functions index, evaluated at the next fitness cycle (due 2026-08-23) — the 15-hour observation window is too thin to kill on, and Track 3 is exactly when their triggers should fire for real. If the conditions fail then, the audit's recommendation executes. (3) Gap-analysis yields: deferred row 12 closed (the dashboard exists — its condition was met by evolution), rows 2/11/13 re-scoped to their true remainders, row 18 added (secrets policy for apps), the inbox got its wiki node and map row, the retrieval system got its map row, docs/01's stale lesson count became countless, and two absences became watched: mid-loop failure recovery (the checkpoint header now tells a booting chat what a dirty tree means and owes) and external-claim refetch (docs-verification's charter now samples upstream sources). One finding was a false positive on recheck (the how-fable path is qualified "in the old repo" on its next line) — recorded because audits are claims too. Source: the three agents' reports (session record, 2026-08-02); the diffs of this commit; git history for the nine-commit window (08:53-10:22, checkpoint grep-verified run-line-free by the auditor). Argument: this is the audit layer doing what D33 bought: the fitness audit's null-procedure verdict — that the fresh-review practice predates and outperforms its function wrappers — is exactly the uncomfortable finding the audit exists to force, and the sunset response applies the learning loop's retirement half with evidence rather than either defensiveness or a same-day purge of owner-ratified functions. Nobody has checked this balance; the next cycle's audit grades it.

D42 — Enforcement-review's first run: the enforcers audited, two real holes, both now closed or named

Concluded: the last never-run audit ran (full receipt: audits.md). The wiring is real — hooks live, planted red blocked and named, tree restored, both map fingerprints true, no writes in the read-only repo (report-grade; the git identity is shared, so authorship cannot be attributed). Its two real findings, both about my own conduct today: (1) A false status=y in commit 75b293f — my receipt-only loop claimed a status update it did not stage; the honest form was status=n-why. Outside the already-recorded D41 window, so the pattern was not contained. Now mechanical: the commit-msg hook rejects status=y unless docs/02 is actually staged. (2) The fingerprint device can be satisfied while the account goes stale — demonstrated on my own commit 9c4b677, which bumped the map's as-of fingerprint for the gate script while leaving the map's account four rules behind. Fixed in content (the gate row now lists every live rule) and named as a standing blind spot on the map itself, with docs-verification's diagram-vs-script charter as the scheduled catch — a fingerprint can prove which version a page describes, never that the description is complete. Also fixed: the commit-gate node's "wired three ways" overstatement. Source: the audit agent's report (session record, 2026-08-02), with command outputs quoted: the planted-red transcript, the four sampled commits' diffs, git status of the old repo; the diff of this commit for the fixes. Argument: both real findings are the same lesson at two layers — self-declared claims drift toward convenience unless a mechanism reads the claim against the artifact. The attestation's status field joins the checkpoint field in being checked, not trusted; what remains self-declared (writing-check=, audits=, deviations= truthfulness) is listed on the map as such, sampled by exactly this audit on its cycle. Its self-reference limits are in the receipt: it rides the alarm it audits, and nothing external anchors any of this until you push (deferred 13).

D43 — The company-overview material read in full; the build plan is docs/13, gated on your menu

Concluded: on your pointer, the old repo's company-overview-app-info was read completely — your forensic audit directly by me, the old skill (procedure, knowledge files, component library, the Kakaku test run), the audit's thirteen findings and four fix drafts, and the authoritative tier-1/tier-2 specs plus the seven benchmark slides each by a scoped fresh agent with verified quotes. The synthesis is docs/13-company-overview-plan.md: six standing requirements distilled from your audit (source-anchored verification with a presence-diff; house furniture first-class with ASK-don't- fallback; producer never authors auditor prompts; never-invent covers graphics; hedged identity never demotes a requirement; the predecessor's failure ledger imports as seed lessons), eight structural ideas worth re-deriving, three things not carried, the kernel mapping (spawn via template, procedures extracted from real runs per the promotion rule, grounding check as floor), and a six-item decision menu of genuine product contradictions in the sources (management block, four-quadrant, thesis, word-budget scope, producer toggle, first target). The spawn waits on your verdict there. Source: your message 2026-08-02 ("see the company-overview-app-info in old aoe8.3 folder…"); the folder's own README ("read the audit findings FIRST… re-derive… rather than porting"); the three agent reports with file:line quotes (session record); my direct read of REPORT.md. Argument: your earlier "dont check now - ill guide the creation" (deferred 10) is superseded for the company-overview half by this explicit pointer — the crypto-transfer half of row 10 still waits. Reading the audit first honoured the folder's own instruction, and the striking finding is convergence: the old build's failure classes (closed-loop verification, producer-authored waivers, silent demotions) are the same diseases this kernel's machinery was built against — which is evidence the kernel generalises, and the reason docs/13 maps the fixes onto existing instruments instead of inventing new ones. Facts from the old repo's working/ are treated stale-until-checked per procedure; the specs and benchmarks are authority-ordered as the folder rules.

D44 — Your design directives for the app: macro-to-micro, components not templates, the brief as judgement not law

Concluded: your messages of 2026-08-02, wired into docs/13 the same loop. (1) Build macro to micro: first form our own documentation of the slide — its anatomy from header to component to formatting detail, derived from the seven benchmark reconstructions (the per-image recon.yaml files you remembered — confirmed present in the old folder) plus the specs — readable by you; then derive the AI wiki and the procedures from that documentation, the macro research loop (research → evaluate → research more → good-enough for the slide's goal) before its micro parts (logo retrieval, component design). (2) Components, never whole-slide templates — the system catalogues parts and combination evidence so a new slide is composed, not copied; "a real analyst might choose a different format"; the goal is to simulate how a real analyst works. (3) Authority, your ruling on my question: the tier-2 brief — from the actual La Caisse analyst you report to — is encoded as defaults with declared deviation (your pick from the options), not as unbreakable rules: ten years of judgement is a strong prior, not a law; departures are logged with reasons and surfaced for review, never silent; only a small floor is hard (the strict header format, furniture presence, font floors, source strip, never-invent for facts and graphics). The benchmarks are noted imperfect at your instruction. (4) Entry point: your chat stays in this workspace — one cockpit; the app lives as a sibling repo with its own commits, gate, and management layer (own status/decisions/deferred/actions/checkpoint/audits — the template creates all of it), copying the kernel modularly with the tether, per D33/D34. The dashboard builder was also fixed this loop so the copy apps inherit skips docs pages they don't have yet instead of crashing. Source: your two messages 2026-08-02 (design directive + the answers "Defaults + declared deviation" and the entry-point questions), quoted phrases verbatim; the old folder's README confirming the recon.yaml files; docs/13's diff this commit. Argument: the macro-to-micro derivation is your own docs→wiki pattern applied inside the app, and deriving procedures from the analysts' real artifacts keeps faith with the promotion rule (evidence, not speculation — provisional until a real run grades them). The declared-deviation model is the kernel's open-functions rule applied to slide-making, and it turns disagreements with the brief into reviewable feedback for the analyst relationship instead of either silent drift or false rigidity. Spawn still awaits your go; the first-company choice rides with it.

D45 — The analysis direction settled (micro-to-macro analysis, macro-to-micro writeup), the rebuilding analysis added, and your review gate set

Concluded: your follow-up of 2026-08-02, wired into docs/13 and docs/08 the same loop. (1) Your direction question answered and recorded: the analysis runs micro to macro — every element of every benchmark slide evaluated on its own terms (each bullet's purpose; how it works with the rest toward the slide's goal), then commonalities found across the seven; the documentation is written macro to micro for you. The bottom-up analysis is also the cross-slide reconciliation pass whose absence lost the La Caisse mark in the old build — your instinct and the audit's fix are the same move. (2) The rebuilding analysis you named is added per slide: reconstruct how the analysts likely found the information and how they decided what earned a place on the slide out of everything found — the selection judgement, which is the heart of simulating a real analyst. (3) Your review gate: the app build stops at the human-facing slide documentation; wiki and procedure derivation wait for your read. (4) The benchmarks are additionally marked not up to date — each dated, conventions read as practice-at-the-time. (5) docs/08 corrected on your catch: the dashboard and session rows were done ("literally this chat") — links moved to Standing. Source: your message, 2026-08-02, phrases verbatim; docs/13 and docs/08 diffs this commit. Argument: taking your message as the go for the work up to the gate you set — "stop at the human-facing docs" directs where the app work halts, which presumes it starts; the spawn happens this session and the analysis follows, with your named review at exactly the point you chose. Direction call is method, so it is answered rather than parked: bottom-up evidence then top-down writeup is also how your own forensic audit worked (eight scoped readers, one synthesis).

D46 — The app is live, sourced, and analysed; the template survived two honest failures; the first kernel upgrade happened by hand

Concluded: ../company-overview exists — spawned by the template, gate green, tether green, 18 locked files pinned to a real kernel commit. Getting there took three attempts — the first two stopped by a gate doing its job, the third succeeding (correction 2026-08-02, docs-verification r2: this entry originally said "each stopped by a gate", which cannot be true of the attempt that produced the live app; the entry's own Source line already counted "the two gate-failure transcripts"): the first spawn died because the checkpoint skeleton lacked the derive-wiki run line today's gate rule demands (the skeleton-drift class docs/12 predicted — fixed in the template); the second import died because frozen reference evidence must not be edited and so cannot carry our timestamp headers — the kernel gained a narrow working/references/ exemption from the stamping rule only, and adopting that fix in the app was deferred row 15's trigger arriving on schedule: the first kernel change after an app existed, upgraded by hand once (re-copy + re-lock; the tether shows it openly). In the app now: the analyst specs, all seven benchmark slides with your verbatim annotations, the per-slide reconstructions, the canonical La Caisse emblem (verified identical across the old lineage, 164x121), your audit's failure lessons as seed lessons, the producer-identity settings file — and the seven micro-to-macro slide analyses, run by seven fresh agents and persisted verbatim in working/analysis/, with the cross-slide headline facts up top (every benchmark dated and stale; seven distinct use-cases; no-takeaway-lines as the set's #1 confirmed defect; two slides proving absences are judgement). The next unit — writing the human-facing slide documentation you'll review — needs no re-analysis. Source:** the app repo's three commits at write time — spawn, setup (which contains the hand upgrade), evidence (correction 2026-08-02, docs-verification r2: originally "four commits (spawn, setup, upgrade, evidence)"; all four events are real and receipted, but the upgrade rode inside the setup commit 48be72f); the two gate-failure transcripts (session record); the kernel-tether output "18 locked files verified"; kernel commits for the skeleton fix and the exemption. Argument: two failed attempts recorded as successes-of-the-gate, not embarrassments — both were the drift classes the design named in advance, caught mechanically at first contact. The hand upgrade is row 15's own closing condition half-met; the procedure extracts after a second occurrence, per the promotion rule.

D47 — Session directives: Cloudflare replaces the artifact, the folder renames at the boundary, and this session hands over

Concluded: three of your directives, wired. (1) Publishing: the phone view moves from the Claude artifact (whose header annoys you) to your Cloudflare Pages route, like aos-8.3-docs: a repo whose index.html deploys on push. Prepared this loop: ../aos-8.3.1-docs exists locally with the current dashboard committed as index.html. Your one-time part: create the GitHub repo (lotivus/aos-8.3.1-docs), connect it to Cloudflare Pages — or say "reuse aos-8.3-docs" and I overwrite the old viewer instead (recommended: the new repo, keeping the old case-study page alive). Standing question inside it: pushes publish — either you push each time you want a fresh view, or you grant push for that docs repo only (recommended; it contains only the derived dashboard). Until it's connected, the artifact stays current as the fallback. (2) Rename to aos-8.3.1 (matching the GitHub remote): correct, and done at the session boundary, not mid-session — the running session, its transcripts, and my cross-session memory are keyed to the folder path. Deferred row 19 carries the two-minute checklist. (3) Handover: your call at 67% context — right by the workspace's own design; both repos' checkpoints are current, the analysis evidence is committed, and a fresh chat boots from cold by construction (six boot tests say so). Source: your three messages, 2026-08-02; aos-8.3-docs inspected (index.html + GitHub origin, the push-deploys pattern); the new local repo's first commit 1ec7a02. Argument: the artifact was always a delivery vehicle, never the record (D28) — swapping the vehicle changes nothing upstream: the loop's publish step becomes "copy dashboard.html to the docs repo, commit" once your Pages project exists. The rename is mechanical; the boundary timing protects the session plumbing, and the successor fixes the two path references (app kernel.lock, app CLAUDE.md) as a declared edit.

D48 — Your staleness concern was dropped by the last session; the audit you asked for found it, and the answer is now wired

Concluded: one directive of yours did fall through. At 15:13 on 2026-08-02 you sent: "but the stale for you raises issue about staleness in this system" — escalating your catch of two already-done rows on the For-you page into a question about the system itself. The session that received it never answered it and never recorded it, while its checkpoint claimed "none — everything from 2026-08-02 is wired". Today's audit — the multi-agent check you asked for ("how to check if previous fable chat tracked everything") — surfaced it: four checkers re-derived the session's record from its transcript, its commits, and both repos, and every finding was then attacked by an independent verifier before reaching you. Your concern's substance was also confirmed in the same run: the status page's own bottom sections ("In progress" / "Waiting on you") sat false from 13:38 onward — build item 3 still marked "next" five hours after D40 closed it — surviving eight commits that edited the very same page, including this session's. Response, wired the same loop: (1) the stale sections are fixed; (2) the work loop's staleness sweep now names the status page's own bottom sections explicitly — the sweep swept other pages but never the tail of the page it was standing on; (3) the two false attestations the audit found outside the previously recorded containment windows (ff321c7 12:45 status=y without docs/02; f4c1c0b 12:57 docs change with no derivation verdict — both before the 13:38/13:46 mechanical fixes existed) are now named in the audit receipts, closing the ~1-hour accounting gap; (4) the audit method itself gets a lesson: owner inputs arrive as more than one message type, and the first extraction missed seven of yours (which, once read, exonerated two decision entries by proving their owner attributions genuine). Source: the session-2 transcript (message at 2026-08-02T07:13:19Z, delivery record origin: human, line 1857/1863 of 656aefbb…jsonl under the old folder's transcript path); the workflow receipts in working/state/audits.md (docs-verification r2); commits 9c4b677 (13:38, item 3 closed) through 6baa2b6 (none correcting the section). Argument: your question was itself the test the system's honesty rules demand: the record is only trustworthy if someone who was not its author can re-derive it. It mostly held — 15 commits attested, 8 messages traced, one dropped directive and two miscounts found, every confirmed defect fixed with its correction visible. The staleness your message named was real, and its cause was structural (a sweep that never looked at its own page's tail), not carelessness — which is exactly the kind of cause a rule can remove, so a rule now does.

D49 — "Always auto push" for the Cloudflare folder: your grant, wired as the standing publish route

Concluded: your message — "for cloudfare folder - always auto push" — is read as granting push for exactly one repository, the derived-dashboard publisher ../aos-8.3.1-docs, and it is now the standing rule: the work loop's publish step copies the standalone index.html into that repo, commits, and pushes; Cloudflare deploys on push, so your phone page updates hands-off every loop. The claude.ai artifact is retired — frozen at today's state as a fallback, never republished. The site's address, verified by fetching it: https://aos-8-3-1-docs.pages.dev. Deferred row 20 closes with this. Source: your message 2026-08-02; the successful push (87d6fd6..abcc2d3, stored credentials — no prompt); the fetch of the URL returning the dashboard with its build header; the mobile defect and fix trail in row 20 and commit f7d4f4a. Argument: the never-push rule exists because publishing is a human act on the record — the work repos stay yours alone, and CLAUDE.md, the procedure, and the loop all now state the exception in the same breath as the rule, so a future chat cannot read the grant as broader than one derived-output repo. The narrow scope is also why granting it is safe: that repo contains only a generated page whose source of truth stays here, gate-checked and history-kept.

D50 — The webpage gets a Files page; the old build's viewer mined for what else to adopt

Concluded: your report — you couldn't find 08 on the webpage — was a real discoverability failure: the dropdown showed invented tab names ("For you") with nothing mapping them to the file numbers you actually use. Fixed two ways: a Files page (second item in the dropdown) now lists the documentation folder file by file under real names — every docs/*.md sorted by number, tap to open, with its last-edited date and size, plus a filter box — and the For-you tab is labelled "For you (08)". Rows for files the site doesn't render (the folder's README) say so instead of hiding, and the page points at 01-what-is-here for the whole-workspace inventory. Adopted from the old build's viewer (../aos-8.3-docs/index.html, inspected): the Files-tab idea itself, the filter-by-name box, and its grey-row honesty (list everything, mark what isn't bundled). Declined, with reasons: its cytoscape Graph view — that is deferred row 14, unchanged (a generated docs-tree view pays at ~25+ pages; we are at 17 files); its Flow tab — our Map page (docs/10) already owns that story; its Settings tab — our font/theme buttons cover what we use; and its bundle-every-workspace-file approach (1,026 files, 3.5MB page) — our site is the docs, and the gate-backed inventory page covers the rest of the workspace honestly. Source: your message 2026-08-02; the old viewer's markup read directly (tab ids, the p-files panel, its meta line); the rebuilt page verified mechanically (17 rows, the 08 row present, filter wired). Argument: the failure class is the one this workspace keeps re-finding — a made-for-reading label hiding the thing's real name. The fix keeps both: labels for reading, filenames for finding.

Deferred — tracked, with what would close each

Your rule, adopted: what is not fixed now gets tracked here with its closing condition, so nothing depends on either of us remembering. A chat that boots here reads this page (it is in CLAUDE.md's read order), so "we remember to cross the bridge" is a property of the boot path, not of memory.

The two source files, read directly — and your design input, evaluated

You corrected me: I had read reference/06-against-ai-dev-workflows.md (a previous session's evaluation) but never the sources themselves. Both are now read in full (2026-08-01): working/user/external-sources/ai-dev-workflows.md (48 lines) and working/user/external-sources/llm-wiki.md (75 lines), both in the old repo. This page is my reading, including where the evaluation over-read or under-read them, then your design questions answered against them.

ai-dev-workflows.md — where the evaluation was right and wrong

Right, and confirmed by my read: the three-actor split (engineers / agents / code) is the file's core and was quoted accurately; "start simple: one build agent and one deterministic validation step" is faithful; and the verdict that the old repo built agents-plus-prose and skipped the code layer is a fair application of it.

Over-read #1 — the "schedule" is not in the source. The evaluation's headline synthesis — "one useful output on a schedule, plus one deterministic check that runs unasked and can turn red" — attributes more to the file than it says. The file's validation runs inside the workflow ("linter, type checker and tests run; failures return to the build agent"); it says nothing about schedules or about checks firing unasked. The schedule half came from your morning-report analogy; the synthesis is good, but it is a combination the evaluator made, presented as if the source carried it. (The same failure shape as the folder's other provenance errors — a right idea wearing the wrong source.)

Under-read #1 — the routing system. The file describes a router that classifies each task and selects "workflow, agents, models, validation steps and computing resources". The evaluation logs "Absent. No router" and moves on — missing that this is outside support for one of the old system's own designs (route.md), one of the few places the source agrees with AOS.

Under-read #2 — the bake-off. "Several agents can attempt solutions independently, with the fastest valid result selected" — not mentioned in the evaluation at all, and directly relevant to the agent-teams question you asked this session.

Worth carrying from my read: the file is 48 lines of unsourced opinion (its own evaluator said so, correctly) — but its three-actor split keeps predicting this project's failures: everything that went wrong in aos-8.3 is an agent doing code's job or grading its own.

llm-wiki.md — my reading, not a relay

The division you cite it for is really there. "You never (or rarely) write the wiki yourself — the LLM writes and maintains all of it… You read it; the LLM writes it." Your "I screen, you write" is a faithful use.

But note what position it puts the human in: sourcing, exploration, questions — "curate sources, direct the analysis, ask good questions". The earlier evaluation line that both source files "make the human the source of what a procedure should say" over-reads this one: the human chooses what enters; the LLM decides what pages exist and say, and the schema "co-evolves". That is closer to your comprehension-not-direction role than the evaluation suggested.

Four things in it the reference folder never carried forward, all load-bearing for the wiki design:

1. Lint is a first-class operation. Periodically: find contradictions between pages, claims newer sources superseded, orphan pages, missing cross-references, concepts without pages. This is the knowledge-layer check-that-can-turn-red, in the source all along — the correction pass that produced your reference folder was one giant manual lint that nobody had scheduled. 2. Answers get filed back. "Good answers can be filed back into the wiki as new pages… your explorations compound." That is the promotion mechanism your episodic-memory question needs (below). 3. The index/log split. index.md (content catalog, updated every ingest) plus log.md (append-only chronology with parseable prefixes). Track 1's tracking design is this pattern plus resumability. 4. The scale claim. Index-first navigation "works surprisingly well at moderate scale (~100 sources, ~hundreds of pages)" with no retrieval infrastructure. The old repo's 108-node wiki is below that scale — its retrieval machinery was built before the need existed.

One caution about citing it at all: the file calls itself "intentionally abstract… everything mentioned above is optional and modular." It endorses almost any instantiation, so "this follows llm-wiki.md" is weak support for any specific design — including yours and including mine. (This also confirms the session record's point that testing it by keyword absence was the wrong instrument.)

And the source-of-truth conflict dissolves on a careful read. In llm-wiki, "source of truth" means the immutable raw sources — provenance. In your ruling, documentation is the source of truth — authority, what you act on. Those are different jobs, so the layers stack rather than fight: raw sources (provenance, immutable) → user docs (authority, screened by you) → AI wiki (derived, for retrieval). Three layers. The old repo's docs-generated-from-wiki design put authority in the derived layer, which is what actually collided with your ruling — not the direction of generation as such. Nobody has checked this reading; it is mine.

The Dex Horthy notes (added 2026-08-02, at your pointer)

First, what the file is: 36 lines summarising a podcast, with citation markers ([1]–[16]) that point at nothing — the same shape as a search-result summary, which your brief rightly distrusts. So I verified its load-bearing claims against Horthy's own published document (github.com/humanlayer/advanced-context-engineering-for-coding-agents, fetched 2026-08-02).

Verified against his own text: the Research → Plan → Implement phasing; "intentional compaction" (pause, distill context into a structured document, restart fresh — which is our checkpoint-and-boot design, arrived at independently); context-utilisation discipline; and — the sharpest verified point — his leverage ranking: "focus human effort and attention on the HIGHEST LEVERAGE parts of the pipeline", which for him means reviewing research and plans beats reviewing code.

Not verified (podcast-only, no fetched source): the "QRSPI" 7-step name, withholding the ticket during research, the "1–3 PRs per morning" figure, and the "dumb zone" framing. Plausible, unconfirmed.

One real discrepancy: your notes say performance degrades above "roughly 40% utilization"; his published doc says keep utilisation "in the 40%-60% range" — a target band, not a cliff. Treat the number as a heuristic either way.

What transfers to us, and the one thing that doesn't. His convergences with what we've built are striking: intentional compaction is our checkpoint; his volume cap is your human-bottleneck rule from the other direction; his "broken reward signal" (models optimise passing the immediate test, nothing penalises rotting architecture) is your falsification finding wearing engineering clothes. The claimed ticket-withholding move — research agents get questions, never the hypothesis — is our framing-bias rule sharpened, and I've adopted it in the procedure regardless of whether the podcast said it, because our own reference folder documents the failure it prevents.

What doesn't transfer — and you said it yourself: his whole system assumes a senior engineer who reads everything and cannot outsource the thinking. You are not that engineer. But his own leverage ranking dissolves the problem: if reviewing research and plans is worth more than reviewing code even for seniors, then the right design puts your attention exactly where you can operate — readable research summaries, plans, and these docs — and sources the code-review function from fresh-context agents, gates, and forced disagreements. The technical thinking that can't be outsourced falls to me, checked by machinery rather than by you; the intent thinking falls to you. That division is now written into CLAUDE.md as a standing rule.

Your design input, evaluated

Flowcharts or prompts? Both, split by task shape — and the split is the three-actor rule applied inside a procedure. Steps that are deterministic belong in code or scripts (they can turn red); steps that are repeated-with-judgement belong in a written procedure the chat may follow (your flowchart form); work that is novel belongs in an outcome prompt with no procedure at all. Evidence for each leg: your PE app's diagnosed defect (references-pile without structure got worse with use) argues for procedures on repeated work; the Fable guide's skills-too-prescriptive warning and describe-outcome-not-steps argue against proceduralising judgement work on this model; and the old repo's measured shape (27 of 30 functions bracketed by unconditional evaluation steps, on a system that hit 94.5% self-maintenance) shows what over-proceduralisation costs. A flowchart whose boxes cannot fail is prose wearing a diagram.

Correction, 2026-08-02, left visible. Above and elsewhere I endorsed "his role is comprehension, not direction" as the resolution to the rubber-stamp problem. I had not yet read reference/07-ai-dev-workflows-v2.md sections 4–5 (you then pointed me at it). Its evidence partially overturns that: "I understand this" carries no information (the illusion of competence is the best-documented novice failure in that literature), and a confident, fluent wrong answer produces no confusion at all — the system being checked controls the input to the check. What survives is the reversal: you explain the thing back in your own words — "state what this does and what happens if it is wrong" — and your explanation is checked against what the system actually does. That produces a falsifiable artifact and makes you the evaluated party, which is the opposite of a rubber stamp. Alongside it: standing conditions written before any proposal exists, forced disagreements instead of verdicts (non-experts judging an exposed disagreement hit 88% vs 60% judging one proposal), process-fact checks, and domain truth you supply. My earlier endorsement stands corrected; the Track 2 design uses the surviving forms.

Your plan → iterate with me → execute → after shape: sound at session altitude (it is how this session actually ran: read/plan → deliver → verify → your review), and it matches the source file's engineer-at-beginning-and-end. Keep it as the default session shape, not a per-turn checklist — the reference folder already records the mis-scoping of exactly this draft into a per-turn ratio, withdrawn.

Episodic memory: do not build a fourth store. Your four-way split (procedural / semantic / episodic / working) is a good map of purposes, but on this substrate three of the stores already exist and the fourth is free: every session transcript is recorded in full, and git holds every state change — that is the episodic record, append-only, written by the harness rather than by the party being graded. The design question is not storage but promotion: llm-wiki's "file answers back" is the mechanism — an episode that earned it gets distilled into a wiki page (semantic) or a procedure (procedural), with a link back to the raw episode as its citation. Working memory stays what Q25 says: the small, current, overwritten checkpoint. So the lifecycle is: append-only record (episodic, free) → checkpoint (working) → distilled pages (semantic) → promoted procedures (procedural) — one record maturing, not four parallel stores. What would change my mind: if retrieval-from-transcripts proves too slow or too noisy in practice, a curated case-file layer becomes worth its maintenance; that is testable in Track 1 and I would rather test it than pre-build it.

The reference library — what we've produced that isn't part of this read flow

You asked where documents like how-fable-works.md belong, since they are not steps in the reading order. The answer this page implements (decision D19, with the reasoning): they are reference — things a person or a chat turns to while working — where the numbered pages here are explanation and status — things you read to understand. The established documentation framework for this split (Diátaxis, fetched 2026-08-02) says exactly why they should not be merged: mixing reference into a reading flow interrupts the flow and cramps the reference. So the flow gets this one page that categorises and links, and each reference work keeps a single authoritative copy.

Reference documents (docs/reference/)

• reference/how-fable-works.md — how the Fable model itself behaves:

strengths, the effort dial, refusal classifiers, failure modes, and where Anthropic's own two sources disagree. For pasting into fresh chats, and for you when the model surprises you. Readable by design — no separate "doc version" exists, on purpose (see below).

• reference/how-claude-works.md — the platform around the model: models

and effort, memory, skills, subagents and agent teams, hooks, permissions, MCP, scheduled runs, reaching you, Slack, dashboards, computer use — each claim marked docs / observed / unverified. For you when deciding what the system can lean on. The raw evidence behind its observed marks and its agent-teams section sits in working/notes-b-direct-observations.md and working/notes-agent-teams-research.md (the gap-analysis audit caught that nothing pointed at the first of these).

AI-facing derivations (wiki/)

Atomic notes derived from named sources for chat retrieval — your docs-to-wiki direction, running. The nodes (wiki/index.md owns the list) fall in three groups: model/ (how Fable behaves and refuses, from how-fable-works.md), platform/ (computer-use status, from how-claude-works.md section 13), and system/ — six nodes a chat retrieves to learn this workspace's own design: the function form, the commit gate, the state and boot system, the research gate, the update triggers, and the learning loop (how functions are born, improved, retired — ruled by your D33 verdict). Each node carries the fingerprint tether the commit gate checks, so none can silently drift from its source; a wiki-lint audit periodically checks what the tether cannot see (its first run caught this very paragraph describing three nodes when nine existed). You never need to read them; this paragraph is their user-facing account, per your "every machine artifact needs a human page" rule.

The functions (working/functions/)

Five procedures exist in the function form you designed — split steps, each step proving itself with an artifact, a when-to-use clause for matching, and bindings to the scripts they use. First approved as pilots on 2026-08-02; ratified the same day when you accepted the Track 2 proposal in full (D33), which ruled the form and the promotion rule they were built under. Their user-facing accounts:

• loop — the work cycle every unit follows: do the work, record it

in these docs, overwrite the checkpoint, run the writing check, update inventories and derive wiki nodes, end the reply with what is open for you, commit through the gate with the attestation line.

• retrieve — how a chat finds context mid-task: state the need as a

question, read the indexes, judge the candidates (never judge without the list), read what matched, and give a found/partial/missing verdict. The designed form (D38) added what the accepted proposal required: routing (a specialised retrieval like the boot path wins when it fits, declared openly), a permanent miss log in the wiki index (misses used to be noted in the checkpoint, which is overwritten every loop — they vanished), and the rule that search machinery is only ever considered when misses visibly cluster, never pre-emptively.

• add-system — the wiring procedure for every new system: its

user-facing account, its layer, how it stays fresh (named enforcement class), its judgement audit, its map row, its wiki node — so nothing new ever depends on anyone remembering to maintain it.

• evaluate-panel — the decision procedure for agent teams: states

the judgement call, classifies it against the researched criteria, and picks none / fresh verifier / jury / debate — with the rule that debate positions are never written by the party being judged.

• derive-wiki — when docs content becomes AI-wiki nodes: at the

close of accepted work, itemise what changed, judge each item derive-or-defer with reasons, write the nodes with their source fingerprints, verify with the gate.

Why no duplicate "doc versions" of the reference documents

Your suggestion of a doc-version of each was considered and declined for now (D19): both reference documents are already written to the user-facing standard (plain clauses, marked evidence), so a doc-version would be a near-verbatim second copy — and two copies of one text is the drift machine this workspace keeps catching itself on. The rule adopted instead: every artifact gets a user-facing account (a paragraph here or a page, sized to the artifact), never a parallel copy. When genuinely AI-facing artifacts arrive — functions, wiki nodes at scale — their accounts on this page grow into the page-per-function coverage you ruled.

What is in this workspace

Every file and folder in aos-8.3.1, and what each one is. Updated whenever a file is added, moved, or renamed.

Files you asked for (the deliverables)

• docs/reference/how-fable-works.md — deliverable (a). The orientation page you can

paste into a fresh Claude Fable chat so it knows how it itself works — now uncapped (your 2026-08-01 instruction), built from the prompting guide plus the launch page, ending with every disagreement found between them.

• docs/reference/how-claude-works.md — deliverable (b). The companion document about

the Claude platform — the features that change how you work with it. Every claim in it is marked docs (fetched documentation), observed (seen working in this session), or unverified.

• docs/ — deliverable (c). The documentation folder you are reading.

docs/README.md explains its read order. Its pages: 00-big-picture.md (AOE top-down — the root of the wiki-style tree), 01-what-is-here.md (this inventory), 02-status.md (where things stand), 03-decisions.md (every decision with its evidence), 04-deferred.md (what is postponed, each with the condition that closes it), 05-direction.md (the three-track proposal — Track 1 approved and built), 06-source-readings.md (my direct reading of your two source files, and your design questions answered against them), 07-state-system.md (how a fresh chat continues the work: the checkpoint, the boot path, the claim marks, and the wiki tether), 08-your-actions.md (the single page listing everything only you can do — other pages point here rather than repeating it), and 09-reference-library.md (the categorised index of reference works and wiki derivations that sit outside the reading flow), 10-system-map.md (the layered map of all systems — solid arrows enforced, dashed discipline-only, blind spots named), and 11-aos-proposal.md (the Track 2 proposal, accepted in full — D33), and 12-app-template.md (how an app workspace is born: the spawn script, the kernel lock, and the divergence tether), and 13-company-overview-plan.md (the first app's build plan and your decision menu).

• wiki/ — the AI-facing wiki, started 2026-08-01 as a deliberate test

of your docs→wiki derivation ruling: atomic notes derived from the user-facing pages, each carrying its source, its date, and one line on how it could be wrong. wiki/index.md lists every note; wiki/README.md states the format. You never need to read these — they are retrieval food for chats.

Files I made for my own working system

You can read all of these, but they are written for the AI, so they are terse.

• CLAUDE.md — the file Claude Code loads automatically when a session

starts in this folder. It tells a fresh session the boundaries (your old repo is read-only), where to catch up (docs/), and which rules to follow.

• working/ — my working files:
• working/procedure.md — the standing rules (commit rule, research

gate, subagent rules, evidence ladder), pointing at the procedures.

• working/functions/ — the functions, each with split

steps and a named artifact per step: loop.md (the work loop), retrieve.md (finding context mid-task), derive-wiki.md (when and how docs content becomes wiki nodes), add-system.md (the six wiring moves every new system goes through, so nothing new depends on anyone's memory), and evaluate-panel.md (whether a judgement call gets no agents, one fresh checker, a jury, or a full debate — by named criterion, never by habit). index.md lists them with their when-to-use clauses; a function missing from that index fails the commit gate.

• working/writing-check.md — a checklist I run before every commit,

enforcing your two writing standards (AI-facing: concise; user-facing: readable). It includes a log recording whether the check actually catches anything, which you asked for.

• working/notes-b-direct-observations.md — my raw notes of what this

session could directly observe about the platform, kept as evidence behind how-claude-works.md.

• working/notes-agent-teams-research.md — condensed findings from

the web research behind the agent-teams section of how-claude-works.md, with source list and quotes.

• working/state/ — the state layer (see docs/07-state-system.md):

checkpoint.md is the small, overwritten what-is-open-right-now file a fresh chat reads first; audits.md is the table of periodic audits with their last-run dates and results.

• working/checks/ — deterministic checks. inventory_check.sh

verifies every file in the workspace is described in this page (or in the wiki index) and that folder sizes are under their sort thresholds — it prints red with reasons, and it caught eight real gaps the day it was written. pre_commit_hook.py wires that check into Claude Code, which runs it before any git commit and blocks the commit while the check is red — tested live: it blocked me twice on 2026-08-01. githooks/pre-commit is the same check wired into git itself (belt and braces: it fires for any committer, with or without Claude Code), activated by a one-line setting recorded in CLAUDE.md. githooks/commit-msg rejects any commit whose message lacks the Loop: attestation line naming that loop's step evidence — how we know each loop followed the procedure, checkable against the commit's own changes. audit_staleness.sh reads working/state/audits.md and turns the gate red when a periodic audit is overdue — how overdue audits get raised to a chat without anyone remembering. wiring_check.py blocks the commit if any checker exists that nothing invokes or schedules — the old repo's headline failure (nineteen well-written gates that nothing ran), made impossible to recommit here. stamp_timestamps.py derives every page's created:/modified: timestamps from git history and the file system — real clocks, never typed — and bumps modified: after an edit (--touch). run_completeness.py checks every function run recorded in the checkpoint against that function's declared step list — an incomplete run with no stated deviation blocks the commit (the device you proved in aoe-8.3, restored in D30). build_dashboard.py renders all of docs/ plus the reference pages into the phone-readable snapshot — embedding its build time, source commit, live gate state, the context-meter chip, and the audits table as receipts, plus a Files page listing the docs folder under real filenames (D50) and the Turns view from git history. make_app_workspace.py spawns a complete application workspace from the kernel — copy, lock, gate, initial commit — refusing to finish unless the new workspace's own gate passes (docs/12-app-template.md). kernel_tether.py is the divergence check copied into every app: a locked kernel file changed without a written reason turns it red. context_meter.py reads the session's own transcript (the one record the chat cannot rewrite) and reports how full the model's context window is — orange at 55%, red at 60%, your thresholds. A red tells the chat to close its loop and offer handover; it never blocks anything (deferred row 21 holds the calibration condition).

• working/artifact/dashboard.html — the generated dashboard page

itself (derived output; the docs stay the source of truth, and the page says so in its own header). Published to claude.ai as the artifact, whose wrapper supplies the document skeleton.

• working/artifact/index.html — the same dashboard as a

standalone document (its own skeleton with the mobile viewport line), for serving raw from your Cloudflare docs repo — added 2026-08-02 after your phone report showed the raw copy rendered desktop-width.

• working/template/ — the app-workspace template (D33 build item

1): README.md (the AI-facing manual for the spawn), and the *.skeleton.md page blanks — CLAUDE.skeleton.md, docs-README.skeleton.md, docs-00-big-picture.skeleton.md, docs-01-what-is-here.skeleton.md, docs-02-status.skeleton.md, docs-03-decisions.skeleton.md, docs-04-deferred.skeleton.md, docs-08-your-actions.skeleton.md, checkpoint.skeleton.md, audits.skeleton.md, wiki-index.skeleton.md — which make_app_workspace.py fills at spawn. Plain account: docs/12.

• working/inbox/ — the deposit box for concurrent chats (its

README.md is the ratified protocol, D37): a chat that does not own this workspace may add new files here and nothing else; the commit gate makes every deposit impossible to miss, and the owning chat integrates then deletes it.

• working/lessons/ — one file per lesson learned, so future

sessions inherit them; the folder's filenames are their own index (no count stated here — an earlier version said "three exist" and went stale the day a fourth landed, caught by the gap-analysis audit). Highlights: the fabricated-check-record lesson (my own check's log invited an invented entry within minutes — the old repo's disease, reproduced and caught here), the computer-use evidence trail, the compression-strips-hedges finding, and the session-spawning recipe with the silent-no-op trap.

Files that were already here

• .claude/settings.json — a settings file you created that turns off

permission prompts (I never have to ask before running a command). Since 2026-08-01 it also wires the commit gate: it tells Claude Code to run working/checks/pre_commit_hook.py before every command, which blocks git commit while any check is red.

• .git/ — the git version-control history. You created it on 2026-08-01

with one commit containing .claude/settings.json and .DS_Store (the file below). I add commits as I work; only you push to GitHub (github.com/lotivus/aos-8.3.1).

• .DS_Store — a file macOS Finder creates automatically. It means

nothing and can be ignored.

How Fable works

Orientation for a fresh Claude Fable 5 chat, and the reference page on this model for anyone else. Sources: Anthropic's Fable prompting guide (the file saved at working/user/external-sources/prompting/prompt-claude-fable-5.md in the old repo, 175 lines, read in full), Anthropic's launch announcement (anthropic.com/news/claude-fable-5-mythos-5, fetched 2026-08-01), and this workspace's own live sessions. The two written sources disagree in places — the last section lists every disagreement found rather than smoothing them over. Anthropic's deeper introduction page (platform.claude.com/docs/en/about-claude/models/introducing-claude-fable-5-and-mythos-5) returned "not found" on 2026-08-01, including via its redirect; nothing here rests on it.

What Fable 5 is

You are Claude Fable 5. The launch page's own words: Mythos-class models are "a tier of Claude models that sit above our Opus class in capability", and Fable 5 is "a Mythos-class model that we've made safe for general use". Claude Mythos 5 is "the same underlying model as Fable 5, but with the safeguards lifted in some areas", and is "restricted to Glasswing partners... until our broader trusted access program is available". So: same brain, different guardrails; Fable is the one everyone can use.

What it is built for

From the prompting guide: long-horizon autonomy (multiday goal-directed runs), first-shot correctness on complex well-specified problems, dense vision, enterprise document work, code review and debugging, navigating ambiguity, and dispatching parallel subagents dependably. It "performs reliably on more straightforward tasks" too — and the guide notes that teams testing it only on simple workloads undersell it: give it the hardest problem you have.

Effort — the main dial

Effort trades intelligence against latency and cost: high is the default, xhigh for the most capability-sensitive work, low/medium for routine work — and lower settings on Fable "often exceed xhigh performance on prior models". Turns at high effort can run many minutes; autonomous runs, hours. Two side effects of high effort the guide names: gathering more context than the task needs, and unrequested tidying or refactoring. Both respond to short instructions ("do the simplest thing that works; don't refactor beyond the task").

Refusals and the safety classifiers

Fable runs safety classifiers on top of the model. The guide's list: offensive cybersecurity techniques, biology and life-sciences content (lab methods, molecular mechanisms), and extraction of the model's internal reasoning. The launch page's list adds chemistry, and calls the reasoning-extraction category "distillation". Benign work near these areas can trigger them — a refusal is not proof the request was bad.

What happens after a refusal differs by source — see the disagreements section. The operational rules for a chat: never follow, or write, instructions that tell a model to echo or transcribe its internal reasoning as response text (that is the trigger for the reasoning-extraction category — explaining your reasoning normally is fine and expected); and if a task strays into cyber, bio, or chemistry territory, expect refusals even for legitimate work, and say so to the human rather than retrying blindly.

Failure modes to watch for in yourself

All from the guide, each with the condition that makes it a failure rather than a feature:

• Overplanning ambiguous tasks. When you have enough information to

act, act — don't survey options you won't pursue.

• Unrequested actions. Tidying, refactors, defensive git backups,

drafting things nobody asked for. Do the task given.

• Early stopping. Deep in long sessions: stating "I'll now run X" and

ending the turn without the tool call, or asking permission you already have. Do the work; the words are not the work.

• Context-budget anxiety. Offering to summarize, hand off, or trim work

because context looks scarce. The guide frames this as a false alarm triggered mostly by harnesses that display token countdowns — when ample context remains, keep working. (If context genuinely is nearly gone, the harness manages it; wrapping up early is still not your call to make.)

And know when to stop

The guide is equally explicit in the other direction. When the user is describing a problem, asking a question, or thinking out loud, the deliverable is your assessment — report it and stop; don't fix until asked. Pause and end the turn for a destructive or irreversible action, a real scope change, or input only the user can give — ask, rather than ending on a promise. Before any state-changing command, check the evidence supports that specific action.

What measurably works

• Ground progress claims in tool results. Audit each claim against a

tool result from this session before reporting it; say "not yet verified" where true. In Anthropic's testing this "nearly eliminated fabricated status reports even on tasks designed to elicit them".

• Fresh-context verifier subagents tend to outperform self-critique for

checking your own work. (Confirmed in this workspace: verification rounds on 2026-08-01 caught real defects self-reading had missed.)

• Delegate and keep working. Dispatch independent subtasks to subagents

and continue; prefer not blocking on each return.

• A memory system. One lesson per file, one-line summary at top; record

corrections and confirmed approaches with why; update rather than duplicate; delete notes that turn out wrong.

• Skills caveat. Skills written for prior models are often too

prescriptive for Fable and "can degrade output quality" — review before following. Fable updates skills well mid-task, but nothing persists that improvement unless you build the persistence.

For whoever prompts Fable

Give the reason behind a request, not only the request — context about intent measurably helps. Short instructions steer better than enumerating every behavior. Claude Code's own Fable guidance adds: describe the outcome you want rather than the steps. Don't show the model a remaining-context countdown. And for long asynchronous runs, give it a send-to-user tool — without an instruction to use it, Fable rarely calls such a tool on its own.

Communication

Lead with the outcome — the first sentence answers "what happened". Complete plain sentences; no arrow-chains, no invented shorthand; identifiers get a plain clause each. When short and clear conflict, choose clear.

Where the sources disagree

Found by reading both in full on 2026-08-01. Neither is "the truth"; where it matters, test.

1. Classifier domains. The guide names offensive cyber, biology and life sciences, and reasoning extraction. The launch page names cyber, biology, chemistry, and distillation. Chemistry appears only on the launch page; nobody has checked which list the deployed classifiers implement. 2. What follows a refusal. The guide says fallback to Opus 4.8 is something you configure ("To re-route declined requests automatically, configure server-side or client-side fallback"). The launch page describes the classifiers as things that "fall back to Claude Opus 4.8" as if built in. Likely reconciliation: built into Anthropic's own products, configured in the API — but that is my inference, nobody has checked it. 3. Biology: strength or refusal zone? The launch page lists drug design, genomics research, and scientific hypothesis generation among Fable's strengths. The guide says Fable "is not intended for offensive cybersecurity or biology and life sciences work" and routes those to refusals. Both statements are real; a general user should expect the guide's behavior, not the launch page's. This is the same marketing-versus-docs pattern found earlier on computer use — treat launch-page capability lists as claims about the model, not about what your account can do. 4. The introduction page is unreachable. The guide links a companion page for API parameter changes (adaptive thinking only, summarized-only thinking output, no extended thinking budgets, the refusal stop reason). That page 404'd today, so those details rest on the guide's summary note alone.

How Claude works — the platform features that change how you work with it

Written 2026-08-01 for Josh. Every claim here comes from one of two places: Anthropic's documentation, fetched that day (marked docs), or something directly observed working in a live Claude Code session on your machine (marked observed). Anything weaker is marked unverified. Platform details change; if a claim matters months from now, re-check it.

The companion page how-fable-works.md covers the model itself. This page covers the platform around it.

1. The models, and what each is for

Claude is a family of models, and you pick per session (the /model command in Claude Code) or per subagent (observed: this session did both today):

• Fable 5 — the newest and most capable tier; the models page calls it

"Anthropic's most capable widely released model". Best for long autonomous work and hard judgement. This session runs on it (observed).

• Opus 5 — the strongest generally-fast model.
• Sonnet 5 — mid-tier: capable, cheaper, good for bulk reading and

routine work.

• Haiku 4.5 — small and fast, for simple high-volume tasks.

(The specs and the Fable quote are docs — the models overview page cited below; the one-line role descriptions are my shorthand, nobody has checked them.)

Fable 5, Opus 5 and Sonnet 5 hold about 1 million tokens of context (roughly a few thousand pages) and can produce up to 128k tokens of output; Haiku 4.5 holds 200k and produces up to 64k (docs: platform.claude.com/docs/en/about-claude/models/overview).

Effort sets how hard a model thinks: five levels — low, medium, high (default), xhigh, max. Higher costs more and takes longer. Not every model has every level; Fable 5, Opus 5 and Sonnet 5 support the high end, and whether Haiku supports the top levels I did not check — unverified (docs: platform.claude.com/docs/en/build-with-claude/effort; your session's /effort menu describes xhigh as available on "Fable 5, Opus 4.7+, Sonnet 5" — observed).

Fast mode (/fast) makes Opus up to 2.5× faster at a higher price — "Fast mode is not a different model", just Opus served faster. It is Opus-only, so it does not apply to Fable (docs: code.claude.com/docs/en/fast-mode.md). Differs by model: no fast mode on Fable, Sonnet, or Haiku.

2. Where Claude runs

Claude Code (the coding agent you use) exists as a terminal program, a desktop app, a web version (claude.ai/code), and VS Code / JetBrains extensions. Separately, claude.ai is the chat product, and the API is the route for programs calling Claude directly. (observed: all stated by the harness — the harness being the program that wraps the model, here Claude Code itself.) Some features below belong to one surface only; each says which.

3. Memory — what a session remembers

Three mechanisms, all file-based and inspectable:

• CLAUDE.md — a file Claude Code reads automatically at session start.

It can live at user level (~/.claude/CLAUDE.md, applies everywhere) and project level (the folder you launch from) — project loads after user, so more specific instructions come later (docs: code.claude.com/docs/en/memory.md). This is why running from a different folder gives you a clean-slate session — the old repo's CLAUDE.md never loads (observed: exactly your setup).

• Auto memory — each project gets a private directory

(~/.claude/projects/<project>/memory/) where Claude writes lessons and facts it decides are worth keeping; the index file MEMORY.md (first 200 lines) is loaded into every new session. On by default (docs: code.claude.com/docs/en/memory.md; observed: I wrote project memories there today).

• Compaction — in long sessions the conversation is summarized so work

can continue; the project CLAUDE.md is re-read from disk afterwards (docs: code.claude.com/docs/en/memory.md).

Related: every Claude Code session is also recorded, in full, as a transcript file under ~/.claude/projects/ (~ means your home folder). One caveat learned the hard way (observed): a session spawned from inside another Claude session inherits a child-session marker that silently turns transcript saving OFF — spawn with that environment variable removed (the lesson file has the exact command). That is the raw material for any "reflect on past sessions" system — your reference folder documents the format and found 465 MB of them for the old repo alone (docs: your reference/02-workspace.md).

4. Skills — reusable instructions

A skill is a folder containing a SKILL.md file of instructions. Claude uses it when relevant, or you invoke it directly by typing /skill-name. "Unlike CLAUDE.md content, a skill's body loads only when it's used" — so long procedures cost nothing until needed (docs: code.claude.com/docs/en/skills.md). Custom slash-commands are now the same thing as skills — "Custom commands have been merged into skills" (same page).

Fable caveat: skills written for older models are often too prescriptive for Fable and can degrade output — review them rather than carrying them over. Fable also "does a good job of updating skills on the fly", but nothing persists that improvement automatically — that gap is exactly where your AOS idea lives. (docs: both from Anthropic's Fable prompting guide, the file saved in your old repo at working/user/external-sources/prompting/prompt-claude-fable-5.md.)

5. Subagents — delegating work

Claude can dispatch subagents: separate Claude instances with their own context window, their own tool list, and optionally a different model and effort (defined in .claude/agents/*.md files; docs: code.claude.com/docs/en/sub-agents.md; observed: a Sonnet subagent ran today from this Fable session). Since Claude Code version 2.1.198 they run in the background by default, so the main session keeps working while they run (docs).

Three facts that shape how they are used:

• A subagent does not see the conversation — it gets only its own

instructions plus the project CLAUDE.md (docs). Brief it fully or it works blind.

• A subagent cannot ask you questions — the question tool is filtered

out; it can only report back to the session that sent it (observed previously and recorded in your reference folder, 02-workspace.md).

• A subagent's capabilities come from the session and its own config, **not

from its model** — a cheaper model is a cheaper reader, not a worse-equipped one (docs plus prior direct observation, both recorded in your reference/02-workspace.md).

There is also a Workflow system for orchestrating many subagents from a deterministic script (loops, fan-out, verification panels). It is opt-in — Claude may only use it when you ask for multi-agent orchestration, e.g. with the keyword "ultracode" (observed: present in this session).

Agent teams — debates, juries, and when they earn their cost

The pattern you used in the correction session — several agents argue fixed opposed positions with citations, separate judges rule on separate criteria, one agent synthesises — was researched against current practice on 2026-08-01 (nine sources fetched, quotes on file in working/notes-agent-teams-research.md). The honest headline first: that exact full stack appears in no fetched study as a measured architecture. Its pieces are evaluated separately; the combination is practitioner folklore that happened to work here.

What the evidence supports (each labelled by strength):

• Parallel subagents on breadth-first research — Anthropic (own product,

self-measured): a lead agent with parallel subagents "outperformed single-agent Claude Opus 4 by 90.2% on our internal research eval".

• Debate helps a weaker judge supervise stronger experts — research

preprint (Khan et al.): non-expert judges reading a debate reached 76% accuracy versus 48% without it. This is the strongest case for opposed-position debate, and note when it applies: the judge can't see the source material, the debaters can. That is exactly your situation — you supervising technical work you can't read — which may be why the pattern worked here.

• A jury beats a single judge — preprint (PoLL): a panel of smaller

models from different families, voting independently, beat one big judge and cost seven times less. The votes must be independent — the moment judges talk to each other you get the conformity failure below.

• A designated devil's advocate reduces a single judge's bias — preprint

(DEBATE), measured on standard benchmarks.

The costs and failure modes:

• Tokens: Anthropic's own figures — agents use about 4× a chat's tokens,

multi-agent systems about 15×. A panel is an expensive instrument.

• Debate often loses to cheap alternatives — two systematic studies

(preprints, Zhang et al. and Smit et al.) found multi-agent debate "often fail[s] to outperform simple single-agent baselines" that cost far less. A single fresh-context verifier — what checked this workspace's documents — is usually the right first instrument.

• Agreement is the disease — workshop paper (Wynn et al.): debating

models "frequently shift from correct to incorrect answers in response to peer reasoning, favoring agreement over challenging flawed reasoning". Panels of the same model amplify shared blind spots; mixed-model panels are the documented antidote.

• The framer steers the verdict — indirectly evidenced: tuning agents'

willingness to agree changes outcomes materially, and persuasiveness sways judges independently of truth. Whoever writes the debate positions is inside the experiment. (Your reference folder documents a live case: an agent briefed with "the flaw I want the adversary to hunt" found exactly that flaw.)

When to reach for which (my synthesis of the above — judgement, marked as such): one fresh-context verifier for routine checking; a mixed-model independent jury when a single judge's bias is the worry; a full opposed-positions debate only for high-stakes judgement calls where you are the judge and cannot read the primary material — and never with the positions written by the party whose work is being judged.

6. Hooks — the checks that can actually block

Hooks are commands the harness runs automatically at fixed events — before a tool call, after it, when Claude tries to finish a turn. A hook can block the action: exit code 2 stops it and shows Claude the reason (docs: code.claude.com/docs/en/hooks.md). They live in settings.json — Claude Code's configuration file; your workspace has one at .claude/settings.json (observed).

Why this matters to you: your old repo's audit found nineteen well-written checks that changed nothing because nothing ran them and a failure blocked nothing (docs: your AOE-AUDIT-2026-08-01.md, read in full). Hooks are the platform's native answer — a deterministic check that runs unasked and can turn red and stop the turn. Your blank workspace currently has an empty hooks block (observed).

7. Permissions — what Claude may do without asking

By default Claude Code asks before actions that touch your system, and you can save allow/deny rules so routine commands stop prompting. The rules live in the same settings.json files as hooks. A mode called bypassPermissions switches all prompting off — which is what your workspace's settings file does today (observed: I have run every command this session without one prompt). There is also a plan mode, where Claude explores and proposes before changing anything (observed: present in this session), and a non-interactive mode (claude -p) for running Claude from scripts with nobody at the keyboard (docs: named on the computer-use page I fetched). Detail beyond that is unverified — say the word and I'll fetch the permissions pages.

8. MCP — connecting outside tools

The Model Context Protocol is the open standard for plugging external tools into Claude: databases, Slack, Google Drive, project trackers, anything with a server. Added with the claude mcp add command or a .mcp.json file in the project; the /mcp command lists and manages servers interactively (docs: code.claude.com/docs/en/mcp.md). This is the general-purpose door for wiring your apps to outside data — e.g. market data for AOET, or a Slack server so agents can post there.

9. Runs that start themselves

You asked for a system that prompts you, rather than you remembering to prompt it. The platform pieces (docs: code.claude.com/docs/en/routines.md and .../scheduled-tasks.md):

• Routines — a saved prompt + repository + connectors ("connectors"

is Anthropic's word for the integrations wired into claude.ai) that runs on Anthropic's cloud on a schedule (hourly, daily, weekly, or a custom "cron" schedule — cron is the standard notation for timetables), when an outside program calls the routine's web address, or when something happens in a GitHub repository. "They keep working when your laptop is closed." Available on Pro/Max/Team/Enterprise with Claude Code on the web enabled; runs draw down your subscription usage and have a daily cap. Two facts that shape any design on this: a routine works on a GitHub repository — "Each repository is cloned at the start of a run" — so whatever a routine maintains must be pushed to GitHub first (your workspace already has a GitHub address, github.com/lotivus/aos-8.3.1; pushing is the missing step, and pushing is yours). And each routine has a model selector — "Claude uses the selected model on every run" — though which models it offers, and whether Fable is one, I did not check (unverified). With that caveat, this is the natural home of AOET's "update the user every day" loop.

• /loop — repeats a prompt inside a live session at an interval.
• Session cron — schedule prompts inside one session (dies with it;

7-day cap) (observed: present here).

• Desktop scheduled tasks — scheduled runs on your own machine with

local file access (docs, page not fully read — details unverified).

10. Reaching you when you're not at the terminal

• Channels (research preview): Telegram, Discord, or iMessage bots wired

into a running session — messages from your phone land in the session, and Claude's replies appear on the platform, not the terminal (docs: code.claude.com/docs/en/channels.md; observed: Telegram channel skills exist in this session).

• Remote control — claude.ai can attach to a live session (you ran

/remote-control today — observed).

• Push notifications — a tool for pushing an alert to you exists in this

session (observed).

11. Claude in Slack ("Claude Tag") — and a problem for app 3

Claude Tag puts Claude in Slack channels: tag @Claude, it works in an Anthropic-hosted sandbox and replies in the thread (docs: claude.com/docs/claude-tag/overview.md).

The catch, stated exactly: "Claude Tag is available on Team and Enterprise plans... It isn't available on individual plans (Free, Pro, or Max)." You are on Max — so your reference folder records; I could not run /status myself, so give that one glance. If so, the company-director app's "agents I can talk to via Slack" cannot use Claude Tag today. The honest options: upgrade to a Team plan, or build Slack access another way (a Slack MCP server or a Slack bot calling the API — both ordinary integrations, neither tested by me; unverified). This changes the design of app 3 and is worth deciding early.

12. Artifacts — live web pages, including dashboards

Claude Code can publish a web page from a session to a private URL on claude.ai: "a live, interactive web page... it updates in place as the session continues." Republishing updates the same URL; anyone with the page open sees the update; versions are kept. Pages can even call MCP connectors at view time so they show current data, not a snapshot (docs: code.claude.com/docs/en/artifacts.md). On Pro/Max, sharing is public-link-only; org-restricted sharing needs Team/Enterprise (docs, same page).

Two limits from that same page matter for your dashboards (docs): a page that calls connectors cannot be shared by public link on any plan — on Pro/Max a connector-backed page stays private to you alone — and a published page can only call claude.ai connectors, never the local MCP servers configured inside Claude Code. So: a live-data dashboard is for your eyes; a page you share must carry snapshot data republished by a session or routine.

With that understood, this is still the cheapest way to get the dashboards you keep asking for — the AOET learning dashboard and a dashboard over the system's logs — without building or hosting a web app.

13. Computer use and browser control

The question your folder marked "never checked" now has most of its answer.

• In the API, the computer-use tool's supported-model list names Opus 5,

Sonnet 5, Opus 4.8, 4.7, 4.6, Sonnet 4.6, Opus 4.5 — Fable 5 is not on the list (docs: platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool). Absence is omission, not a stated "no" — no page says either way (unverified either direction).

• In Claude Code, computer use is *"a built-in MCP server called

computer-use. It's off by default until you enable it"* — you type /mcp, find it in the list, choose Enable (the setting then persists for that project). Its documented requirements are macOS, a Pro or Max plan (explicitly not Team/Enterprise), claude.ai sign-in, and an interactive session. No model requirement is documented anywhere on the page — I fetched it myself and checked (docs: code.claude.com/docs/en/computer-use.md). The Desktop app has the same capability on macOS and Windows via a settings toggle.

• Observed today: in this live Fable session on your Mac, no

computer-use tool exists in the session's tool registry — consistent with the server being off by default. This also explains why an earlier check with claude mcp list found nothing: that was read as disproving the MCP idea, but disabled built-in servers evidently don't show there — the earlier "disconfirmed" was wrong.

• **The ten-second test is still yours to run, and now has a concrete

script:** type /mcp, enable computer-use, and ask Claude to take a screenshot. If that works in a Fable session, the question closes as yes.

Separately, Claude for Chrome drives your actual browser (clicking, forms, logged-in sites) from Claude Code via the Claude in Chrome extension: claude --chrome, needs the extension and a Pro/Max/Team/Enterprise plan (docs: code.claude.com/docs/en/chrome.md; whether it is model-gated — whether Fable can drive it — no page I saw says: unverified). For "post to a website" or "read a dashboard" tasks this is often the practical route regardless of how the computer-use question resolves.

14. What this means for your three applications

• AOET (trading simulator): a Routine for the daily research-and-update

cycle; an Artifact for the learning dashboard, possibly MCP-connected so it shows live data; MCP for market-data sources.

• Company director (rental startup): Claude Tag is unavailable on your

plan — decide early between a Team plan and a custom Slack integration. Subagents and Workflow cover the "create and direct many agents" half; what persists between their runs has to be files, which is the AOS question. One gap to know: subagents die with their session and routines are scheduled runs, so a standing "CEO agent" you can message at any moment needs either a long-lived session wired to a channel (section 10) or a separate program built on Anthropic's Agent SDK — a toolkit for building custom agents, which the subagent docs reference (docs that it exists; whether it fits this design is unverified).

• Company-overview app (La-Caisse analyst): mostly a procedures-and-

memory problem, not a platform one — skills, CLAUDE.md, auto memory, and subagents for bulk reading are the relevant pieces.

15. What was checked, and how

Two research agents fetched every documentation page cited above on 2026-08-01 and returned verbatim quotes. I re-fetched the two most consequential pages myself — computer use and Claude Tag — and a third, fresh-context checking agent independently re-fetched three more (routines, artifacts, the models overview); every spot-checked quote matched, and that checker's findings — the GitHub requirement on routines, the artifact sharing limits, and the missing permissions section — are incorporated above. Pages not in those five rest on the research agents' fetches alone. Items marked observed happened in front of me in this session. Items marked unverified are exactly that — nobody has checked them, including me.

Turns

One row per closed loop (newest first). The chips are the loop's own attestation, checkable against that commit's diff; rows marked pre-attestation predate the rule.

Files

Every file in the documentation folder, under its real name — tap one to open its page. Rows without a button exist in the repo but are not rendered on this site (the read-order README). The inventory of everything else in the workspace is a page of its own: 01-what-is-here.