Fanning a large goal out into one distill (or one loop) per service is the map.
The reduce -- assembling the slices and driving the seams between them to
convergence -- was only a hand-wave in driving-the-loop §6: "run a whole-spec
integration pass". Slices distilled in isolation don't agree at their seams: the
same entity defined twice, a rule that depends on a trigger another slice was
meant to emit, a contract demanded with nothing to fulfil it.
Turn §6 into a concrete reduce: assemble and wire the slices (canonical owner
for a shared entity, use imports), cross-check the whole set with a single
`allium analyse` call (now cross-module aware, so it reasons across use seams and
returns the seams that don't line up), route each finding through the existing
taxonomy to tend/weed, then cross-service propagate and a final witness. The CLI
does the seeing and the existing phase agents do the edits, so the orchestrator
holds slice paths and JSON, never slice bodies -- and no new agent is added.
- New reference integrating-slices.md: the seam detail (canonical entity
ownership, use wiring, contract matching, which findings signal a broken seam).
- driving-the-loop §6 rewritten as the four-step reduce, linking it.
- actioning-findings gains the cross-seam framing and documents
allium.reference.unknownName as the seam signal to read from diagnostics.
- test-skills: a reduce group pinning the procedure's constructs and links.
## Why
When the loop drives a big goal it can run for many ticks. If it stops converging, with tests not improving and weed still dirty, there is no signal until it hits an iteration cap. The loop now records each tick and warns as soon as it stalls, instead of at the cap.
## What it does
Each tick it appends a line to a trace file with the test counts, the weed verdict, the open questions, and which subagent ran and why. If a tick improves none of those, it flags a stall rather than waiting for the cap. A hook records how long each subagent call took. The final report shows the trace.
## Implementation
- One trace entry per tick in `.allium-loop/<slug>.trace.jsonl`, built from the phases' typed records.
- The stall rule is simple counting over the trace, so the model applies it directly. The threshold is a config value.
- A hook times each subagent call into `.allium-loop/timings.jsonl`. It runs where hooks are supported and does nothing elsewhere.
- Each entry records which phase ran and why, so a wasted call is visible.
## Tests
- Offline: trace entries validate, malformed ones are caught, and the stall rule is proven over trajectories.
- The hook has unit tests in CI, plus a live check that spawns a real subagent and confirms a timing line lands.
## Potential next steps
The model applies the stall rule today, with the deterministic version pinned in the tests. It could move into a script or the CLI later, which would also be the natural home for the timing.
## Why
The loop runs each phase in its own subagent. Each phase hands back a result. Until now that result was prose, so the loop had to read it and work out what it meant. This makes the result typed. The loop reads a field instead of reading a paragraph. The routing and the done check get simpler and easier to trust, with less room to misread a result. It also lays the groundwork for moving these checks into the CLI later, where code can run them instead of the model.
## What it does
Every phase now returns a small JSON record instead of prose. weed returns a verdict and its divergences. propagate returns the coverage counts. The loop reads those fields to decide what to do next. A clean verdict moves on, a code bug goes back to the code, and whether the loop is done becomes a plain check over the fields.
## Implementation
- Six schemas: one per phase result, plus the ledger.
- Each skill returns its record, with a worked example to follow.
- The routing table and the convergence check read the typed fields.
## Tests
- The test suite has a small dependency-free validator: valid records pass, malformed ones are caught, and convergence is proven as a function of the fields.
- A live test spawns each real agent and confirms its output matches its schema.
## Potential next steps
Right now the loop reads the records itself, and the validator that checks them lives in the tests, not the live loop. A possible next step is to run that check inside the loop too, first as a small script the loop calls on each hand-off, and later as part of the CLI, alongside the routing and the done check. That would be the point where these checks stop being the model's judgement and become code.
## Why
The loop keeps getting stronger. 3.10 moved each phase into its own subagent. 3.11 fanned distill out across services. Each phase runs isolated and hands back a short result. This is the next step. The loop should be able to stand behind that result and prove it. Witness gives it that. It confirms the run's own answer against ground truth, and it leaves a record the loop can show for it.
## What it does
This adds a new phase called witness. It runs at the convergence gate in its own subagent. It rebuilds the result from ground truth the run cannot fake. It reads the test runner's own exit status. It hashes each generated test and compares it to the hash propagate recorded. It reads the reconciliation line and the weed verdict. It checks the open questions. If any of that was faked, the witness fails and the loop keeps working. The loop converges only when the witness passes.
It stays cheap. It re-runs the fast deterministic tools and reads output the phases already produced. It never re-runs propagate, distill, or weed. So it costs one light pass per run.
## Implementation
- New witness skill and agent. Same dual entry as the other phases.
- Propagate records the generated test hashes in the ledger. That is the baseline the witness checks.
- The loop docs gate convergence on the witness verdict.
- Witness writes a record to `.allium-loop/<slug>.witness.json`.
- Tests cover it, including a live probe that weakens a test and confirms the witness catches it.
- Version bump to 3.12.0.
Make each skill the single source of truth; Claude Code agents become thin preload shells. Add distill and propagate agents for per-phase loop isolation. Generate VS Code agents from the canonical skills. Pin the interaction-mode contract offline and add a live parking probe.
/allium now drives the whole spec→tests→code loop to convergence. The separate /allium:loop command and standalone loop skill are removed — folded into the allium entry-point skill, with the driver procedure in skills/allium/references/driving-the-loop.md. Minor release 3.6.0 → 3.7.0.
Henry Garner