§0 — Why the skills go unused (diagnosis)

The lead reported not using the reckon skills and suspected they "could be improved." A holistic review of all five skills (create / edit / ship / status / sync) against the server source found four mechanical causes — none is "the skills are conceptually wrong" — plus a behavioral gap (dependency-order blindness).

§1 — Historical rename rationale: reckon-ship → reckon-implement (later reverted)

The full-family rename (drop reckon-, add -plan suffix) was considered and rejected: it creates collisions (edit-plan vs the edit_plan MCP tool), noun-ish awkwardness (status-plan, sync-plan), and carries all the migration risk while fixing none of the usability causes above. The reckon- prefix is namescoping that aids discovery and dodges every collision. Only ship is a bad noun ("implement" describes the skill's execute-and-record job better). Because reckon-implement kept the prefix, even the reckon-* directory glob in reckon-sync still matches — blast radius stays tiny.

Rename inventory (full sweep):

• Skill dir skills/reckon-ship/ → skills/reckon-implement/ during the temporary rename; the live repo now restores skills/reckon-ship/.
• Cross-references in the other four skills (create/edit/status all point at reckon-ship).
• reckon/cli.py:432 SKILLS list entry (doctor/install-skills).
• Re-point symlinks in ~/.claude/skills/ and ~/.agents/skills/.
• Reckon repo AGENTS.md routing table + all /reckon-ship mentions.
• Migrate recommends_skill="/reckon-ship …" in reckon docs + the ~10 imas-codex plan HTML files (so queued followups stay live).
• User-global ~/.agents/AGENTS.md + imas-codex AGENTS.md Plan System tables.

§2 — Systemic fixes (all five skills)

• impl truth. Correct the "server-computes-impl" falsehood in PLAN-FORMAT.md, AGENTS.md, and the skills; reckon-ship sets impl = shipped_sections / total on every landing (monotonic, meaningful). Leave version/modified as genuinely server-owned.
• allowed-tools. Add mcp__reckon___read_plan / edit_plan (and audit for status) to create/edit/status/implement.
• Fast-path. A 4–6 line "to do X, do Y" recipe atop each skill; demote checkout_path / edit_plan(create=True) deep-dives below the everyday steps.
• §05 dedup. One canonical §05 template; the others reference it. Fix reckon-edit:149's example that violates its own "don't re-list decisions" rule.
• Dependency gate. reckon-ship Step 1 reads depends_on; STOP+surface if a prerequisite isn't shipped/done; name the blocks successors on completion.

§3 — Structural redesigns

• reckon-status leads with the DAG. A "dependency order / ready-set / what-to-ship-next" section computed from depends_on (ready = active plans whose prereqs are all shipped); never recommend a plan ahead of its prerequisites. Call the audit MCP tool instead of the hand-coded checklist that drifts; add dangling/cyclic depends_on checks.
• reckon-sync → thin wrapper. Delegate CSS/index/mounts/state to reckon sync + install-skills; keep only the genuinely-unique ~/.agents/skills/ leg + legacy migration; finish with reckon doctor. Kills the two-copies-of-index.html drift hazard.
• Sprint management. ~78 lines of sprint orchestration in reckon-edit has a distinct trigger surface from plan-text editing — see decision.

Writeback is bound to reckon crew complete: nothing else may be promoted, merged, dispatched or opened before the plan write. impl advances per node landing over the orchestrator's executable-node denominator, carrying the commit and the gate's quantitative measure — a moved percentage is never the only new information — and a landing no longer pretends to close its section. 5 contract tests, suite green at 1,671; the four prescribed ops were checked against a real plan copy before integration. Full record: commit f6e2518, merged 005fc81.

§2 fixed what impl is — a settable scalar the executing skill writes, not a figure the server computes. It did not fix when. The skill writes plan state per section, and a section spans several nodes, so a plan with three landed nodes and two still in flight reads exactly like one nobody has started. The figure is stalest precisely while the work is most active, which is when every reader needs it: the next session deciding what is left, the roadmap deciding what is ready, and the lead looking at a board that appears dead.

The unit of advance is the node landing, not the section. A landing is already a discrete, evidenced event — a promoted run with a commit, a gate verdict and a measure. Writing plan state in the same beat as that promotion costs one call and removes the window in which the plan disagrees with the repository. Waiting for the section to close is what creates the window.

Detail advances with the number. A percentage that moves while the prose still describes unstarted work is a progress bar, not a record. Each landing writes what landed: the commit, the measure the gate produced, the artifact. A reader must be able to see what has been done without running anything, at any moment, not only after the last node.

A followup on the plan being shipped is a section, not a followup. Deferring same-plan work into a followup and then marking the plan complete hides it: lifecycle status is what the roadmap filters on, so a plan at shipped with impl 1.0 leaves pending_work and ready_now entirely, taking its open followup with it. Followups are for work belonging to a different plan, whose own lifecycle surfaces it.

Evidence gates

§5 — A run does not end with a foldable followup open

§4 fixed the cadence of the plan write. It left the disposal of everything a run discovers. A followup created while shipping — by the orchestrator on a landing, or by a worker reporting work it was fenced out of — is currently written and left for a session that may never come. The plan accretes debt at exactly the rate the run generates insight, which is the worst possible coupling: the more the run learns, the more it defers.

Followups generated during a run are triage input for that run, not a handoff. The orchestrator classifies every open followup and folds each one that needs no decision it cannot make into the current plan as a section, with nodes on the DAG. It repeats after every wave, because landing work generates more followups, and stops when a pass turns up nothing foldable. That termination condition is the same shape as the loop-until-dry rule already used for discovery: a simple counter would stop while the tail is still arriving.

Most followups need no decision at all — they are work somebody noticed and was fenced out of. So folding is the default and leaving one open is the exception that must name itself. The exemption is narrow and enumerable: the followup needs authority the orchestrator does not hold (spend, an outward-facing effect, an irreversible action), or it asks to reopen a locked decision and belongs in the dissent flow, or its work is owned by a different plan or repository whose own lifecycle will surface it. Anything else is folded.

The enforcement point is terminal status. A plan may not be set shipped or done while a foldable followup against it is open — which is the same failure §4 already identified from the other side: a terminal status removes the plan from the ready set and takes its open work with it. An exempt followup may remain open precisely because it states why it cannot be folded, so a reader can tell a blocked promise from a forgotten one.

Evidence gates

Project: reckon
Plan:    reckon-skill-overhaul (http://localhost:8765/reckon/reckon-skill-overhaul.html)
Section: §1 (rename) then §2 (systemic) then §3 (structural)
Tier:    opus

Context
  The reckon skill family is under-used for four mechanical reasons (impl never
  advances, MCP tools ungranted, redundancy with SPA/CLI, high activation energy)
  + dependency-order blindness. Naming LOCKED: keep reckon- prefix, rename only
  reckon-ship→reckon-implement. Honour the sprint-extraction + dep-order-home
  decisions shown live above this brief.

State to read  (code/files, not the plan)
  ~/Code/reckon/skills/reckon-{create,edit,implement,status,sync}/SKILL.md
  ~/Code/reckon/reckon/cli.py (SKILLS list ~429; install_skills ~613; doctor ~415)
  ~/Code/reckon/PLAN-FORMAT.md (impl row ~85; §05 template)
  ~/Code/reckon/AGENTS.md (routing table) ; reckon/_store.py + serve.py (impl, depends_on)
  ~/.claude/skills/reckon-* + ~/.agents/skills/reckon-* (symlinks to re-point)
  imas-codex docs/*.html (recommends_skill="/reckon-ship …" to migrate, ~10 plans)

Scope locks / constraints  (non-decision)
  Keep the reckon- prefix on all five; rename ONLY reckon-ship→reckon-implement.
  reckon primary branch = main; commit reckon and imas-codex separately, push each.
  Skill edits (SKILL.md) are NOT docs/*.html — direct edits are fine.
  No co-author trailers; stage explicit paths only.

Done-when
  1. §1: reckon-implement everywhere; cli.py updated; symlinks re-pointed;
     recommends_skill migrated in both repos; `reckon doctor` clean.
  2. §2: impl truth fixed (docs+skills); allowed-tools grant MCP tools;
     fast-path atop each skill; §05 de-duped; dependency gate in implement.
  3. §3: status leads with DAG/ready-set + audit tool; sync→thin wrapper;
     sprint per decision.
  4. uv run pytest (reckon) clean if tests exist; followups written + this resolved.

Project: reckon
Plan:    reckon-skill-overhaul (http://localhost:8765/reckon/reckon-skill-overhaul.html)
Section: §2 (finish) + §3 (structural)
Tier:    opus

Context
  §1 rename + §2 core fixes (allowed-tools, impl-truth, dependency gate) landed.
  Finish the activation-energy fixes and the structural redesigns. The
  dep-order-home decision is LOCKED skill-only; the sprint-extraction decision
  is still OPEN — lock it before touching sprint code.

State to read  (code/files, not the plan)
  ~/Code/reckon/skills/reckon-{create,edit,implement,status,sync}/SKILL.md
  ~/Code/reckon/reckon/cli.py (sync ~69; install_skills ~613; doctor ~415)
  ~/Code/reckon/docs/ui/graph.jsx (critical-path/ready-set logic to mirror in status)
  ~/Code/reckon/reckon/mcp.py (audit tool the status skill should call)

Scope locks / constraints  (non-decision)
  Keep the reckon- prefix. One canonical §05 template; others reference it.
  reckon primary branch = main; commit + push; no co-author trailers.
  A new reckon-sprint skill (if chosen) needs cli.py SKILLS + doctor test +
  symlinks + AGENTS.md — same coordinated change as the rename.

Done-when
  1. Fast-path recipe atop all 5 skills; demote checkout_path/edit_plan(create) deep-dives.
  2. One canonical §05 template; reckon-edit self-contradicting example fixed.
  3. reckon-status leads with DAG/ready-set + audit tool; dangling/cyclic depends_on check.
  4. reckon-sync = thin wrapper over reckon sync/install-skills/doctor + ~/.agents leg.
  5. sprint per locked decision. uv run pytest clean. impl advanced; this followup resolved.