skills/reasoning-brief/SKILL.md
Synthesize the 7-section risk-forward Review Brief from a run's reasoning log. Triggers on "reasoning brief", "review brief", "synthesize the brief", "generate the brief", "brief the run", "brief for review", "story brief". You are the driver: the `acb brief` CLI renders a mechanical preservation-safe backbone and proves preservation; you synthesize the narrative prose (summary + changes), single-pass or multipass over episode chunks, then gate it through Stage-1 (mechanical, blocking) and Stage-2 (prose judge, advisory).
npx skillsauth add mjmorales/claude-prove reasoning-briefInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
You are the driver. Two invariants govern every phase — read them before any command:
acb brief validate proves this; ship nothing until it passes (Stage-1).The split follows the engine boundary — the engine owns mechanical work, the model owns judgment: the acb brief CLI owns the mechanical half (render typed sections, partition episodes, prove preservation); you own the judgment half (the Summary and Changes narrative).
The run dir is .prove/runs/<branch>/<slug>; its reasoning log lives at <run-dir>/log/<agent>/<id>.json.
claude-prove acb brief render --run-dir <run-dir> > brief.md
This is a complete, preservation-safe 7-section brief. Its Summary and Changes are seeded from synthesis entries — placeholder prose you will replace. Everything else is final.
Read the episodes — each opens on a decision and closes at the next decision/synthesis:
claude-prove acb log episodes --run-dir <run-dir>
Single-pass (small log — one chunk): write Summary and Changes directly from the episodes. Summary = the outcome in 2-4 sentences; Changes = what was done, episode by episode.
Multipass (large log — synthesis would exceed your context): partition first, then synthesize a fragment per chunk and merge.
claude-prove acb brief chunk --run-dir <run-dir> --token-budget 6000
This returns { chunks: string[][] } — each inner array is the decision-ids of one chunk's episodes. The partition covers every episode in order, so no episode is dropped. Synthesize a fragment per chunk (a subagent per chunk via the Agent tool, or sequentially), then merge the fragments into the final Summary and Changes.
Rewrite Summary and Changes in brief.md with your synthesized prose; leave every other section untouched.
claude-prove acb brief validate --run-dir <run-dir> --file brief.md
Exit 0 = every attention-bearing item survived. Exit 1 = you dropped something — the JSON missing list names each one. Re-add the missing items to the relevant section and re-validate. Do not proceed until this passes.
Spawn the brief-judge agent (Agent tool) on brief.md to assess accuracy, risk-forwardness, and coherence. The verdict is advisory — it never halts:
risk reasoning-log entry (acb log append), then ship. Revising is your call; the recorded risk is itself preservation, so the next reader sees the brief was flagged.The validated brief.md is the run's Review Brief — the PR body for story-close (paired with acb assemble for the commit-level intent) or the input to a review. The brief is the durable artifact; regenerate it from the log with acb brief render any time.
| File | Purpose |
|------|---------|
| references/design-principles.md | Design principles: engine boundary — mechanical CLI vs prose judgment |
| agents/brief-judge.md | The Stage-2 advisory prose judge |
| skills/decompose/SKILL.md | Story-close (Phase C4) drives this skill to brief a story |
testing
Anchor session context into prove primitives before compaction and rehydrate from them after. Built-in compaction summarizes by recency and drops the claude-prove state an agent needs to reorient; this skill externalizes volatile context into durable anchors (scrum tasks, decisions, run-state, a compact-anchors pointer file) pre-compact, then runs a deterministic reorientation sequence post-compact. Use before a manual /compact, when context is about to auto-compact, or immediately after a compaction. Triggers on "smart compact", "prepare for compaction", "anchor before compact", "context is getting long", "rehydrate", "reorient after compact".
tools
Apply model-driven CONTENT reshaping to stored run artifacts that sit behind the current schema, on explicit operator invocation only. Triggers on "migrate runs", "migrate run artifacts", "run content migration", "reshape run artifacts", "bring runs to current schema". You are the driver: the `run-state migrate-runs` CLI mechanically detects which artifacts are behind and emits a plan naming each one plus its migration-instruction file; you read the instructions and reshape the prose/findings, gated by the operator. The deterministic `schema migrate` handles structural column moves; this skill covers only the content reshaping beyond them. Never run as a background or resident loop — only when the operator asks.
tools
Prune stale cached versions of the prove plugin from Claude Code's plugin cache. Use when superseded versions pile up under plugins/cache and agents read stale skills/references from them, or when reclaiming plugin-cache disk space. Triggers on "clean up cached plugin versions", "prune the plugin cache", "remove old prove versions", "stale plugin cache".
development
Gather charter, team, or decomposition-kickoff answers through a self-contained HTML intake form instead of a conversational interview, then drive the same writer the conversation would. Triggers on "intake form", "fill out a form", "charter form", "team form", "decompose form", "HTML form", "render an intake form", "form instead of questions". You are the driver: render the form with `claude-prove intake render`, hand the operator the file to fill and copy, read the pasted-back payload, validate it with `claude-prove intake validate`, and map the validated answers onto the existing writer (bootstrap for charter, `scrum team` for team, the decompose ladder for decompose). The form and the interview are two front-ends to ONE writer — never a second writer.