Pre-1.0: prove the agent-* stack around developer focus, attention, and owner truth

[voku]

North star

Use the remaining pre-1.0 window to optimize the agent-* stack for what is becoming the scarce resource in agentic software development:

developer attention + engineering focus

This does not mean adding an Attention subsystem, another workflow phase, another package, or a dashboard score.

The intended split is:

engineering-codelight / agent-skills
  -> how the coding agent reasons with focus
  -> evidence, uncertainty, provenance, owner boundaries, falsification,
     smallest coherent hypothesis, re-grounding, recovery

agent-loop
  -> what is currently authorized and what evidence closes the Run
  -> Contract/Run authority, mutation_ready, next_action_kind / next_action,
     cross-owner orchestration, validation/review/Learning close semantics

agent-map
  -> exact local code/navigation/impact evidence
  -> derived indexes remain owner-maintained implementation detail

agent-learning + agent-recall-compiler
  -> reusable historical evidence and bounded recall

agent-ui
  -> where human attention is returned
  -> decision presentation, evidence orientation, deltas, re-entry/navigation
  -> never workflow truth

agent-loop-runner
  -> optional execution of already-authorized work
  -> runtime observation/recovery, never correctness or authority

The target experience is:

developer grants bounded authority
-> agent works with small current engineering context
-> owner evidence updates lifecycle state
-> human is interrupted only for genuine decision_required authority
-> agent-ui presents the smallest sufficient decision/evidence context
-> human decides
-> autonomous work resumes
-> a later developer can re-enter from persisted current state without chat archaeology

A human-in-the-loop system has failed if the human becomes a shell remote control or must reconstruct state the system already owns.

Current reality (2026-09-11)

Re-ground before every slice; this section is a save point, not eternal truth.

Loop release / current head

agent-loop 0.20.5 is tagged at:

646599110aa1b7223ff58393b59e417f749fdf12

Current main is one product commit ahead at:

10bef9759fa8d6b0c09773781d458cd3837a5b6d

That head adds configured asset roots plus package_skills / package_subagents toggles. This is now the structural mechanism for reducing projected capability surface when evidence justifies it. It is not itself evidence that any default should be removed.

The former owner-path cleanup tracker #285 remains complete. Do not reopen it as generic cleanup.

Agent engineering focus

Codelight composition is complete. voku/agent-skills remains the owner of the portable engineering-codelight reasoning skill at immutable owner commit:

eaf55a0645f2871ad3a255f162dfa67d0c45e12b

agent-loop#403 completed through merged #419. The YAML bootstrap correction and hook anti-injection proof also landed. Loop now routes named PHP identities to map scope / planned edits to map context instead of sending semantic identities back to text search.

The remaining behavioral question is #420: paired fresh-session Codelight vs no-Codelight evidence on raw engineering tasks. Change guidance only when observable decisions differ, not because prose sounds more principled.

Human attention/control plane

agent-ui 0.15.0 is released and has materially grown into the human evidence surface:

• Contract revision deltas beside approval;
• Learning promotability/readability visibility;
• Contract scope vs Map impact;
• Work <-> Architecture navigation;
• source/impact continuation from Map views;
• interactive graph exploration over owner projections;
• semantic search restored through Map's typed owner API.

Project identity/probing from agent-ui#54 is complete.

Current bridge work is #418 / PR #430. It adds only optional local probe + presentation:

Loop decides canonical lifecycle result
-> optional vendor/bin/agent-ui status probe
-> only exact ready/project-bound owner result yields /task/<id>
-> unavailable/wrong UI remains presentation state
-> no lifecycle reclassification

No generic hooks, no repository-configured command execution, no browser authority, no Loop -> UI package dependency.

Learning / Recall owner boundary

Learning 0.18.6 owns self-healing of recomputable lineage projections at ordinary read boundaries; Loop now requires that released owner floor.

The numeric-looking identity defect ("403") is owner-fixed through the lossless identity_depths projection. Recall consumes that shape, and the released Learning 0.18.5 installed-consumer proof from agent-recall-compiler#171 is now merged. Do not add Loop-side int/string normalization.

Capability-surface evidence

#431 tracks the next capability-footprint question: measure projected vs actually observed-used skills/subagents before changing defaults.

Important distinction:

installed/projected != loaded/selected != useful

Use host-observable evidence only. A host that cannot reveal reliable selection/load information yields unknown, not unused.

Current executable frontier

1. Finish the Loop -> agent-ui presentation bridge

Track #418 / PR #430.

Merge only from current exact-head evidence. Required invariants:

• canonical Loop result exists before probing UI;
• UI absence/failure cannot change mutation_ready, next_action_kind, next_action, blockers, exit semantics or lifecycle state;
• only owner-reported ready yields a task link;
• repository config cannot execute arbitrary commands;
• no-UI installed consumers stay valid.

After merge, dogfood the bridge on real decision_required and ordinary re-entry cases before deleting any standalone human presentation.

2. Run the bounded Codelight behavior experiment

Track #420.

Stop after the designed paired cohort unless the evidence is genuinely ambiguous. Reward changed decisions, better owner/probe selection, falsifiable validation and avoided wrong work. Do not reward more prose, tests or token use.

3. Measure capability projection before shrinking defaults

Track #431.

Use the new configured asset/package toggles only after evidence supports one of:

KEEP_DEFAULT
PROJECT_ON_DEMAND
REPOSITORY_OWNED
DELETE_DUPLICATE
UNKNOWN

No telemetry subsystem merely to count skills.

4. Dogfood attention and re-entry, then improve only demonstrated gaps

Track voku/agent-ui#36 and voku/agent-loop-runner#18.

For real human interruptions ask:

what am I deciding?
why does this require my authority?
what changed since my last decision?
what evidence supports/challenges it?
what is unknown/stale/truncated?
what happens after the decision?

For interrupted work ask:

can I recover approved intent + current state + next action + reason + evidence
from persisted owner state without reading an old chat?

Add UI only where the answer currently requires memory, raw-file archaeology, or manual joining of owner outputs.

5. Consolidate duplicated human review presentation only after proof

After #418 is merged and real dogfood demonstrates equivalent/better interactive coverage:

preferred interactive review -> agent-ui
no-UI fallback               -> smallest deterministic truthful fallback

Census human questions and owner projections first. Do not copy Loop's HTML renderer into UI. Delete presentation code only when its questions are genuinely covered elsewhere.

Existing evidence lanes that remain valid

• voku/agent-map#61 — real legacy-scale local semantic/navigation value and boundedness;
• voku/agent-learning#73 — real-scale lineage evidence when a genuinely large owner root exists;
• voku/agent-recall-compiler#152 — bounded precedent selection at representative scale + real tasks;
• voku/agent-loop-runner#18 — real execution/recovery cohort;
• voku/agent-ui#53 — dead-public-API detection gap; do not replace it with string matching;
• Enforce main-branch CI/review gates at repository level #275 — repository enforcement remains an external GitHub administration boundary.

These lanes should produce evidence or subtraction. They do not all need to become product surfaces.

Product rules

1. Current owner state beats stale planning. Re-ground the changed delta; preserve stable authorized intent.
2. Evidence is not authority. UI, Runner, Map, Recall and review evidence never silently change product intent.
3. Every human interruption must buy a real human decision. Host prompts without decision_required are defects unless separately requested.
4. Every autonomous interval stays inside granted authority. Fewer prompts must not mean broader silent permission.
5. Human presentation should remove reconstruction work. Prefer deltas and owner-backed context over asking the developer to remember prior state.
6. The UI is replaceable. Removing agent-ui may worsen UX but must not change correctness, authority or completion.
7. The CLI is not the ideal human canvas. Keep it precise and complete; use agent-ui for rich interactive orientation when available.
8. No generic hooks until repeated evidence earns them. A narrow control-plane probe is not permission to build another workflow engine.
9. Features pay rent. Add a projection only when it changes a decision, removes manual joining/reconstruction, improves recovery, or preserves unique evidence.
10. Negative change is success. Delete duplicated guidance/presentation once an owner/harder surface truly replaces it.
11. Projection is not usage. Do not shrink or expand capability defaults from installation counts alone.

Explicit non-goals

Unless repeated real dogfood overturns these:

• no new agent-* package;
• no new workflow phase;
• no AttentionManager, focus score, token-score dashboard, or universal priority algorithm;
• no generic event/hook DSL;
• no agent-ui workflow authority or private .agent-loop/** mutation;
• no Loop dependency on agent-ui;
• no mandatory browser/UI for CI or unattended use;
• no auto-opening browsers in the first bridge;
• no daemon manager inside Loop;
• no transcript-derived truth;
• no hidden-reasoning telemetry;
• no broad architecture rewrite merely because a prettier diagram exists;
• no 1.0 deadline.

Pre-1.0 success condition

The stack is approaching a defensible stable boundary when real daily work shows that:

• coding agents stay focused by using small owner-backed engineering context rather than ever-growing bootstrap prose;
• Loop reliably returns one canonical current action and genuine authority boundaries;
• developers are interrupted only when their judgment matters;
• agent-ui presents those decisions and their evidence without owning truth;
• developers can resume after interruption/chat loss from persisted current state;
• Runner repeatedly executes/reconciles/recover real governed work without becoming authority;
• owner APIs remain bounded and private formats are not reconstructed cross-package;
• Learning/Recall/Map scale evidence remains honest;
• installed consumers remain clean without optional UI/Runner packages;
• capability projection can be reduced from evidence rather than intuition;
• repeated soft guidance/presentation can be deleted when structural enforcement or a better owner surface replaces it.

The goal is not a more impressive agent stack. It is a workflow that spends machine effort freely and human attention deliberately.

[voku]

Pre-1.0 execution update — 2026-09-06

This tracker is now producing deletions/decisions, not just another roadmap layer.

Landed / decided

• Recall typed inline owner API: agent-recall-compiler#153 merged (d0a56dc4112a9d951fbd7ee3082dee6f2a73fdd8). Canonical host path is now InlineCompileTask -> CompileRequest -> RecallCompiler -> CompileResult; CLI implementation classes remain internal.
• Loop first-party Recall skill discovery: agent-loop#390 merged (959c895f35021e0a50268746a3d7ef111f513f10), deleting the pre-0.15 RecallCli reflection/filesystem fallback.
• Loop review preparation: agent-loop#391 merged (39978188124a82fd178d75d0ac4249f50a360d88) after exact-head CI, installed release-set dogfood, release/resume proof, diagnostics, and self-shape all passed. Loop now delegates deterministic review preparation to Recall's ReviewAuditPreparer.
• Map graph Stage 2: agent-map#64 closed with KEEP_DUAL. Canonical Map relation/local semantic evidence remains JSON/TOON; graph.sqlite remains the derived structural query accelerator. The 70-MiB evidence did not justify collapsing those semantic products into one store.
• Map local semantics: agent-map#61 was already substantially implemented on current main, including $false = true, flow-sensitive narrowing, local bindings/exits, source positions, ScopeInspector and EditContextPlanner integration. The remaining work is real legacy dogfood + boundedness/warm-cache proof, not another variable-facts implementation.
• Stale premise trackers were reduced: dogfood: verify exact Map navigation replaces PHP target rediscovery #342 superseded; Teach autonomous checkpoints to challenge a failing solution premise #345 completed; Recall Fix isolated tool-project workflow activation #139 completed; Recall fix: scaffold a board that can archive its own demo card #143 retained only for its real remaining SHA-1 compatibility deletion.

Release bridge now in flight

agent-recall-compiler#154 is the 0.16.0 release candidate. After repeated byte-stability checks, its current patch changes only the new 0.16 changelog section; no historical release text remains modified. Exact head e76b22c8a0777ba3e737efa263203726525f4a07 is running CI now.

After that release is tagged, the next Loop deletion is the edit consumer: bump Recall to ^0.16.0, replace Command\\CompileCommand/CLI-token composition and private output parsing with the typed owner APIs, then prove it from a clean installed consumer.

Enrich / prove slices

• agent-learning#73: first derived lineage graph narrowed to mechanically encoded Finding/Proposal/LearningNote relations only; no inferred similarity graph in V1.
• agent-recall-compiler#152: bounded scale/query proof remains pending after the owner queries exist.
• agent-loop-runner#18: real-provider task cohort remains an external-host proof, not something CI should impersonate.
• agent-ui#36: evidence-first human surface remains after the owner projections settle.
• agent-loop#275: repository ruleset enforcement remains an external GitHub-admin boundary for this connection.

The useful shape is getting smaller: reduce duplicate ownership first, enrich only owner-backed semantics, then prove real consumers before asking what deserves a 1.0 contract.

[voku]

New executable guidance frontier: #403 — compose Codelight engineering reasoning with executable Loop authority.

This is intentionally owner-first and does not add another lifecycle:

1. voku/agent-skills: add one compact technology-neutral Codelight reasoning skill (nine-law core, workflow-neutral, size-bounded) while keeping coding-simplicity as implementation minimization.
2. agent-loop: consume the exact merged agent-skills commit, route non-trivial engineering reasoning to Codelight without copying it into SessionStart/AGENTS, and fix the stale historical human-gate wording in agent-loop-discipline.
3. Run a guidance census and delete/reroute only proven duplicate generic engineering prose from Loop assets.
4. Dogfood on a localized bug, a cross-owner change, and a recovery/stale-plan task; record observable evidence rather than a synthetic quality score.

Important current-state correction: #285 is already complete via #401 and is not part of this frontier.

Success metric: less duplicated prompt policy, not more documentation; one engineering-reasoning owner, one executable workflow authority, exact pinned consumer proof, no parallel lifecycle.

[voku]

Re-grounded after the #403 work moved while we were discussing the next dogfood step:

• Pre-1.0: compose Codelight engineering reasoning with executable Loop authority #403 is now complete via merged PR feat(skills): compose engineering-codelight with Loop authority (finish #403) #419 at merge commit 53cbfa118876096cc3495e13cb1124182e895deb; Codelight/Loop ownership composition is no longer the frontier.
• Fresh dogfood immediately exposed a more basic defect in the projected Loop bootstrap: agent-loop-discipline used an unquoted YAML description containing : , which normal YAML parsers reject before the reasoning skill can even load.
• PR fix(skills): make discipline frontmatter YAML-safe #421 contains only the loader-level correction plus a focused regression. No workflow/Codelight semantics are changed.
• Dogfood: paired Codelight attention experiment on raw engineering tasks #420 now tracks the next evidence question: paired fresh-session Codelight vs no-Codelight runs on raw engineering tasks, with crossover order and observable decision/attention evidence rather than LOC/test-count/throughput proxies.

This sharpens the current #389 sequence to: make the bootstrap load reliably -> run behavioral paired dogfood -> change guidance only from observed decision differences. Existing #418/UI work remains independent human-presentation work.

[voku]

2026-09-12 re-ground delta for the #389 north star:

• voku/agent-skills has moved from the save-point pin eaf55a0645f2871ad3a255f162dfa67d0c45e12b to merged owner commit 92cb91535505fd675afca9b874e1de1ae8dc65c0 (agent-skills#20). The Codelight delta adds fresh-context semantic review guidance and says read-only investigation/review should use a host-enforced capability boundary when the host can provide one. Loop should consume that owner boundary rather than copy the prose.
• Dogfood: shrink runtime capability surface by measuring use, cost, and compile-down candidates #431 is now sharpened from projected-vs-selected measurement into a capability diet / compile-down experiment. It keeps repo_applicability, host_selection, and decision_effect separate, adds observable runtime cost where a host exposes it, and asks a second question for capabilities that demonstrably help: can the behavior move into a static rule, typed owner API, CI invariant, Map/repository fact, workflow code, or deterministic formatter/rewriter?
• The target is therefore stronger than "select fewer skills": useful engineering learning should leave LLM-readable runtime context when a deterministic owner can replace it, and the superseded prose should then be deleted or shrunk. SEMANTIC_GUIDANCE is the residual category, not the preferred destination for every learning.

No new subsystem follows from this. Existing configured asset roots plus package_skills / package_subagents remain the projection mechanism; existing semantic owners remain the deterministic destination. The experiment should earn subtraction rather than create a CapabilityManager.

[voku]

Pre-1.0 delta — 2026-09-12

Current execution has moved materially beyond the save-point in the issue body. Keeping this as a delta comment rather than rewriting the historical body while active PRs are still moving.

Completed / structurally learned

• Restore stale-verification convergence after artifact-hash memoization #433 stale-verification convergence: completed via merged fix(run): keep projected artifact identity content-exact #434 (20afa418867585833e1fd10b0169e69135cb60fa). The regression was not missing guidance; an already compiled CI invariant caught a weakened artifact-identity cache. This is the desired Learning direction: reusable lesson -> deterministic invariant -> later regression caught without runtime recollection.
• Dogfood: shrink runtime capability surface by measuring use, cost, and compile-down candidates #431 capability diet / compile-down: completed with a bounded real-work cohort. No telemetry package, score, CapabilityManager, or package-default churn was justified. Named PHP identities and literal/config tasks support keeping the tiny adaptive router; Codelight Pair 1 remains inconclusive; lifecycle convergence is already a CI_INVARIANT, so detailed textual duplication is unnecessary.
• repository enforcement Enforce main-branch CI/review gates at repository level #275: still external. Current repository rulesets are empty and main remains technically unenforced. The stable required-check contract has now been narrowed to canonical CI contexts rather than every optional/path-specific workflow.

Active lanes owned elsewhere

• Project human attention into agent-ui without moving lifecycle authority #418 / PR feat(front-door): project verified agent-ui task links #430: Loop -> agent-ui presentation bridge is active under another agent. Do not duplicate that lane.
• Project read-only subagent intent into host-enforced sandbox where supported #432 / PR feat(subagents): project read-only intent to Codex sandbox #439: canonical read-only subagent intent -> Codex sandbox projection is active under another agent. The important remaining review boundary is executable host-capability/status truth: generated config proves projection, not observed runtime enforcement.
• Dogfood: paired Codelight attention experiment on raw engineering tasks #420: Pair 1 on agent-learning#92 found no material Codelight decision effect and was a weak specimen because the issue was already highly specified. Pair 2 remains the useful experiment before changing Codelight policy.

Map consumer evidence

#435 / PR #437 remains deliberately evidence-only. Its consumer harness has been refreshed from the older Map owner snapshot to current agent-map#93 head cbfe8841bc65e94e51254d30ac0d9fe61c106143 because the owner moved semantically in its SCIP provider/determinism proof. Loop product source and released dependency graph remain unchanged. Product integration stays blocked until the Map owner stack is merged/released normally.

The direction is getting smaller rather than broader: compile repeated rules into owner/code/CI facts, keep semantic guidance only where judgment remains, and do not turn observation gaps into new subsystems.

[voku]

Re-ground savepoint — 2026-09-12

Fresh cross-repo census after the current merge train:

• agent-loop#442 merged: Recall ^0.17.4 is now the real released floor, with candidate/installed-consumer evidence aligned.
• agent-loop#437 merged after fresh exact-head CI on current main: workflow-only Map capability dogfood remains evidence-only and does not move provider choreography into Loop.
• agent-loop#435 is complete; its old "blocked on Map release" premise is obsolete because the owner capability shipped in the released Map line.
• agent-learning#103 merged: finding-classify now provides the supported post-capture path from a valid raw Finding to explicit reusable-learning triage and promotability.
• agent-learning#92 is complete; stale duplicate #93 is closed.
• agent-loop#418 is complete.
• agent-loop#431 is complete.
• Current open-PR census across agent-loop, agent-map, agent-recall-compiler, agent-learning, agent-ui, and agent-loop-runner: none.

So the executable frontier in this issue body is partially stale. Do not reopen completed #418/#431 or the Map/Learning slices above.

Next smallest verifiable slice

Prefer agent-loop#420: run the bounded paired Codelight behavior experiment exactly as specified and stop after the designed cohort unless the evidence is genuinely ambiguous. It is now a cleaner next step than another product-integration PR because the currently identified owner-boundary and dependency-floor work has no open implementation PR.

After that, use the remaining real-evidence lanes (agent-ui#36, agent-recall-compiler#152, agent-loop-runner#18) according to observed gaps. Keep #389 as north-star/governance context, not as permission for generic cleanup.

[voku]

New executable frontier: #445 — compile current execution context before free-form discovery

Re-grounded after current work moved again:

• Loop test(map): dogfood released Map 0.12 owner #444 is an evidence-only released Map 0.12 consumer proof; keep it product-code-free unless it exposes a real defect.
• Recall dogfood: inventory external reference surface before sealing adaptation scope #173 is an evidence-only task-aware Learning scale proof; do not turn it into the context-routing implementation.
• Recall fix: tighten projected host workflow guidance #166 is the first concrete product slice because its projection waste is already measured.
• Recall fix: scaffold a board that can archive its own demo card #143 remains the right real-task surface for deciding exact context vs automatic discovery/search.

#445 now records the cross-repo sequence and, equally importantly, the explicit non-goals.

Current order:

1. finish independent evidence PRs
2. fix measured Recall projection waste (#166)
3. dogfood real Recall task shapes (#143)
4. prove whether Loop presents compiled evidence at the right execution boundary
5. change Map only for a demonstrated owner gap
6. revisit host-native plugin/routing mechanisms only after the failing boundary is known

The key correction to the earlier Map-first idea is that agent-map may only be the skipped downstream capability, not the owner of the routing/context failure. #445 therefore tests Recall first, then Loop, and treats “no product change required” as a successful outcome.

Explicitly not authorized by this frontier: no new package, AttentionManager/context manager/universal router, new lifecycle phase, Recall authority, Loop-owned Map/Learning semantics, Map workflow router, automatic provider installers, universal Map-first rule, hidden reasoning telemetry, focus/token score, generic benchmark framework, native-plugin marketplace authority, or Codelight prose expansion for behavior that can be made deterministic.

Success is smaller sufficient current evidence before execution, not a more elaborate stack.

[voku]

Re-grounded the attention/focus frontier after current Map 0.12 consumer work and Recall task-aware Learning changes.

New bounded execution lane: voku/agent-recall-compiler#174 — compile the smallest current execution context before free-form discovery.

The ownership hypothesis is now explicit:

Loop owns what may happen
-> Recall compiles what the executor needs to know now
-> Map / Learning own underlying facts
-> agent judgment handles what is not mechanically knowable

Execution order:

1. finish Recall fix: tighten projected host workflow guidance #166 first: preserve complete audit provenance in the durable report, but bound system.md to rendered facts + an explicit omission summary;
2. continue Recall fix: scaffold a board that can archive its own demo card #143 on real task shapes: exact target/file context should be boring/direct, Search weak, automatic architecture discovery evidence-bound;
3. dogfood several real tasks and record the first additional repository-discovery action after Recall compilation;
4. only if the compiled context is useful but is not naturally present at enter/resume -> work, open the smallest Loop/host dispatch integration slice;
5. classify any remaining friction as RECALL_PROJECTION_GAP, LOOP_DISPATCH_GAP, MAP_OWNER_GAP, HOST_INTEGRATION_GAP, SOFT_GUIDANCE_GAP, or FALSE_ASSUMPTION before implementing anything.

Important current work stays separate:

• Loop Dogfood released Map 0.12 through the existing Loop map route #443 / PR test(map): dogfood released Map 0.12 owner #444 proves the released Map 0.12 owner through the existing Loop route. Green evidence there is a reason not to invent another Loop Map command.
• Recall PR dogfood: inventory external reference surface before sealing adaptation scope #173 remains scale/correctness evidence for task-aware Learning precedents. It is not an execution-context/router feature.

Explicitly not authorized by this direction:

• no AttentionManager/context-budget subsystem;
• no new agent-* package or lifecycle phase;
• no Recall workflow/mutation authority;
• no generic task/tool router or opaque LLM classifier;
• no Loop-side PHP/JS/Python/provider detection;
• no new Map CLI/front door or automatic reindex until real owner-side friction proves it;
• no rg/grep blocking or generic hook DSL;
• no native-plugin/marketplace implementation in this slice;
• no Codelight expansion from architecture preference;
• no telemetry framework / hidden reasoning capture;
• no GraphRAG/vector-search detour;
• no deletion of fallback/evidence surfaces before replacement is proven.

The success condition is deliberately subtractive: rich durable evidence, small current runtime projection, exact owner facts before fuzzy discovery, and fewer mechanically unnecessary reconstruction steps for the coding agent. If the existing boundaries already achieve that, the correct result is evidence + no product change.

[voku]

Savepoint — 2026-09-12 after Codelight / Learning-Recall evidence work

Re-grounded state has moved materially beyond the body above.

Learning / Recall

• voku/agent-learning#87 is owner-fixed and closed: task relevance is applied before the bounded precedent capacity cut instead of letting lexical note-id order decide which cross-task evidence survives.
• the owner fix is released as voku/agent-learning 0.18.7 (release content bc998ed7a8521d13eb43010c8ae89576762d9715).
• voku/agent-recall-compiler#172 is merged at 0b41bc3d275c6c68dbb1ba042a0da2f2da66cf14: Recall forwards TaskBrief.files/tags through an optional task-aware owner capability while preserving the legacy/standalone path.
• fix: keep installed first-party projections current in status #172 exact-head gate was green on PHP 8.3/8.4/8.5, PHPStan and governed agent-loop consumer dogfood.
• evidence-only Recall dogfood: inventory external reference surface before sealing adaptation scope #173 then reran fix: make mid-run scope re-planning an explicit supersession path #152's 100/500/1000 scale matrix with the three relevant cross-task notes deliberately placed at the lexical tail behind every unrelated note. All three rows are green against released Learning 0.18.7 and current Recall: owner returns 3 relevant candidates, Recall considers/selects 3, deterministic query/compile/observation, no truncation. dogfood: inventory external reference surface before sealing adaptation scope #173 is closed without merge after recording the measurements on fix: make mid-run scope re-planning an explicit supersession path #152.

Therefore the synthetic scale/correctness side of agent-recall-compiler#152 is complete and stronger than the original easy-ordering proof. Its only remaining acceptance is the explicitly separate three-real-agent-* task dogfood with independently known prior Learning evidence. That is correctly blocked on real active, human-approved LearningNotes; do not manufacture or auto-promote durable notes merely to close the issue.

Codelight #420

Pair 1 remains valid negative evidence on an over-specified task. Pair 2 self-replays were useful diagnostically but are explicitly CONTAMINATED: this conversation/model already knows Codelight concepts and historical fixes. Do not derive a keep/shrink/remove verdict from them.

The remaining causal gate is one genuinely fresh isolated Pair 2 cohort with identical historical authority/source context in both arms and only Codelight as treatment. This is an experimental isolation boundary, not missing product implementation.

Frontier consequence

Do not reopen Learning/Recall owner architecture or add more benchmark machinery here. For these two lanes, implementation has reached the intended savepoint:

#152 -> wait for real human-approved Learning history, then run 3 real tasks
#420 -> run one clean independent fresh-session pair, then apply its stop rule

Further code in either lane before those inputs exist would be process theater rather than evidence-driven work.

[voku]

Opened #457 as the explicit North-Star acceptance experiment for the learning thesis.

#389 remains the broader pre-1.0 attention/owner-truth direction; #457 asks the narrower falsifiable question that was still missing:

Task A -> Finding -> durable precedent -> later Task B -> bounded Recall selection -> L2 -> exact governed L1 -> observable changed decision -> outcome -> Dream -> human promotion -> deterministic invariant -> different Task C manifestation caught (or falsified)

This should reuse existing owner/evidence lanes rather than create another subsystem. In particular, voku/agent-recall-compiler#152 supplies the bounded real-task precedent-selection evidence, while #456 is useful falsification evidence against overclaiming the current next_action must advance hardening.

Treat #457 as an acceptance proof, not another architecture program: stop at the first missing owner boundary, fix the smallest evidenced gap, then continue the same lineage.

[voku]

2026-09-13 checkpoint: frontier moved from context construction to real-host incorporation/runtime preflight

Re-grounding after the latest slices changes the executable frontier materially.

Completed / stop-rule outcomes

• Bounded execution context: the broad Pre-1.0: compile the smallest current execution context before free-form agent discovery #445 experiment is complete and closed. Recall projection waste was fixed at the owner; Loop's final-L1 dispatch gaps were fixed in fix(execution): dispatch the final L1 contract for L2 stages #446/fix(context): project final L1 through ordinary enter #449; released Map 0.12 works through the existing Loop delegation; Dogfood released Map 0.12 through the existing Loop map route #443 is closed with the explicit result no new Loop Map/provider front door.
• Closed-learning deterministic half: learning: persist first real closed-loop precedent #459 merged the first real durable LearningNote into agent-loop's owner root. fix(workflow): generalize blocked next-action convergence #465 then tested the already-reviewed next_action must advance Constraint against a different artifact_integrity manifestation and generalized enforcement without another recovery subsystem. Self-Shape selected the Constraint but did not read system.md, yet hard enforcement still worked. That is useful compile-down evidence rather than runtime-guidance theater.
• Runner recovery: real cohort defect from roadmap: pre-1.0 semantic reset, evidence-first and reversible (Aug 2026) #18 is fixed in Runner feat: add task-scoped cross-package run manifest projection #23. A clean failed provider attempt with no StageResult/completion envelope now has an owner-supported cleanup path; dirty/result-bearing evidence remains fail-closed.

Current concrete owner gap

The other real Runner #18 miss is now isolated rather than hand-waved: doctor can know the configured provider is unavailable while status still advertises execution. Runner cannot safely reconstruct the current role from today's profile definition because execution plans are versioned and Run-bound.

Loop #466 / PR #467 therefore publishes a narrow typed current-stage owner projection from the exact persisted Plan + State binding. No provider policy enters Loop. After a released Loop owner version exists, Runner can project host availability without reading private state or calling prepareStage() merely for status.

Remaining behavioral evidence, not architecture permission

• agent-loop-runner#18: continue real governed task cohort after the known recovery/preflight defects are removed;
• agent-loop-runner#21 + agent-learning#107: real coding host must consume the known Learning-selected L2, construct/bind exact L1 through Loop, and produce an attributable engineering consequence before the soft-learning thesis can move forward;
• agent-recall-compiler#152: still needs legitimate real precedent-selection tasks; fix(workflow): generalize blocked next-action convergence #465 was inspected as a negative control and correctly did not select the unrelated new LearningNote;
• Dogfood: paired Codelight attention experiment on raw engineering tasks #420: paired fresh-session Codelight behavior remains a real-host experiment, not something CI fixtures can settle.

Current mental model

owner context + final L1              largely proven
Map released-owner delegation         proven; stop
workflow convergence compile-down     proven on a different manifestation
Runner clean provider recovery        fixed
exact current-stage runtime fact       #466/#467 in progress
real host uses precedent/L1 well       UNKNOWN

The next useful changes should therefore remove a demonstrated runtime/host seam or collect real behavioral evidence. More Recall/Map/context architecture is currently unauthorized.

[voku]

2026-09-13 acceleration checkpoint — compress the roadmap into evidence gates

The three-month direction can be collapsed substantially because current owner truth has already implemented/proved much of the intended architecture. Do not turn the roadmap into three months of feature work merely because we wrote three months on a calendar.

Just landed in this pass

• PR feat(execution): expose exact current stage role projection #467 merged as 9f4de4d3caeb73c212f70223b953a529464f3f4b; Pre-1.0: project the current execution role for external runner preflight #466 is closed.
• The new CurrentExecutionStageReader exposes exact persisted task/run/contract/plan/stage/attempt/candidate binding plus stage kind/role for external runtime preflight.
• Its PR head 32ffbcf865ddb976327ce7145efcd4fa427ce1ef had green CI, diagnostics, candidate dogfoods, installed Map/refactor consumers and release upgrade/resume proofs before merge.
• Main had moved independently, so this merge joins the additive owner boundary with the current Learning/Recall/Map dependency work rather than making Runner an authority surface. Merge-commit CI is not yet observed at this checkpoint.

What is already structurally proven

Finding
-> durable LearningNote
-> bounded Learning/Recall selection
-> L2
-> real coding host creates project-specific L1
-> Loop binds exact L1
-> governed execution

GH-457-Task-B crossed that real host boundary. Its behavioral attribution correctly remained WITHHELD, because the initiating task independently prescribed the same anti-overclaim decision.

Separately, compile-down is already real:

learned soft guidance
-> reviewed Constraint
-> deterministic PHPStan/CI enforcement
-> superseded soft guidance retired
-> provenance retained

So the product thesis is no longer blocked on architecture. It is blocked on honest behavioral evidence.

Collapse the remaining frontier to three gates

1. Natural behavioral value — Pre-1.0: prove the closed learning loop from Finding to changed future execution #457 / agent-learning#107: wait for a normal independently specified task where an existing precedent is relevant but does not already dictate the answer. Record DEMONSTRATED_VALUE, NO_DEMONSTRATED_VALUE, or WITHHELD. Do not manufacture Task C.
2. Real-host attention evidence — Dogfood: paired Codelight attention experiment on raw engineering tasks #420 and agent-recall-compiler#174: finish the contamination-controlled Codelight Pair 2 and observe what a real host still rediscovers after current Recall compilation. This is evidence work, not permission for another router/context framework.
3. Subtraction after proof — every useful repeated semantic rule gets classified as STATIC_RULE, OWNER_API, CI_INVARIANT, REPO_FACT, WORKFLOW_CODE, FORMATTER_REWRITE, or irreducible SEMANTIC_GUIDANCE. When a deterministic replacement is proven, retire the duplicated prose instead of preserving both.

Stop rule

Do not open another cross-repo architecture tracker from this checkpoint. The fastest path now is normal work plus targeted host experiments. Current owner state should be allowed to falsify the remaining thesis rather than adding machinery to make the thesis look complete.

The compressed acceptance question remains:

Does yesterday's real engineering experience change a later independent coding-agent decision, and when the lesson becomes objective/repeated, can we remove it from probabilistic runtime guidance by compiling it into deterministic owner/code/CI enforcement?

[voku]

2026-09-13 cross-repository workflow contract — connect the owners, not the prose

The current repositories are individually healthy enough that the remaining risk is coordination drift: each package can be correct while the end-to-end product still asks the coding agent or human to reconstruct the handoff between them.

Use this as the current cross-repo execution map. It does not create another architecture layer; it names the owner at every transition so future work has somewhere precise to fail.

human/product intent
        |
        v
agent-kanban
  task/card/backlog context + provenance
        |
        | intent/reference, never lifecycle authority
        v
agent-loop
  approved Contract -> governed Run -> canonical next_action
  sole workflow/mutation/evidence-acceptance authority
        |
        +------> agent-session
        |         pruneable working memory + checkpoints
        |         exact task/session ownership; safe reopen/rehydration
        |         never substitute for durable Run truth
        |
        +------> agent-recall-compiler
        |         compile the smallest current construction context
        |            ^
        |            |
        |            +-- agent-map
        |            |     exact current code/navigation/impact/provider facts
        |            |
        |            +-- agent-learning
        |                  validated Findings + durable precedents + active guidance lineage
        |
        +------> agent-skills / engineering-codelight
        |         residual engineering judgment: owner/evidence/falsification/scope
        |         only while the behavior cannot be made deterministic
        |
        v
coding host
  L2/current evidence -> project/task-specific L1
        |
        v
agent-loop
  binds exact execution-contract/L1 + candidate/stage identity
        |
        +------> local host directly
        |
        +------> agent-loop-runner (optional)
                  process/provider/workspace execution + runtime observation
                  never correctness/workflow authority
        |
        v
implementation + deterministic validation + review evidence
        |
        v
agent-loop finish/close
        |
        +------> agent-learning
        |         real outcome -> Finding when warranted
        |         repeated independent evidence -> Dream candidate
        |         HUMAN reviews durable promotion
        |         objective invariant -> Constraint/generation package
        |                                  |
        |                                  v
        |                  PHPStan / fixer / tests / CI / owner code / Map fact
        |                                  |
        |                         retire superseded soft guidance
        |
        +------> agent-session
                  working memory can be pruned once resume-critical state is durable

agent-ui sits beside this flow:
  owner-backed human decision + evidence + re-entry presentation
  removing it may worsen UX, never correctness.

Package contract in one sentence

repository	owns	must not own	current product question
agent-kanban	task/card context, board provenance, optional task organization	governed lifecycle legality	Is task intent discoverable without consumers reconstructing board config?
agent-loop	Contract/Run authority, canonical action, L1 binding, evidence acceptance	Map/Learning private semantics; provider policy	Does every owner handoff naturally reach the executor/human at the right moment?
agent-session	pruneable working memory, checkpoints, one-open-session/task semantics	durable product/workflow truth	Can working memory disappear without losing resumability?
agent-map	mechanically knowable current repository facts and currentness/provider evidence	task/workflow routing	Which free-form discoveries are repeated because a required owner fact is genuinely missing?
agent-learning	Findings, LearningNotes/precedents, guidance lineage, Dream/promotion evidence, Constraints	automatic approval; execution authority	Does real future evidence return as new Findings and eventually compile down?
agent-recall-compiler	deterministic bounded current context / L2 construction input	workflow authority; private owner reconstruction	After receiving this context, what does a real host still rediscover unnecessarily?
agent-skills	irreducible reusable reasoning guidance	copied workflow semantics	Does compact Codelight still change decisions after structural rules have been compiled down?
agent-ui	human attention, decision/evidence orientation, re-entry	lifecycle truth	Can a developer resume/decide without chat archaeology or manual evidence joins?
agent-loop-runner	optional host/process/workspace execution and observation	correctness, provider policy in Loop, mandatory orchestration	Which real runtime failures remain after Loop publishes exact stage/role identity?

agent-kanban already exposes typed BoardContextResolver provenance instead of requiring consumers to know its config layout. agent-session already owns one-open-Session-per-task and reopen/checkpoint semantics. Treat both as stable supporting owners unless real consumer evidence says otherwise; they are not today's feature frontier.

The actual closed-loop product goal

The project succeeds when this happens during ordinary work, without a special benchmark ceremony:

Task A
-> useful/failed real outcome
-> Finding
-> durable precedent

later independent Task B
-> Recall selects that precedent because it is relevant
-> coding agent receives bounded current facts + precedent
-> concrete L1 changes a real engineering decision/probe/validation
-> outcome is recorded honestly

repeated independent evidence
-> Dream proposes, HUMAN decides
-> objective part becomes deterministic enforcement
-> old prompt/Memory/Skill wording is retired where replaced

Task C, different manifestation
-> deterministic enforcement catches it
-> coding agent no longer needs to remember the lesson

Current evidence already proves the structural LearningNote -> Recall -> L2 -> concrete L1 -> real coding host path and separately proves one real soft guidance -> reviewed Constraint -> PHPStan enforcement -> retire superseded guidance compile-down. The remaining Learning acceptance gap is causal behavioral value on a naturally specified later task; do not manufacture it. Track #457 and voku/agent-learning#107.

Current evidence frontiers and handoffs

1. Release current owner truth first: Release 0.20.7: ship current closed-loop and execution-role owner boundaries #468 publishes the post-0.20.6 Loop boundaries, including feat(execution): expose exact current stage role projection #467's exact current-stage role projection. A released consumer boundary beats a dev-main folk contract.
2. Learning causal edge: Pre-1.0: prove the closed learning loop from Finding to changed future execution #457 / agent-learning#107 wait for a natural independent Task B where the relevant decision is not already prescribed. DEMONSTRATED_VALUE, NO_DEMONSTRATED_VALUE, and WITHHELD are all legitimate outcomes.
3. Residual discovery: agent-recall-compiler#174 records what a real executor does after bounded context. Repeated mechanically knowable missing fact -> owner gap; redundant projection -> shrink Recall; genuine uncertainty -> leave it to agent judgment. Do not redesign Map from intuition.
4. Residual reasoning prose: Dogfood: paired Codelight attention experiment on raw engineering tasks #420 runs the frozen clean Codelight ablation. If a law repeatedly helps and can be encoded, compile it down and shrink the skill; if it only changes narration, delete/shrink it.
5. Human attention/re-entry: agent-ui#36 should consume real decision_required and interruption cases from the same ordinary tasks. Add presentation only when it removes reconstruction or evidence-joining work.
6. Optional runtime execution: agent-loop-runner#18 consumes the released Loop stage-role boundary after Release 0.20.7: ship current closed-loop and execution-role owner boundaries #468 and classifies runtime/provider/workspace failures. Runner evidence may discover owner gaps, but Runner remains optional.

One routing rule for every future defect

When a real task fails, classify the first missing boundary before coding:

wrong/ambiguous product authority       -> agent-loop
missing/incorrect task-board context    -> agent-kanban
lost pruneable working context          -> agent-session
mechanically knowable code fact missing -> agent-map
history/precedent/promotion semantics    -> agent-learning
right owner fact, wrong/bloated context  -> agent-recall-compiler
irreducible reasoning failure            -> agent-skills / Codelight
human reconstruction friction            -> agent-ui
process/provider/workspace execution      -> agent-loop-runner

Then fix the smallest owning boundary, prove it through the real downstream consumer, release it, and return to the same task. No cross-package workaround if the owner can express the fact. No new package/state/manager/router because humans apparently enjoy naming things.

Stop adding architecture when the loop becomes boring

The target is not more agent-*. The target is that an ordinary coding task can enter through Loop, receive current facts/history, execute, recover, learn, compile repeated lessons down, interrupt a human only for genuine authority, and resume later from persisted state. Once that path is boring and repeated evidence mainly causes deletion rather than new abstractions, we are approaching the project goal and a defensible stable boundary.