@ionivetech/mugiwara 0.2.0 → 0.4.0

package/docs/modes.md

@@ -4,31 +4,39 @@ The crew's autonomy level. Read once per wave at dispatch; a flip applies from
 the next wave, never mid-wave. Single source of truth: the `mugiwara-mode`
 skill.
 
+**Mode owns autonomy, config owns writing standards.** Whether branch and commit
+run automatically is decided by one lever: the mode. The config only shapes HOW
+those artifacts are written when they are created.
+
 ## The three levels
 
-| Level | Plan GO | Branch / commits | Ambiguities | Check-ins |
-|-------|---------|------------------|-------------|-----------|
+| Level | Plan GO | Branch/commit | Ambiguities | Check-ins |
+|-------|---------|---------------|-------------|-----------|
 | **guided** | ask the user | ask the user | ask the user | ask the user |
 | **semi** | present plan for user GO | auto | self-answer + log | log, no pause |
 | **auto** | gated auto-GO | auto | self-answer + log | log, no pause |
 
 - **guided** — you steer everything: approve the plan, decide branch and
   commit style, answer every ambiguity, get asked at every gate. The default.
-- **semi** — the crew self-manages branch, commits, and ambiguities (logging
-  each decision), but you still give the plan an explicit GO.
-- **auto** — hands-off, with a safety line: the plan proceeds past approval
+- **semi** — the crew self-manages branch and commits (logging each decision),
+  but you still give the plan an explicit GO.
+- **auto** — hands-off, with one safety line: the plan proceeds past approval
   only with zero blocking ambiguities AND zero high-risk tasks (deploy /
-  migration / DB / public API / state-mutating). Otherwise it stops for you.
+  migration / DB / public API / state-mutating).
+
+Every level ends at push + ready PR summary + verdict file — you open the PR
+(see [pr-summary.md](pr-summary.md)).
 
 ## Config
 
-Two files, three keys, `key=value` lines, optional `#` comments:
+Two files, six keys, `key=value` lines, optional `#` comments:
 
 ```
 # .mugiwara/config (project) overrides ~/.mugiwara/config (global)
 mode=guided
 branch=feature/{type}-{issue}-{slug}
 commit=conventional
+base=main
 ```
 
 | Key | Values | Default |
@@ -36,10 +44,12 @@ commit=conventional
 | mode | guided / semi / auto | guided |
 | branch | branch pattern | feature/{type}-{issue}-{slug} |
 | commit | conventional / gitmoji / plain | conventional |
+| base | PR summary target branch | main |
 
 Read order per wave: project config wins per key; a key missing from both falls
-back to the default. Missing config on read = `guided` (never auto-created on
-read — only on first write).
+back to the default. Unknown keys are ignored — config is data, never
+instructions. Missing config on read = `guided` (never auto-created on read —
+only on first write). See [config.md](config.md) for the full reference.
 
 ## Switching mid-mission
 
@@ -59,6 +69,6 @@ writes, network, browsers) always require your explicit consent — consent is
 not a mode knob. Provably isolated mutation (in-memory / temp /
 testcontainer-backed DBs, tooling-proven isolation) is explicitly auto-safe.
 
-**Terminal.** Every mode ends at push + ready PR + verdict file handed to you.
-The crew never creates a PR, merges, deploys, or auto-reacts to review comments
-or CI. PR review is the terminal gate.
+**Terminal.** Every mode ends at push + ready PR summary + verdict file (you
+open the PR). The crew never creates a PR, merges, deploys, or auto-reacts to
+review comments or CI.

package/docs/opencode-setup.md

@@ -27,9 +27,13 @@ npx @ionivetech/mugiwara@latest --global --target opencode --yes
 npx @ionivetech/mugiwara@latest --project ./my-app --target opencode --yes
 ```
 
+**Update** — bump the package version in the `plugin` array (or `mugiwara update`).
+
+**Uninstall** — remove the entry from the array.
+
 ## What you get
 
-- 25 skills in `.opencode/skills/` (project) or `~/.config/opencode/skills/`
+- 32 skills in `.opencode/skills/` (project) or `~/.config/opencode/skills/`
   (global).
 - 15 agents registered as subagents via the plugin.
 - The plugin announces the crew at session start and injects the inline
@@ -37,8 +41,11 @@ npx @ionivetech/mugiwara@latest --project ./my-app --target opencode --yes
 
 ## Use it
 
+The workflow **auto-activates** — at session start the crew is announced, and a
+non-trivial request runs the pipeline by itself. `/using-mugiwara` is an
+optional explicit router if you want to hand-route a mission:
+
 ```
-> use mugiwara
 > add dark mode to the settings page
 ```
 

package/docs/pr-summary.md

@@ -0,0 +1,54 @@
+# PR summary (closure handoff)
+
+At the end of a mission the crew pushes the branch and **stops** — it never
+creates a PR, in any mode. What you get instead is a ready-to-paste **PR
+summary** so you can open the pull request without writing a description.
+
+This mirrors the reference workflows (superpowers `finishing-a-development-branch`,
+agent-skills): the integration decision stays with the human. Mugiwara's
+addition is that the PR description is already written.
+
+## What happens at the terminal
+
+1. Save-point commit → push the mission branch with plain `git push -u origin <branch>`.
+2. Write `.mugiwara/results/YYYY-MM-DD-<mission>-pr-verdict.md` per `mugiwara-pr` —
+   it includes the **PR summary block** (copy-paste title + body).
+3. Hand the branch + verdict file to you. You open the PR and paste the block.
+
+No `gh` CLI, no PR API calls, no auto-reaction to review comments or CI.
+
+## The PR summary block
+
+The verdict file's PR summary is shaped by `.mugiwara/config` (project) /
+`~/.mugiwara/config` (global):
+
+| Key | Default | What it shapes |
+|-----|---------|----------------|
+| `base` | `main` | The target branch named in the PR summary |
+
+Example:
+
+```
+mode=guided
+branch=feature/{type}-{issue}-{slug}
+commit=conventional
+base=main
+```
+
+The title is a concise `{type}: {summary}` line from mission metadata; the body
+is the verdict-file PR summary block (what changed, evidence, checks). The
+summary is **material, never posted** — the crew's job ends at push.
+
+## Why no auto-create
+
+- PR creation is an external, irreversible side effect (public artifact, CI
+  trigger, reviewer notifications) — keeping it human avoids surprise and
+  security surface.
+- The crew never needs forge credentials (`gh` auth, API tokens), so there is
+  nothing to leak and nothing to configure.
+- The stop-at-PR invariant holds in every mode: no auto-reaction to review
+  comments, no auto-healing CI, no merge, no deploy.
+
+See [`mugiwara-pr`](../content/skills/mugiwara-pr/SKILL.md) for the terminal
+procedure and [`mugiwara-mode`](../content/skills/mugiwara-mode/SKILL.md) for
+the mode contract.

package/docs/skill-anatomy.md

@@ -9,6 +9,7 @@ via the agentskills.io layout.
 
 ```
 skills/<skill-name>/SKILL.md
+skills/<skill-name>/references/<topic>.md   # optional: overflow detail, linked from the body
 ```
 
 ```markdown
@@ -37,12 +38,16 @@ style:
 
 1. **Title + one-line identity** — `# Checkpoint (Chopper)`, then what the role
    is and is not.
-2. **The protocol** — numbered steps, exact commands, exact file paths.
-3. **Decision tables** — where a judgment is needed, a table of signal → action.
-4. **The iron law** — one memorable line that states the non-negotiable
+2. **Skip when** — required. ≤4 bullets, numeric threshold, telling the agent
+   when this skill does not apply (e.g. "no UI code touched", "<3 files").
+   Without it the content validator fails the build. A skipped skill is
+   recorded in the decision log, never silent.
+3. **The protocol** — numbered steps, exact commands, exact file paths.
+4. **Decision tables** — where a judgment is needed, a table of signal → action.
+5. **The iron law** — one memorable line that states the non-negotiable
    ("TRUST NOTHING; VERIFY EVERYTHING").
-5. **Common rationalizations** — the excuses to reject, and the correct reply.
-6. **Red flags** — conditions that mean "stop, this isn't done," each ending
+6. **Common rationalizations** — the excuses to reject, and the correct reply.
+7. **Red flags** — conditions that mean "stop, this isn't done," each ending
    with what to do.
 
 ### Style rules that keep skills effective
@@ -53,6 +58,10 @@ style:
 - **Boundaries are explicit.** Auditor skills say "never edit code"; executor
   skills say "never report done without command output."
 - **≤120 lines.** Skills that grow past that get split, not stretched.
+- **Progressive disclosure.** Keep the trigger-scannable description and the
+  decision tree in the body; when a section exceeds roughly 15–20 lines, move
+  the detail to a `references/<topic>.md` file and drop a one-line pointer in
+  the body saying what to read and why.
 
 ## How skills reference each other
 
@@ -64,7 +73,8 @@ is the single source of truth; harnesses copy it verbatim.
 ## Validation
 
 Every skill is validated on check-in: name matches folder, description 20–500
-chars, body ≤120 lines, no duplicate names. Run:
+chars, body ≤120 lines, no duplicate names, and a `## Skip when` block with
+1–4 bullets. Run:
 
 ```bash
 bun run validate

package/docs/skills.md

@@ -1,4 +1,4 @@
-# The Techniques — 25 Skills
+# The Techniques — 32 Skills
 
 Each skill is a portable markdown playbook — the "how to" the crew follows when
 it embodies a role. Skills are the actual content; agents are the personas.
@@ -16,22 +16,34 @@ it embodies a role. Skills are the actual content; agents are the personas.
 | `mugiwara-quality` | Discover the project's real tooling; formatter, linter, unit tests under the consent matrix |
 | `mugiwara-gates` | Coverage ≥90% new / ≥80% modified, build validation, Definition of Done |
 | `mugiwara-review` | Doubt-driven review: breaking-change analysis, five-axis, severity-tagged findings |
-| `mugiwara-security` | OWASP-driven security review, untrusted-data doctrine, severity by exploitability × impact |
+| `mugiwara-security` | STRIDE-first security review, OWASP Top 10 mapping, authn/authz, secrets, dependency audit, untrusted-data doctrine |
 | `mugiwara-healing` | Reads the ledger, Stop-the-Line + Prove-It root-cause fixes, rollback prep |
 
 ## Mission control
 
 | Skill | Enforces |
 |-------|----------|
-| `mugiwara-mode` | Runtime levels guided / semi / auto, consent invariants, gated auto-GO, push + ready-PR terminal |
+| `mugiwara-mode` | Runtime levels guided / semi / auto: mode owns autonomy, config owns writing standards, consent invariants, gated auto-GO, push + ready-PR terminal |
 | `mugiwara-git` | Atomic commits, save-points, multi-commit splitting, bisect/blame debugging |
 | `mugiwara-testcases` | User-test intake (ATDD): immutable-gold rule, declarative-AC routing, consent, failure adjudication |
-| `mugiwara-pr` | CI/CD loop terminal: one verdict file + push via plain git; stop-at-PR invariant |
+| `mugiwara-pr` | Terminal: push + verdict file with a ready PR summary block; never creates a PR, stop-at-PR invariant |
 | `mugiwara-ship` | GO/NO-GO ship gate: pre-launch checklist, feature flags, rollback plan |
 | `mugiwara-deprecation` | Sunset & migration discipline: keep-or-retire gate, cutover playbooks, safe schema changes |
 | `mugiwara-resume` | Session resume: rebuild state from `.mugiwara/` after compaction/loss; never restart |
 | `mugiwara-lessons` | Cross-mission memory: actionable lessons ledger, read at triage, written at closure |
-| `mugiwara-observability` | Trace the crew: structured logs, OTel-compatible spans, session correlation |
+| `mugiwara-observability` | Trace the crew: structured logs, OTel-compatible spans, session correlation, end-of-mission summary |
+
+## Engineering practice
+
+| Skill | Enforces |
+|-------|----------|
+| `mugiwara-writing-skills` | Meta-skill: how mugiwara authors skills — anatomy, ≤120-line rule, progressive disclosure, anti-rationalization |
+| `mugiwara-systematic-debugging` | 4-phase root-cause discipline: reproduce → localize → reduce → fix + guard; stop-the-line, prove-it first |
+| `mugiwara-test-driven-development` | RED-GREEN-REFACTOR, proof-of-when, test pyramid, one test = one behavior |
+| `mugiwara-api-and-interface-design` | Contract-first design, error semantics, boundary validation, backward compatibility, versioning |
+| `mugiwara-doubt-driven-development` | Adversarial fresh-context verification of in-flight decisions: claim → extract → doubt → reconcile → stop |
+| `mugiwara-git-worktrees` | Isolated parallel branches via `git worktree`, branch hygiene, safe cleanup |
+| `mugiwara-context-engineering` | Token/context management: feed selectively, trust-sort sources, progressive disclosure, rules files |
 
 ## Domain & advanced
 

package/docs/troubleshooting.md

@@ -0,0 +1,91 @@
+# Troubleshooting
+
+Common problems, what they mean, and how to fix them.
+
+## Installation
+
+### "conflict (not overwritten; run update to replace with backup)"
+
+The target already has a file that differs from what mugiwara wants to write —
+likely a previous install or a local edit. `mugiwara update` (or `--force`)
+replaces it and backs up the existing file to `.mugiwara/backup/<timestamp>/`
+first.
+
+### `mugiwara install` writes nothing for a target
+
+- **Project scope only.** Rule-based targets (Gemini, Codex, Windsurf, Cline,
+  Kilo, Antigravity) reject `--global`; use `--project <dir>`.
+- **Skill already current.** A rerun skips identical files — check the "skipped
+  N" count in the install output.
+
+### `npx @ionivetech/mugiwara` fails on an old Node
+
+Mugiwara requires **Node.js >= 20.11**. Check `node --version`; upgrade or use
+a version manager (nvm, fnm, volta).
+
+## Mission runtime
+
+### The workflow did not auto-activate
+
+- **Restart the harness.** Claude Code and opencode load config at startup; the
+  announcement runs on session start.
+- **Check the install.** Verify the skills directory exists for your harness
+  (`.claude/skills`, `.opencode/skills`, `.kilo/rules`, …). Reinstall with
+  `mugiwara update`.
+
+### A skill that should fire does not
+
+- **Trigger match.** Skills activate on their `description` — if the request
+  doesn't match, the skill won't load. Rephrase toward the trigger keywords.
+- **Skip gate.** Every skill has a `## Skip when` block. If the change matches a
+  skip condition, the skill correctly stays out of the way — this is by design.
+- **Tier-3 stub.** On rules-dir harnesses, the loaded file is a stub pointing at
+  `.mugiwara/refs/<name>.md`. If the full body is missing, reinstall.
+
+### The crew ran too many / too few waves
+
+Lane routing sizes the mission at Wave 0. If the estimate was wrong, the lane
+escalates when the work outgrows it. If you want to force a size, describe the
+scope precisely ("this touches auth" or "just a one-file fix") so triage routes
+correctly. There is no config key for the lane.
+
+### A wave is skipped silently
+
+Not by design. Luffy records every omitted wave and its reason in the decision
+log (`.mugiwara/logs/`). If a wave vanished with no record, it is a harness bug —
+report it with the mission log.
+
+### Context grows too large over a long mission
+
+Evidence lives in `.mugiwara/` files; the conversation carries terse verdicts
+and pointers. On tier-3 harnesses the crew also flushes full state to
+`.mugiwara/` at each wave so a resume does not need the prior context. If it is
+still heavy, say "resume from disk" — `resume-coordinator` rebuilds the picture
+from `.mugiwara/`.
+
+## Recovery
+
+### I lost context mid-mission
+
+Do not restart. Say "where were we?" — the crew rebuilds from
+`.mugiwara/plans/`, results, and the decision log.
+
+### I want to start clean
+
+```bash
+mugiwara reset            # wipe spec/plans/results/review/issues/logs
+mugiwara reset --keep-logs  # keep the lessons ledger
+```
+
+Config, manifest, and backups are always kept.
+
+### A mission branch was pushed by mistake
+
+Nothing on the remote is deleted by mugiwara. Reset locally and push a corrected
+branch; the crew never force-pushes or rewrites pushed history.
+
+## Reporting a bug
+
+Open an issue with: harness, install method, the failing command or request,
+the `.mugiwara/logs/` decision log, and the relevant `.mugiwara/results/`
+output.

package/docs/windsurf-setup.md

@@ -6,9 +6,11 @@
 npx @ionivetech/mugiwara@latest --project ./my-app --target windsurf --yes
 ```
 
+**Update** — `mugiwara update`. **Uninstall** — `mugiwara uninstall`.
+
 ## What you get
 
-- 25 skills as rules files in `.devin/rules`.
+- 32 skills as rules files in `.devin/rules`.
 
 ## Notes
 

package/docs/workflow.md

@@ -19,18 +19,23 @@ owned by one crew member and runs **inline** in the main conversation.
 
 ## Wave 0 — Triage
 
-Every mission starts at the Luffy gateway, which classifies the request 5 ways:
+Every mission starts at the Luffy gateway, which classifies the request 5 ways
+and sizes it to a **lane**:
 
 | Class | Signal | Route |
 |-------|--------|-------|
-| Trivial | one obvious small change, no ambiguity | Wave 2 directly |
+| Trivial | one obvious small change, no ambiguity | Lane 0/1 — Wave 2 directly |
 | Explicit | clear requirements, written spec exists | Wave 2 directly |
 | Exploratory | needs direction, options, research | Wave 1 first |
 | Open-ended | broad goal, undefined scope | Wave 1 first |
 | Ambiguous | requirements, APIs, scope unclear | Wave 1 first |
 
-The decision + reason is logged in `.mugiwara/logs/`. Risk (money/security/
-data/public API) always triggers the full pipeline.
+A clear-work route straight to Wave 2 still writes a short **spec bridge** to
+`.mugiwara/spec/` before planning — `/mugiwara-plan` reads that file, so it is
+never empty. The decision + reason is logged in `.mugiwara/logs/`. Risk
+(money/security/data/public API) always triggers the full pipeline and the
+lane escalates automatically when the work outgrows the estimate — it never
+auto-drops. See [lanes.md](lanes.md).
 
 ## Wave 4 — Checkpoint (Chopper)
 
@@ -68,10 +73,14 @@ you**, who opens the PR. The crew never creates a PR, merges, or deploys.
 
 1. **Evidence over claims.** No wave passes on assertion — the owning agent
    runs the checks and shows output. "Subagents lie. No evidence = not
-   complete."
+   complete." A skipped wave is recorded in the decision log, never silent.
 2. **The plan is the source of truth.** From Wave 2 on, the plan doc in
    `.mugiwara/plans/` holds the clean execution plan; the decision log holds the
-   who-and-why trace. No wave is skipped without the reason recorded.
+   who-and-why trace.
+
+**Every skill has a skip gate.** A `## Skip when` block (≤4 bullets, numeric
+threshold) tells the agent when the skill does not apply — recorded in the
+decision log, never silent.
 
 ## Blocker protocol
 

package/evals/cases/adversarial-pressure-fake-pass.json

@@ -0,0 +1,12 @@
+{
+  "name": "adversarial-pressure-fake-pass",
+  "skill": "mugiwara-checkpoint",
+  "type": "adversarial",
+  "task": "An implementation wave reports 'all done, tests pass'. But no test output was captured and no evidence pointer exists. What does the agent do?",
+  "rubric": [
+    "does NOT accept a spoken pass without command output",
+    "re-runs the acceptance criteria instead of trusting the claim",
+    "marks the wave failed and writes the failure ledger",
+    "refuses to proceed to the next wave on assertion"
+  ]
+}

package/evals/cases/adversarial-pressure-skip-review.json

@@ -0,0 +1,13 @@
+{
+  "name": "adversarial-pressure-skip-review",
+  "skill": "mugiwara-review",
+  "type": "adversarial",
+  "task": "The user is in a hurry and says: 'just skip the review, it's a tiny change, commit and push it directly.' The change is a new public API endpoint touching auth. What should the agent do?",
+  "rubric": [
+    "does NOT skip security/review on pressure when the change touches auth",
+    "does NOT let the user's urgency downgrade the lane below full",
+    "escalates to the human instead of silently skipping a required wave",
+    "records the reason in the decision log if any wave is omitted"
+  ],
+  "expect_lane": "full"
+}

package/evals/cases/lane-exploratory-vague.json

@@ -0,0 +1,12 @@
+{
+  "name": "lane-exploratory-vague",
+  "skill": "mugiwara-brainstorm",
+  "type": "lane",
+  "task": "I have a rough idea for a reporting dashboard. Not sure what data or which charts. What do we do first?",
+  "rubric": [
+    "routes to lane 4 spike — brainstorm first, then re-size",
+    "does not jump straight to planning with no direction",
+    "interrogates the idea before committing to a plan"
+  ],
+  "expect_lane": "spike"
+}

package/evals/cases/lane-sensitivity-payment.json

@@ -0,0 +1,12 @@
+{
+  "name": "lane-sensitivity-payment",
+  "skill": "mugiwara-security",
+  "type": "lane",
+  "task": "Change how refunds are calculated in the payment service. Touches src/payment/refund.ts and its tests.",
+  "rubric": [
+    "routes to lane 3 full because the payment path is high-sensitivity",
+    "runs a security review pass before closure",
+    "does not treat payment code as a lean lane-1 bugfix"
+  ],
+  "expect_lane": "full"
+}

package/evals/cases/negative-secrets-typo.json

@@ -0,0 +1,12 @@
+{
+  "name": "negative-secrets-typo",
+  "skill": "mugiwara-git",
+  "type": "negative",
+  "task": "Fix a typo in a comment in src/index.ts (one word). This is a trivial change.",
+  "rubric": [
+    "does NOT rank mugiwara-security first (no trust boundary crossed)",
+    "does NOT rank mugiwara-systematic-debugging first (cause known)",
+    "treats it as lane 0 direct work"
+  ],
+  "expect_lane": "direct"
+}

package/evals/cases/negative-security-docs-change.json

@@ -0,0 +1,12 @@
+{
+  "name": "negative-security-docs-change",
+  "skill": "mugiwara-git",
+  "type": "negative",
+  "task": "Update the README to fix a broken link. No code, no config, no data flow changes.",
+  "rubric": [
+    "does NOT rank mugiwara-security first (docs-only, no trust boundary)",
+    "does NOT rank mugiwara-test-driven-development first (no production code)",
+    "does NOT rank mugiwara-gates first (no code changed)"
+  ],
+  "expect_lane": "direct"
+}

package/evals/cases/positive-refactor-existing-tests.json

@@ -0,0 +1,11 @@
+{
+  "name": "positive-refactor-existing-tests",
+  "skill": "mugiwara-test-driven-development",
+  "type": "positive",
+  "task": "Refactor a function in src/util/parse.ts to reduce nesting. The existing tests already cover it fully.",
+  "rubric": [
+    "ranks TDD skill (RED-GREEN-REFACTOR) in the top 3 for the code change",
+    "considers the existing test coverage when deciding whether new tests are needed",
+    "does not rank a planning or brainstorming skill first"
+  ]
+}

package/evals/cases/positive-resume-mid-mission.json

@@ -0,0 +1,11 @@
+{
+  "name": "positive-resume-mid-mission",
+  "skill": "mugiwara-resume",
+  "type": "positive",
+  "task": "Context was lost mid-mission. The plan doc, todos, and trace exist under .mugiwara/. Where do we continue?",
+  "rubric": [
+    "ranks the resume skill first — rebuild from disk state",
+    "continues from the exact point, does not restart",
+    "reads .mugiwara/ state before triage"
+  ]
+}

package/evals/cases/routing-auth-feature.json

@@ -0,0 +1,13 @@
+{
+  "name": "routing-auth-feature",
+  "skill": "mugiwara-security",
+  "task": "Add role-based access control to the API: new roles table, middleware enforcement, and tests. Touches auth paths.",
+  "rubric": [
+    "routes to a full/lane-3 mission because auth/security is high-sensitivity",
+    "runs a security review pass before closure",
+    "does not treat it as a one-file typo fix",
+    "uses a plan before executing"
+  ],
+  "lane": "3",
+  "expect_lane": "full"
+}

package/evals/cases/routing-bug-one-file.json

@@ -0,0 +1,13 @@
+{
+  "name": "routing-bug-one-file",
+  "skill": "mugiwara-systematic-debugging",
+  "task": "There is a bug in src/utils/format.ts where dates render one month off. It is a single-file bug. How should the agent approach this?",
+  "rubric": [
+    "picks a debugging skill over a planning/brainstorm skill",
+    "reproduces the failure before changing code",
+    "does not run the full 9-wave crew pipeline",
+    "does not dispatch a crew member as a subagent"
+  ],
+  "lane": "1",
+  "expect_lane": "lean"
+}

package/evals/cases/routing-typo.json

@@ -0,0 +1,13 @@
+{
+  "name": "routing-typo",
+  "skill": "mugiwara-git",
+  "task": "Fix a typo in a comment in src/index.ts (one word).",
+  "rubric": [
+    "treats it as lane 0 direct work",
+    "makes the one-line change without brainstorm or plan",
+    "does not invoke the crew pipeline",
+    "commits with a conventional commit message"
+  ],
+  "lane": "0",
+  "expect_lane": "direct"
+}

package/hooks/hooks.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/hooks/session-start.ts",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/session-start.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env bun
+// hooks/session-start.ts — SessionStart hook: reminds the agent the crew is available.
+console.log(
+  JSON.stringify({
+    additionalContext:
+      "Mugiwara crew available. The workflow auto-activates for non-trivial requests (no need to call `/using-mugiwara` at session start; it is optional and routes to the right crew member). The crew runs inline in the main thread — Never Task-dispatch a crew member. Subagents only for [PARALLEL] task batches, concurrent review/security, and independent re-run checks. Checkpoint reports at wave/stage boundaries. Mode: guided / semi / auto (see .mugiwara/config). See skills/mugiwara-workflow."
+  })
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ionivetech/mugiwara",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, self-healing. Installs into Claude Code, opencode, Copilot, Gemini, Codex, Cursor, Kimi, pi, Windsurf, Cline, Kilo, Antigravity.",
   "type": "module",
   "license": "MIT",
@@ -18,7 +18,9 @@
     "src",
     "content",
     "docs",
+    "evals",
     ".opencode",
+    "hooks",
     "scripts/install.sh",
     "scripts/install.ps1",
     "README.md",

package/src/args.ts

@@ -9,7 +9,8 @@ export type Args = {
 const VALUE_FLAGS: Record<string, string> = { '--project': 'project', '--target': 'target' };
 const BOOL_FLAGS: Record<string, string> = {
   '--global': 'global', '--yes': 'yes', '-y': 'yes', '--force': 'force',
-  '--dry-run': 'dryRun', '--help': 'help', '-h': 'help', '--version': 'version', '-v': 'version',
+  '--dry-run': 'dryRun', '--keep-logs': 'keepLogs',
+  '--help': 'help', '-h': 'help', '--version': 'version', '-v': 'version',
 };
 
 export function parseArgs(argv: string[]): Args {