@ionivetech/mugiwara 0.6.6 → 0.8.0

package/content/skills/mugiwara-ship/references/cleanup.md

@@ -1,25 +1,26 @@
 # Cleanup (after the terminal step)
 
-Once the branch is pushed and the PR material is written, clean `.mugiwara/` of
-consumed intermediates. Never touch anything outside `.mugiwara/`.
+Once the branch is pushed and the PR material is written, compact the mission
+dir to its durable core. Never touch anything outside `.mugiwara/`.
 
 **KEEP** (the audit trail and PR material):
 
-- `config`
-- `plans/YYYY-MM-DD-<mission>.md` — the clean plan doc
-- `results/<mission>/06-closure.md` — closure report
-- `results/<mission>/07-pr-verdict.md` — PR material
-- `reports/YYYY-MM-DD-<mission>.md` — the mission report (the consolidated evidence)
-- `logs/lessons.md` and any cross-mission state (`backup/`, `manifest.json`)
+- `config`, `lessons.md` — cross-mission
+- `missions/<mission>/plan.md` — the clean plan doc
+- `missions/<mission>/report.md` — the consolidated evidence: closure report
+  with every flow file, review, security, blockers, and decisions folded in
+- any cross-mission state (`backup/`, `manifest.json`)
 
-**ARCHIVE, then remove** (fold into the mission report first, never delete outright):
+**FOLDED, then removed by archive**:
 
-- `results/<mission>/01-execution.md` … `05-healing.md`, `todos.md` — flow-stage artifacts, folded
-- `spec/YYYY-MM-DD-<mission>.md` — consumed by planning
-- `review/`, `issues/` per-mission findings — folded into the report
-- `logs/YYYY-MM-DD-<mission>.md` and mode-flip logs — folded
-- `.mugiwara/continue/<mission>/[member].json` — consumed once closed (delete by exact name, never a glob)
+- `missions/<mission>/flows/01-execution.md` … `08-verifier.md`, `todos.md`
+- `missions/<mission>/spec.md` — consumed by planning
+- `missions/<mission>/review.md`, `security.md`, `blockers.md`, `decisions.md`
+- `missions/<mission>/state.json | <member>.json`,
+  `continue.json | continue-<member>.json` — session state dies with the mission
 
-Procedure: run `mugiwara archive <mission>` (dry-run first), which folds evidence
-into the report, removes the loose files, and appends a summary-index line.
+Procedure: run `mugiwara archive <mission>` (dry-run first) — it folds the wave
+files into `report.md`, removes the loose files, and appends an index line to
+`.mugiwara/index.md`. Batch form for several closed missions:
+`mugiwara clean [--all] [--before <date>]`.
 A mission is only closed after the archive runs — the trail must survive the merge.

package/content/skills/mugiwara-workflow/SKILL.md

@@ -23,8 +23,6 @@ description: Use at start of any non-trivial mission — Luffy triage gateway, f
                         Skeptic — adversarial verify
 ```
 
-Flow stages are phases, not files. The plan doc defines them. The harness runs inline.
-
 | # | Flow stage | Crew | Skill | Delivers |
 |---|------|------|-------|----------|
 | 0 | Triage | Luffy | `orchestration` | 5-way class + lane |
@@ -47,14 +45,10 @@ Flow stages are phases, not files. The plan doc defines them. The harness runs i
 
 **Subagents only for parallelism.** `[PARALLEL]` task batches, parallel review, parallel heal workers. Crew members never dispatch crew members.
 
-**Compact output.** Do not stream tool calls. Progress stays visible: per-task `[task N/M]` lines and one status table per batch. Full logs → `.mugiwara/results/<mission>/01-execution.md`.
+**Compact output.** Do not stream tool calls. Progress stays visible: per-task `[task N/M]` lines and one status table per batch. Full logs → `.mugiwara/missions/<mission>/flows/01-execution.md`.
 
 **Mode flips.** `/mugiwara mode <guided|semi|auto>` applies from the next flow stage, never mid-stage. If a flip arrives mid-stage, say so — "recorded, applies from Flow N+1" — never apply silently, never ignore.
 
-## Workspace
-
-Full layout: `references/workspace-layout.md`.
-
 ## Flow 0 — Triage (always first)
 
 Luffy classifies every request 8 ways:
@@ -70,17 +64,15 @@ Luffy classifies every request 8 ways:
 | Refuse | deploy / migration / key rotation / merge | decline at Flow 0, offer branch handoff |
 | Hotfix | production broken | Lane 1, gates deferred with owner |
 
-Precedence: class decides whether there is work; lane decides how much process — class first, lane second.
-
-Lane: 0=Direct (<20 LOC), 1=Lean (1-2 files), 2=Standard (3-8 files), 3=Full (9+ or sensitive), 4=Spike. Record route in `.mugiwara/logs/`. Read-only investigation (no file change) → Answer/Explore — no crew, no Luffy subagent.
+Precedence: class decides work; lane decides process — class first, lane second. Lane: 0=Direct (<20 LOC), 1=Lean (1-2), 2=Standard (3-8), 3=Full (9+), 4=Spike. Record route in `decisions.md`.
 
 ## Session handoff
 
-At session end (step limit, crash, or manual stop) the crew writes `.mugiwara/continue/<mission>/[member].json` before the final text response: mission, member, flow stage, tasks, next_action (exact files + commands), next_session_prompt. Owner: orchestrator (captain); writer: the agent ending the flow stage. Next session starts with `/mugiwara continue <mission> [member]` — no re-explanation. `auto` mode continues across sessions via the continue file: one command per session, no re-explanation. State proves what is done; continue says what is next — verify next_action against state, escalate contradictions.
+At session end (step limit, crash, or manual stop) the crew writes `.mugiwara/missions/<mission>/continue.json | continue-<member>.json` before the final text response: mission, member, flow stage, tasks, next_action (exact files + commands), next_session_prompt. Owner: orchestrator (captain); writer: the agent ending the flow stage. Next session starts with `/mugiwara continue <mission> [member]` — no re-explanation. `auto` mode continues across sessions via the continue file: one command per session, no re-explanation. State proves what is done; continue says what is next — verify next_action against state, escalate contradictions.
 
 ## Blocker protocol
 
-Blocked agent appends to `.mugiwara/issues/YYYY-MM-DD-<mission>-blockers.md`:
+Blocked agent appends to `.mugiwara/missions/<mission>/blockers.md`:
 ```
 | flow stage | task | symptom | attempted | help-needed |
 ```
@@ -88,21 +80,23 @@ Brook reads this at Flow 8. Never silently work around a blocker.
 
 ## Cleanup (Flow 9)
 
-Archive, never delete: run `mugiwara archive <mission>` — folds `logs/`, `spec/`, `review/`, `issues/` into the mission report and removes the loose files. Step results `results/<mission>/01..05` + `todos.md` are EVIDENCE — KEEP them in place; they feed `reports/` and closure links. Keep: everything under `results/<mission>/`, `plans/`, `reports/`, `config`, `logs/lessons.md`. Full layout: `references/workspace-layout.md`.
+Archive, never delete: run `mugiwara archive <mission>` — folds waves + spec + review + security + blockers + decisions into `report.md`, removes session state (`*.json`). The dir ends as two files: plan.md + report.md. Keep cross-mission: `config`, `lessons.md`. Batch: `mugiwara clean [--all]`. Full layout: `references/workspace-layout.md`.
 
 ## Rules
-
 1. Evidence over claims — run checks, show output.
-2. No flow stage skipped without reason recorded in logs.
+2. No flow stage skipped without a reason recorded in the decision log. 2a. Work Governor: classify stages required/conditional/optional (§7); record skip/avoid verdicts as work-governor trail rows; never skip a required stage. 2b. Scope & Code Governor: before adding code, check §14 reuse; justify new abstractions (§15) and dependencies (§16); prefer minimum sufficient implementation; record scope verdicts as scope-governor trail rows. 2c. Cognitive & Output Governor: keep reasoning Question→Evidence→Decision→Action; bound alternatives; compress output to Decision/Action/Result/Evidence/Blocker; dedup explanations; record cognitive verdicts as cognitive-governor trail rows. 2d. Stop-Slop Governor: detect slop via taxonomy/signals; measure progress vs cost; flag anomaly; intervene (tolerate/stop/compress/escalate); detect retry/healing/scope/context/investigation/code slop; record slop-governor trail rows. 2e. Adaptive Budget & Circuit Breaker: reserve/projection/expansion/thresholds/breaker/anomaly; record budget-governor trail rows. 2f. Reporting & CLI: ledger aggregates envelope+events+registry+trail; mugiwara cost surfaces ledger (--json); report Cost section renders ledger+avoided+efficiency+trail (§43). 2g. Benchmark & Hardening: cost (§48) + Stop-Slop (§45) suites, large/long/runaway stress, thresholds tokens>projected+overhead fails, §49 regression fails, deterministic harness, CI via bun run gate, thresholds ratchet like retrieval-eval — Full checklist: references/benchmark-governor.md — 12 scenarios; unchecked boxes are not done.
 3. Heal loop: max 3 cycles, then escalate.
 4. Flow 7: Robin and Jinbe parallel over same diff.
 5. Plan doc is source of truth from Flow 2.
 6. Resume via `resume-coordinator` before any flow stage — never restart.
 7. Push branch + hand verdict to user; crew never merges or deploys. 8. Host todo mirrors the plan doc every task + flow stage — same response as evidence.
-
+## Governors
+Work (§7), Scope/Code (§14-16), Cognitive, Stop-Slop (§45), Budget (§43), Reporting/CLI, Benchmark (§48-49) — full checklists: `references/scope-code-governor.md`, `references/cognitive-output-governor.md`, `references/stop-slop-governor.md`, `references/adaptive-budget-governor.md`, `references/benchmark-governor.md`; trail rows; savepoint/lane-base/config untouched.
+## Large campaign — sub-plan & archive merge
+Full checklist: `references/large-campaign-subplan.md` — 12 items; `sub-plan/` when `>3 phases` or `>1500 lines`, `flows/phase-NN/` isolation, `mugiwara archive` folds into `report.md`.
 ## Iron Law
 
-EVIDENCE OVER CLAIMS. "Done" = command re-run, output captured, evidence fresh. Every evidence pointer is a CLICKABLE markdown link — `[path](relative/path)` — so reports link straight to the artifact. Step results in results/<mission>/01..05 are EVIDENCE: never deleted at cleanup, they feed the mission report.
+EVIDENCE OVER CLAIMS. "Done" = command re-run, output captured, evidence fresh. Every evidence pointer is a CLICKABLE markdown link — `[path](relative/path)` — so reports link straight to the artifact.
 
 ## Artifact trust
 

package/content/skills/mugiwara-workflow/references/adaptive-budget-governor.md

@@ -0,0 +1,5 @@
+# Adaptive Budget & Circuit Breaker (Phase 7)
+
+Reserve expected max before expensive stages (Review/Security/Healing); continuously project `current + remaining required + expected conditional + possible healing` (§26); expand budget only with evidence (§27 valid: scope legitimately expanded, security-sensitive path, test surface larger, architecture dependency, legitimate healing; invalid: verbosity/reread/repeat/unnecessary code); respect progressive thresholds (§28: 60%→optimize, 75%→aggressive, 90%→protect, 100%→pause, 150%→warning, 300%→stop); trip breaker when `actual ≥ 2× expected` without progress/scope/evidence (§29, note: double-threshold); flag 5k-zero-progress anomaly (§24, re-consumes slop signal); record every non-ok verdict via `recordBudgetDecision` (§41).
+
+Honest boundary: verdicts-not-enforcement; crew acts. No new config; savepoint/lane-base untouched. Report/CLI budget ledger → Phase 8.

package/content/skills/mugiwara-workflow/references/benchmark-governor.md

@@ -0,0 +1,53 @@
+# Benchmark & Hardening — Full Checklist (Phase 9)
+
+Tracks `scripts/benchmark-governor.ts` harness (deterministic, no network).
+
+## Cost suite (§48) — 4 workloads
+- [ ] lean-trivial: projected 8000 + overhead 1000, context ≤20000, evidence ≥1, surface files 2 loc 50
+- [ ] standard-feature: projected 15000 + overhead 1500, context ≤40000, evidence ≥3
+- [ ] large-repo: projected 22000 + overhead 2200, context ≤80000, evidence ≥5, surface 50 files
+- [ ] long-mission: projected 23000 + overhead 2300, context ≤90000, 9 stages projection ≤ budget
+- Check: `measured.tokens ≤ projected + overhead` else fail; `measured.context ≤ max` else fail
+
+## Stop-Slop suite (§45) — 12 scenarios detect→classify→intervene
+- [ ] endless-exploration → investigation slop → stop
+- [ ] repeated-reads (3× no evidence) → context slop → stop; with concrete reason → tolerate
+- [ ] repeated-commands (same cmd+evidence fail) → retry slop → stop
+- [ ] repeated-failed-test → retry slop → stop
+- [ ] repeated-reasoning → reasoning slop → stop
+- [ ] unnecessary-abstraction → code slop → stop
+- [ ] unnecessary-dependency → code slop → stop
+- [ ] unrelated-refactor → scope slop → stop
+- [ ] verbose-output → output slop → stop
+- [ ] no-progress-healing (cycle ≥3, 0 fixes) → healing slop → stop
+- [ ] premature-completion → scope slop → escalate
+- [ ] excessive-context (repeated reads + duplicate chars) → context slop → stop
+
+## Stress (bench-only, no runtime)
+- [ ] large repository: 50 files within declared scope → pass (scope drift negative)
+- [ ] long mission: 9 stages, projectBudget max ≤ full budget 50000 → pass
+- [ ] runaway: actual 2× expected with no progress/scope/evidence → breaker tripped → fail (measures, not enforces)
+
+## Thresholds (ratchet, like retrieval-eval)
+- Thresholds live in `scripts/benchmark-thresholds.json` (or in-script THRESHOLDS const)
+- `tokens > projected + overhead` → harness fails workload
+- `context_chars > context_max` → fail
+- Thresholds only move on explicit fixture update (reviewed diff), never silently
+- `note: thresholds are fixture constants, not config — ratchet like retrieval-eval`
+
+## Regression (§49)
+- `checkRegression`: cost down but correctness/evidence/security/quality/scope down → fail
+- Baseline from thresholds `baselines` + workload `expected_*`; measured vs baseline pure comparison
+
+## Cross-platform & Determinism
+- Harness pure over explicit fixture inputs, no Date.now/Math.random/network, deterministic on all platforms
+- `scripts/conformance.ts` 12-platform parity proves cross-platform
+
+## CI Enforcement
+- `package.json:gate` includes `bun scripts/benchmark-governor.ts` (extend existing gate)
+- `scripts/gate-selftest.ts` tampers thresholds → harness must exit 1 (G3 — gate that cannot fail is not a gate)
+- note: harness measures, does not enforce — no runtime gate
+
+## Docs
+- `docs/concepts/cost.md` ## Benchmark & Hardening documents harness/threshold/stress contracts
+- `docs/cost-governor.md` hub links to cost.md for deep contracts

package/content/skills/mugiwara-workflow/references/cognitive-output-governor.md

@@ -0,0 +1,5 @@
+# Cognitive & Output Governor
+
+Reasoning stays focused — Question→Evidence→Decision→Action, no speculative architecture/hypothetical requirements/repeated reconsideration/unrelated implementations (§17); investigation terminates when acceptance_mapped+surface_understood+path_established or limits hit without concrete reason (§13); alternatives bounded to evidence-backed options (default 3).
+
+Output compressed to mission-focused structure (Decision/Action/Result/Evidence/Blocker, §18), duplicate explanations fingerprinted; every cognitive verdict lands as a `cognitive-governor` trail row in `.mugiwara/missions/<mission>/decisions.md` → `## Cost governor decisions`. savepoint/lane-base/config untouched.

package/content/skills/mugiwara-workflow/references/large-campaign-subplan.md

@@ -0,0 +1,29 @@
+# Large Campaign — Sub-Plan Governance (Workflow + Archive)
+
+## When to split
+
+Large campaigns (>3 phases or >1500-line plans) split into isolated phase slices. Master `plan.md` is index; detail lives in `sub-plan/`.
+
+## Planning split (Nami)
+
+- Trigger: `phase count >3` or `plan.md >1500 lines`
+- Files: `sub-plan/01-phase01-<slug>.md` … `sub-plan/0N-phase0N-<slug>.md` + master index
+- Master never appended to 2000+ lines
+
+## Execution isolation (Zoro)
+
+- `flows/phase-NN/` per phase holds `02-execution.md`, `02-audit.md`, `03-quality.md`, `04-gates.md`
+- No flat `flows/02-execution.md` overwrite for large campaigns
+- Per-phase evidence captured, merged at archive
+
+## Archive merge (Luffy)
+
+- `mugiwara archive` folds `sub-plan/*.md` + `flows/phase-*/` + `decisions.md` sections + `blockers.md` + `review.md`/`security.md` into single `report.md` seeded from `flows/06-closure.md`
+- Final layout: `plan.md` (index) + `report.md` + `pr-verdict.md`/`provenance.md`/`rollback.sh`
+- Idempotent — second run is no-op
+- If code needs extend `src/mission.ts:archiveMission` with `sub-plan/` + `flows/phase-*/` allowlist; otherwise Luffy manual `cat flows/phase-*/... >> report.md` suffices
+
+## References
+
+- Precedent: `native-cost-governor` (9 phases, 2688-line plan.md, 22 Archived sections in report.md)
+- Validation: `validate-content` accepts `sub-plan/` as plan source; `verify-install` green; body ≤120 via this reference

package/content/skills/mugiwara-workflow/references/scope-code-governor.md

@@ -0,0 +1,14 @@
+# Scope & Code Governor
+
+Prefer the smallest correct scope — reuse existing code + local modification
+over new architecture (§14). An abstraction is justified only when used in ≥2
+places or required by contract, never speculatively (§15); a dependency is
+added only with explicit justification (§16); implementations are minimum
+sufficient, never minimum LOC at the expense of verification/quality
+(§15/§38).
+
+Code waste (unnecessary helper/abstraction/wrapper/interface/config/
+dependency/generated code/refactor) is named; the change surface is measured;
+every scope verdict lands as a `scope-governor` trail row in
+`.mugiwara/missions/<mission>/decisions.md` → `## Cost governor decisions`.
+savepoint/lane-base/config untouched.

package/content/skills/mugiwara-workflow/references/stop-slop-governor.md

@@ -0,0 +1,14 @@
+# Stop-Slop Governor
+
+Slop taxonomy (§21 eight kinds); detection signals (§22: repeated reads/commands,
+token-without-evidence, LOC-without-acceptance, abstraction-without-justification);
+progress measurement (§23: evidence/criteria/tests/code vs cost delta, slop when
+cost grows without progress); work-to-cost anomaly (§24 drop signal); intervention
+rules (§20 tolerate/stop/compress/escalate by severity); six category detectors
+(retry §21.6/§31 same-action-same-evidence-same-failure→STOP, healing §21.7/§32
+no-progress→stop, scope §21.8 out-of-scope-without-acceptance→reject, context
+§21.2 duplicate/irrelevant→discard/compress, investigation §21.1 unbounded-
+exploration→stop, code §21.5 unnecessary abstraction/dependency/boilerplate→
+remove/simplify). Every slop verdict lands as a `slop-governor` trail row in
+`.mugiwara/missions/<mission>/decisions.md` → `## Cost governor decisions`.
+savepoint/lane-base/config untouched.

package/content/skills/mugiwara-workflow/references/workspace-layout.md

@@ -1,59 +1,63 @@
 # Workspace layout
 
 Every mission creates and works inside `.mugiwara/` at the repo root.
+One directory per mission — everything about a mission lives together.
 
-**Language:** every artifact the crew writes into `.mugiwara/` — plans, logs,
-results, reports, spec, state, continue, issues, review — is English, one
+**Language:** every artifact the crew writes into `.mugiwara/` — plans, waves,
+reports, spec, state, continue, blockers, review, decisions — is English, one
 language only. The audit trail is shared by the whole team and by future
 sessions; it must not depend on the author's conversational language. A
 mission artifact in any other language is a defect, not a style choice.
 
 ```
 .mugiwara/
-├── config              → runtime mode config (gitignored; project overrides global)
-├── state/<mission>/    → computed mission state per (mission, member): state.json (solo) or <member>.json (mugiwara savepoint)
-├── continue/<mission>/ → machine-written resume point per (mission, member): state.json (solo) or <member>.json
-├── spec/               → brainstorm output: YYYY-MM-DD-<mission>.md
-├── plans/              → plan doc: YYYY-MM-DD-<mission>.md — CLEAN, Nami-only, source of truth from Flow 2
-├── results/            → per-mission folder: results/<mission>/ holds every flow-stage artifact
-│   └── <mission>/
-│       ├── 01-execution.md   → flow stage 3: task table + evidence
-│       ├── 02-audit.md       → flow stage 4: checkpoint report
-│       ├── 03-quality.md     → flow stage 5: quality report
-│       ├── 04-gates.md       → flow stage 6: gate verdict
-│       ├── 05-healing.md     → flow 8: healing report (only when heal ran)
-│       ├── 06-closure.md     → flow stage 9: closure summary (KEEP at cleanup)
-│       ├── 07-pr-verdict.md  → flow stage 9: PR material (KEEP at cleanup)
-│       └── todos.md          → execution checkbox list
-├── reports/            → mission report (aggregate): YYYY-MM-DD-<mission>.md — one-file summary of all flow stages
-├── review/             → review + security findings
-├── issues/             → blocker log: YYYY-MM-DD-<mission>-blockers.md
-└── logs/               → Luffy's decision + check-in log: YYYY-MM-DD-<mission>.md (deleted at cleanup)
+├── config                  → runtime mode config (gitignored; project overrides global)
+├── lessons.md              → cross-mission lessons ledger (memory keeper)
+├── index.md                → one line per archived mission (written by mugiwara archive/clean)
+└── missions/<mission>/     → ONE dir per mission; bare names, no date prefixes
+    ├── plan.md             → CLEAN execution plan — Nami-only, source of truth from Flow 2
+    ├── spec.md             → brainstorm output / spec bridge (consumed by planning)
+    ├── decisions.md        → Luffy's decision + check-in log (route reasons, mode flips)
+    ├── blockers.md         → blocker ledger rows
+    ├── review.md           → Robin's findings
+    ├── security.md         → Jinbe's findings
+    ├── report.md           → closure report; archive folds the flow files into it
+    ├── state.json          → computed state per (mission): solo = state.json,
+    │   │                     team = <member>.json  (gitignored)
+    │   └── continue.json   → machine resume point: solo = continue.json,
+    │                         team = continue-<member>.json  (gitignored)
+    └── flows/              → per-flow-stage artifacts, numbered by flow order
+        ├── 01-execution.md → flow stage 3: task table + evidence
+        ├── 02-audit.md     → flow stage 4: checkpoint report
+        ├── 03-quality.md   → flow stage 5: quality report
+        ├── 04-gates.md     → flow stage 6: gate verdict
+        ├── 05-healing.md   → flow stage 8: healing report (only when heal ran)
+        ├── 06-closure.md   → flow stage 9: closure summary (seeds report.md)
+        ├── 07-pr-verdict.md→ flow stage 9: PR material
+        ├── 08-verifier.md  → flow stage 4.5: skeptic findings (optional)
+        └── todos.md        → execution checkbox list
 ```
 
-Naming rule: every artifact inside `results/<mission>/` uses the SAME mission
-name, no date prefix — the folder is the grouping, numbered by flow-stage order
-(`01-`, `02-`, …). Unnumbered support files may sit alongside the numbered
-ones (`todos.md`, `resume.md`, `eval.md`, evidence logs) and are not part of
-the flow-stages table. `reports/` and `logs/` and `plans/` files carry the
-`YYYY-MM-DD-` date prefix because they are cross-mission folders; `results/`
-does not, because each mission owns its folder.
+Naming rule: bare names only. The date lives in `state.json` (`updated_at`)
+and in git history; the folder is the grouping. Lane 0/1 missions write the
+minimum: `state.json`, `flows/01-execution.md`, and `report.md` at closure —
+no plan/spec/blockers unless a blocker actually occurs (audit-lite).
 
 The plan doc stays clean: it holds ONLY the execution plan (flow stages, tasks,
 criteria, risks). Who did what, route decisions, and check-in verdicts go to
-`logs/`; the closure report goes to `results/<mission>/06-closure.md`. Nothing
-non-plan pollutes the plan doc.
+`decisions.md`; the closure summary goes to `report.md`. Nothing non-plan
+pollutes the plan doc.
 
 The owning agent creates the folder it needs on first write. No mission
 artifacts go outside `.mugiwara/`.
 
 ## Cleanup (Flow 9)
 
-Step results are evidence — KEEP every file in `results/<mission>/`
-(`01-execution.md` through `05-healing.md`, `todos.md`, `06-closure.md`,
-`07-pr-verdict.md`); they feed the mission report and closure links. Delete
-only consumed cross-artifacts: `logs/`, `spec/`, `review/`, `issues/`,
-`state/<mission>/`, `continue/<mission>/`. Keep
-`plans/`, `reports/`, `config`, `logs/lessons.md` (canonical
-lessons ledger; cross-mission state: `backup/`, `manifest.json`). List
-candidates before deleting.
+Run `mugiwara archive <mission>` (dry-run first). It folds every flow file,
+review, security, blockers, and decisions into `report.md`, then removes them
+along with session state (`*.json`). The PR material
+(`flows/07-pr-verdict.md`) survives as a standalone `pr-verdict.md` at the
+mission root — it is the handoff to the user and must not fold away. The
+mission dir ends as durable files: `plan.md` + `report.md` +
+`pr-verdict.md` (+ rollback/provenance). Batch form for several closed
+missions: `mugiwara clean [--all] [--before <date>]`.