@ionivetech/mugiwara 0.5.4 → 0.6.0

package/scripts/mission-report.sh

@@ -1,88 +1,153 @@
 #!/usr/bin/env bash
-# scripts/mission-report.sh — generate human-readable mission report from state.json
-# Usage: mission-report.sh <mission>
+# scripts/mission-report.sh — generate aggregate mission report from state.json
+# + per-mission wave artifacts. Usage: mission-report.sh <mission>
+# Output: .mugiwara/reports/YYYY-MM-DD-<mission>.md — one-file summary of all waves.
 set -u
 
 MISSION="${1:-}"
 [ -z "$MISSION" ] && { echo "usage: mission-report.sh <mission>" >&2; exit 1; }
+case "$MISSION" in
+  *[!a-zA-Z0-9._-]*) echo "mission-report: invalid mission name \"$MISSION\" (allowlist: [a-zA-Z0-9._-])" >&2; exit 1 ;;
+esac
 
 MUGIWARA_DIR="${MUGIWARA_DIR:-.mugiwara}"
 STATE_FILE="$MUGIWARA_DIR/state.json"
 REPORT_DIR="$MUGIWARA_DIR/reports"
-REPORT_FILE="$REPORT_DIR/${MISSION}.md"
+RESULTS_DIR="$MUGIWARA_DIR/results/$MISSION"
+REVIEW_DIR="$MUGIWARA_DIR/review"
+ISSUES_DIR="$MUGIWARA_DIR/issues"
 
 [ -f "$STATE_FILE" ] || { echo "mission-report: $STATE_FILE not found" >&2; exit 1; }
 
-python3 <<PY
-import json, os, sys
-from datetime import datetime
-
-state_file = "$STATE_FILE"
-report_file = "$REPORT_FILE"
-os.makedirs(os.path.dirname(report_file), exist_ok=True)
-
-with open(state_file) as f:
-    s = json.load(f)
-
-mission = s.get("mission", "$MISSION")
-actor = s.get("actor", "unknown")
-branch = s.get("branch", "unknown")
-lane = s.get("lane", "unknown")
-lane_reason = s.get("lane_reason", "")
-mode = s.get("mode", "guided")
-wave = s.get("wave", 0)
-files_touched = s.get("files_touched", 0)
-loc_delta = s.get("loc_delta", 0)
-sensitive = s.get("sensitive_paths", [])
-tasks = s.get("tasks", {})
-blockers = s.get("blockers_open", 0)
-heal_cycle = s.get("heal_cycle", 1)
-tokens = s.get("tokens_est", 0)
-budget = s.get("budget", 0)
-evidence = s.get("evidence", [])
-updated = s.get("updated_at", datetime.utcnow().isoformat() + "Z")
-
-now = datetime.utcnow().strftime("%Y-%m-%d")
-report = f"""# Mission: {mission} · {now}
-
-**Lane** {lane} · **Mode** {mode} · **Actor** {actor} · **Branch** {branch}
-
-## What changed
-
-{files_touched} files, +{loc_delta if loc_delta >= 0 else loc_delta} LOC"""
-
-if sensitive:
-    report += "\nSensitive paths: " + ", ".join(sensitive)
-
-report += f"""
-
-## Gates
-
-| Gate | Verdict | Evidence |
-|------|---------|----------|"""
-
-for e in evidence:
-    report += f"\n| — | PASS | {e} |"
-
-report += f"""
-
-## State
-
-| Field | Value |
-|-------|-------|
-| Wave | {wave} |
-| Tasks | {tasks.get('done', 0)}/{tasks.get('total', 0)} done |
-| Blockers open | {blockers} |
-| Heal cycles | {heal_cycle} |
-| Tokens used | {tokens:,} / {budget:,} |
-
-## Updated
-
-{updated}
-"""
-
-with open(report_file, 'w') as f:
-    f.write(report)
-
-print(f"✓ mission report: {report_file}")
-PY
+export STATE_FILE REPORT_DIR RESULTS_DIR REVIEW_DIR ISSUES_DIR MISSION
+node << 'NODE'
+const fs = require('fs');
+const path = require('path');
+
+const stateFile = process.env.STATE_FILE || ".mugiwara/state.json";
+const reportDir = process.env.REPORT_DIR || ".mugiwara/reports";
+const resultsDir = process.env.RESULTS_DIR || ".mugiwara/results/unknown";
+const reviewDir = process.env.REVIEW_DIR || ".mugiwara/review";
+const issuesDir = process.env.ISSUES_DIR || ".mugiwara/issues";
+const mission = process.env.MISSION || "unknown";
+
+if (!fs.existsSync(stateFile)) {
+  console.error("mission-report: " + stateFile + " not found");
+  process.exit(1);
+}
+
+fs.mkdirSync(reportDir, { recursive: true });
+const s = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+
+const now = new Date().toISOString().slice(0, 10);
+const reportFile = path.join(reportDir, now + "-" + mission + ".md");
+const lane = s.lane || "unknown";
+const mode = s.mode || "guided";
+const actor = s.actor || "unknown";
+const branch = s.branch || "unknown";
+const wave = s.wave || 0;
+const filesTouched = s.files_touched || 0;
+const locDelta = s.loc_delta || 0;
+const sensitive = s.sensitive_paths || [];
+const tasks = s.tasks || {};
+const blockers = s.blockers_open || 0;
+const healCycle = s.heal_cycle || 1;
+const tokens = s.tokens_est || 0;
+const budget = s.budget || 0;
+const evidence = s.evidence || [];
+const updated = s.updated_at || new Date().toISOString();
+
+// --- wave artifact scan: results/<mission>/NN-*.md with verdict sniffing ---
+const WAVE_LABEL = {
+  "01-execution": "Execute (Wave 3)",
+  "02-audit": "Checkpoint (Wave 4)",
+  "03-quality": "Quality (Wave 5)",
+  "04-gates": "Gates (Wave 6)",
+  "05-healing": "Healing (Wave 8)",
+  "06-closure": "Closure (Wave 9)",
+  "07-pr-verdict": "PR material",
+};
+
+const WAVE_FILES = new Set(Object.keys(WAVE_LABEL));
+
+function sniffVerdict(file) {
+  const text = fs.readFileSync(file, 'utf8');
+  const lines = text.split(/\r?\n/).filter(l => /pass|fail|✅|❌|verdict|go|no-go/i.test(l));
+  for (const l of lines) {
+    const m = l.match(/(NO-GO|GO|PASS|FAIL|✅|❌)/i);
+    if (m) return m[1].toUpperCase();
+  }
+  return "?";
+}
+
+const waveRows = [];
+if (fs.existsSync(resultsDir)) {
+  const files = fs.readdirSync(resultsDir).filter(f => f.endsWith('.md')).sort();
+  for (const f of files) {
+    const base = f.replace(/\.md$/, '');
+    if (!WAVE_FILES.has(base)) continue; // support files (todos.md, resume.md, eval.md, evidence logs) not in waves table
+    const label = WAVE_LABEL[base];
+    const verdict = sniffVerdict(path.join(resultsDir, f));
+    waveRows.push({ label, file: f, verdict });
+  }
+}
+
+// --- review + issues scan: aggregate findings count + open blockers ---
+let reviewFiles = [];
+let reviewFindings = 0;
+if (fs.existsSync(reviewDir)) {
+  reviewFiles = fs.readdirSync(reviewDir).filter(f => (f.startsWith(mission + "-") || f.startsWith(mission + "/")) && f.endsWith('.md'));
+  for (const f of reviewFiles) {
+    const text = fs.readFileSync(path.join(reviewDir, f), 'utf8');
+    reviewFindings += (text.match(/^\s*(?:#+\s*)?(?:🔴|🟠|🟡|⚪)(?:\s*\/\s*(?:🔴|🟠|🟡|⚪))?\s+.*/gm) || []).length;
+  }
+}
+
+let issueRows = [];
+if (fs.existsSync(issuesDir)) {
+  const issueFiles = fs.readdirSync(issuesDir).filter(f => (f.startsWith(mission + "-") || f.startsWith(mission + "/")) && f.endsWith('.md'));
+  for (const f of issueFiles) {
+    const text = fs.readFileSync(path.join(issuesDir, f), 'utf8');
+    for (const line of text.split(/\r?\n/)) {
+      if (line.trim().startsWith('|') && line.includes('|') && !line.includes('---')) {
+        const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+        if (cells.length >= 5 && !/^wave$/i.test(cells[0])) issueRows.push(cells.join(" | "));
+      }
+    }
+  }
+}
+
+let report = "# Mission: " + mission + " . " + now + "\n\n";
+report += "**Lane** " + lane + " . **Mode** " + mode + " . **Actor** " + actor + " . **Branch** " + branch + "\n\n";
+
+report += "## What changed\n\n";
+report += filesTouched + " files, +" + locDelta + " LOC";
+if (sensitive.length) report += "\nSensitive paths: " + sensitive.join(", ");
+
+report += "\n\n## Waves\n\n| Wave | Artifact | Verdict |\n|------|----------|---------|";
+if (waveRows.length) {
+  for (const r of waveRows) report += "\n| " + r.label + " | `" + r.file + "` | " + r.verdict + " |";
+} else {
+  report += "\n| (no wave artifacts found in `" + resultsDir + "`) | | |";
+}
+
+report += "\n\n## Review & blockers\n\n";
+report += "Review + security files: " + (reviewFiles.length ? reviewFiles.join(", ") : "none") + "\n";
+report += "Findings: " + reviewFindings + "\n";
+report += "Blocker ledger rows: " + issueRows.length + (issueRows.length ? "\n" + issueRows.map(r => "- " + r).join("\n") : "");
+
+report += "\n\n## State\n\n| Field | Value |\n|-------|-------|\n";
+report += "| Wave | " + wave + " |\n";
+report += "| Tasks | " + (tasks.done || 0) + "/" + (tasks.total || 0) + " done |\n";
+report += "| Blockers open | " + blockers + " |\n";
+report += "| Heal cycles | " + healCycle + " |\n";
+report += "| Tokens used | " + tokens.toLocaleString() + " / " + budget.toLocaleString() + " |\n\n";
+
+report += "## Evidence\n\n";
+for (const e of evidence) report += "- " + e + "\n";
+
+report += "\n## Updated\n\n" + updated + "\n";
+
+fs.writeFileSync(reportFile, report);
+console.log("\u2713 mission report: " + reportFile);
+NODE

package/scripts/onboard.ts

@@ -0,0 +1,292 @@
+#!/usr/bin/env bun
+// scripts/onboard.ts — Mugiwara onboarding wizard (10 fixed questions, no network)
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+
+const root = join(import.meta.dirname, "..");
+const mugiwaraDir = join(root, ".mugiwara");
+const configPath = join(mugiwaraDir, "config");
+const onboardPath = join(mugiwaraDir, "onboard.json");
+
+function ask(rl: import("node:readline").Interface, prompt: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => resolve(answer.trim()));
+  });
+}
+
+async function confirm(rl: import("node:readline").Interface, prompt: string): Promise<boolean> {
+  const a = await ask(rl, prompt);
+  return a.toLowerCase() === "y" || a.toLowerCase() === "yes";
+}
+
+async function pick(
+  rl: import("node:readline").Interface,
+  prompt: string,
+  options: string[],
+): Promise<number> {
+  while (true) {
+    const a = await ask(rl, prompt);
+    const n = Number.parseInt(a, 10);
+    if (!Number.isNaN(n) && n >= 1 && n <= options.length) return n;
+    console.log(`  Enter a number 1–${options.length}`);
+  }
+}
+
+async function main() {
+  // --help / no-tty guard
+  if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    console.log("Usage: bun scripts/onboard.ts");
+    console.log("Runs the Mugiwara onboarding wizard (10 fixed questions).");
+    console.log("Writes .mugiwara/config and .mugiwara/onboard.json.");
+    process.exit(0);
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    console.log("");
+    console.log("╔══════════════════════════════════════╗");
+    console.log("║   Mugiwara Onboarding Wizard         ║");
+    console.log("╚══════════════════════════════════════╝");
+    console.log("");
+
+    // Check for existing config
+    if (existsSync(configPath)) {
+      const redo = await confirm(
+        rl,
+        "Existing .mugiwara/config found. Re-onboard? (y/n): ",
+      );
+      if (!redo) {
+        console.log("Onboarding cancelled. Config preserved.");
+        process.exit(0);
+      }
+      console.log("");
+    }
+
+    const answers: Record<string, unknown> = {
+      started_at: new Date().toISOString(),
+    };
+
+    // ---- Phase 1: Project Context ----
+    console.log("── Phase 1: Project Context ──");
+    console.log("");
+
+    const q1 = await pick(rl, "Q1 — Project type:\n  [1] Web application\n  [2] Mobile application\n  [3] CLI tool\n  [4] Library/SDK\n  [5] Backend service / API\n  [6] Other\n  > ", [
+      "Web application",
+      "Mobile application",
+      "CLI tool",
+      "Library/SDK",
+      "Backend service / API",
+      "Other",
+    ]);
+    answers.project_type = q1;
+    console.log("");
+
+    const q2 = await pick(rl, "Q2 — Primary language:\n  [1] TypeScript\n  [2] JavaScript\n  [3] Python\n  [4] Go\n  [5] Rust\n  [6] Java\n  [7] Other\n  > ", [
+      "TypeScript",
+      "JavaScript",
+      "Python",
+      "Go",
+      "Rust",
+      "Java",
+      "Other",
+    ]);
+    answers.primary_language = q2;
+    console.log("");
+
+    const q3 = await pick(rl, "Q3 — Team size:\n  [1] Solo\n  [2] 2–5\n  [3] 6–15\n  [4] 16+\n  > ", [
+      "Solo",
+      "2–5",
+      "6–15",
+      "16+",
+    ]);
+    answers.team_size = q3;
+    console.log("");
+
+    const q4 = await pick(rl, "Q4 — Git workflow:\n  [1] Trunk-based (feature/{type}-{issue}-{slug})\n  [2] GitFlow (feature/{slug})\n  [3] GitHub Flow (feat/{slug})\n  [4] Other (feature/{slug})\n  > ", [
+      "trunk-based",
+      "gitflow",
+      "github-flow",
+      "other",
+    ]);
+    answers.git_workflow = q4;
+    console.log("");
+
+    const q5 = await pick(rl, "Q5 — CI/CD platform:\n  [1] GitHub Actions\n  [2] GitLab CI\n  [3] CircleCI\n  [4] Jenkins\n  [5] None / manual\n  [6] Other\n  > ", [
+      "GitHub Actions",
+      "GitLab CI",
+      "CircleCI",
+      "Jenkins",
+      "None / manual",
+      "Other",
+    ]);
+    answers.ci_cd = q5;
+    console.log("");
+
+    // ---- Phase 2: Mugiwara Preferences ----
+    console.log("── Phase 2: Mugiwara Preferences ──");
+    console.log("");
+
+    const q6 = await pick(rl, "Q6 — Autonomy mode:\n  [1] guided — ask before every wave transition\n  [2] semi — auto-advance through waves, pause on failures\n  [3] auto — full auto-pilot\n  > ", [
+      "guided",
+      "semi",
+      "auto",
+    ]);
+    answers.autonomy_mode = q6;
+    console.log("");
+
+    const q7 = await ask(rl, "Q7 — Agents to enable (comma-separated or 'all'):\n  Available: brainstorm, plan, execute, checkpoint, quality, gates, review, security, healing\n  Default: all\n  > ");
+    answers.enabled_agents = q7 || "all";
+    console.log("");
+
+    const q8a = await pick(rl, "Q8a — Code review depth:\n  [1] full — breaking-change map, five-axis review, ≤3 cycles\n  [2] standard — five-axis review, 1 cycle\n  [3] quick — diff-only, no caller-map\n  > ", [
+      "full",
+      "standard",
+      "quick",
+    ]);
+    answers.review_depth = q8a;
+    console.log("");
+
+    const q8b = await pick(rl, "Q8b — Quality check depth:\n  [1] full — format, lint, typecheck, test, build\n  [2] standard — lint, typecheck, test\n  [3] quick — test only\n  > ", [
+      "full",
+      "standard",
+      "quick",
+    ]);
+    answers.quality_depth = q8b;
+    console.log("");
+
+    console.log("Q9 — Test coverage threshold:");
+    const q9 = await pick(rl, "  [1] 90/80 — new code 90%, modified 80%\n  [2] 80/70 — new code 80%, modified 70%\n  [3] custom — enter your own values\n  [4] none — 0/0, no coverage enforcement\n  > ", [
+      "90/80",
+      "80/70",
+      "custom",
+      "none",
+    ]);
+    let coverageNew = 90;
+    let coverageModified = 80;
+    if (q9 === 1) {
+      coverageNew = 90;
+      coverageModified = 80;
+    } else if (q9 === 2) {
+      coverageNew = 80;
+      coverageModified = 70;
+    } else if (q9 === 3) {
+      const cNew = await ask(rl, "  Enter coverage threshold for new code (%): ");
+      const cMod = await ask(rl, "  Enter coverage threshold for modified code (%): ");
+      coverageNew = Number.parseInt(cNew, 10) || 0;
+      coverageModified = Number.parseInt(cMod, 10) || 0;
+    } else {
+      coverageNew = 0;
+      coverageModified = 0;
+    }
+    answers.coverage_threshold = q9;
+    answers.coverage_new = coverageNew;
+    answers.coverage_modified = coverageModified;
+    console.log("");
+
+    const q10 = await pick(rl, "Q10 — Commit style:\n  [1] Conventional Commits (feat:, fix:, chore:, docs:)\n  [2] Semantic (type(scope): message)\n  [3] Free-form\n  > ", [
+      "conventional",
+      "semantic",
+      "free-form",
+    ]);
+    answers.commit_style = q10;
+    answers.completed_at = new Date().toISOString();
+    console.log("");
+
+    // ---- Branch name format ----
+    const branchFormats: Record<number, string> = {
+      1: "feature/{type}-{issue}-{slug}",
+      2: "feature/{slug}",
+      3: "feat/{slug}",
+      4: "feature/{slug}",
+    };
+    const branch = branchFormats[q4] || "feature/{slug}";
+
+    // ---- Autonomy mode ----
+    const modes: Record<number, string> = { 1: "guided", 2: "semi", 3: "auto" };
+    const mode = modes[q6] || "semi";
+
+    // ---- Commit style ----
+    const commitStyles: Record<number, string> = { 1: "conventional", 2: "semantic", 3: "free-form" };
+    const commit = commitStyles[q10] || "conventional";
+
+    // ---- Review depth ----
+    const reviewDepths: Record<number, string> = { 1: "full", 2: "standard", 3: "quick" };
+    const reviewDepth = reviewDepths[q8a] || "standard";
+
+    // ---- Quality depth ----
+    const qualityDepths: Record<number, string> = { 1: "full", 2: "standard", 3: "quick" };
+    const qualityDepth = qualityDepths[q8b] || "standard";
+
+    // ---- Write config ----
+    if (!existsSync(mugiwaraDir)) mkdirSync(mugiwaraDir, { recursive: true });
+
+    const config = {
+      mode,
+      branch,
+      coverage_new: coverageNew,
+      coverage_modified: coverageModified,
+      commit,
+      review_depth: reviewDepth,
+      quality_depth: qualityDepth,
+      enabled_agents: answers.enabled_agents,
+    };
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    writeFileSync(onboardPath, JSON.stringify(answers, null, 2) + "\n");
+
+    // ---- Summary ----
+    const qLabels: Record<string, Record<number, string>> = {
+      project_type: {
+        1: "Web application",
+        2: "Mobile application",
+        3: "CLI tool",
+        4: "Library/SDK",
+        5: "Backend service / API",
+        6: "Other",
+      },
+      primary_language: {
+        1: "TypeScript",
+        2: "JavaScript",
+        3: "Python",
+        4: "Go",
+        5: "Rust",
+        6: "Java",
+        7: "Other",
+      },
+      team_size: { 1: "Solo", 2: "2–5", 3: "6–15", 4: "16+" },
+      git_workflow: { 1: "Trunk-based", 2: "GitFlow", 3: "GitHub Flow", 4: "Other" },
+      ci_cd: { 1: "GitHub Actions", 2: "GitLab CI", 3: "CircleCI", 4: "Jenkins", 5: "None", 6: "Other" },
+      autonomy_mode: { 1: "guided", 2: "semi", 3: "auto" },
+      review_depth: { 1: "full", 2: "standard", 3: "quick" },
+      quality_depth: { 1: "full", 2: "standard", 3: "quick" },
+      coverage_threshold: { 1: "90/80", 2: "80/70", 3: "custom", 4: "none" },
+      commit_style: { 1: "Conventional", 2: "Semantic", 3: "Free-form" },
+    };
+
+    console.log("╔══════════════════════════════════════╗");
+    console.log("║   Onboarding Complete                ║");
+    console.log("╚══════════════════════════════════════╝");
+    console.log("");
+    console.log("  Project type:     ", qLabels.project_type[q1]);
+    console.log("  Primary language: ", qLabels.primary_language[q2]);
+    console.log("  Team size:        ", qLabels.team_size[q3]);
+    console.log("  Git workflow:     ", qLabels.git_workflow[q4]);
+    console.log("  CI/CD:            ", qLabels.ci_cd[q5]);
+    console.log("  Autonomy mode:    ", qLabels.autonomy_mode[q6]);
+    console.log("  Enabled agents:   ", answers.enabled_agents);
+    console.log("  Review depth:     ", qLabels.review_depth[q8a]);
+    console.log("  Quality depth:    ", qLabels.quality_depth[q8b]);
+    console.log("  Coverage:         ", q9 === 3 ? `${coverageNew}/${coverageModified}` : qLabels.coverage_threshold[q9]);
+    console.log("  Commit style:     ", qLabels.commit_style[q10]);
+    console.log("");
+    console.log(`  Config written:   ${configPath}`);
+    console.log(`  Audit trail:      ${onboardPath}`);
+    console.log("");
+  } finally {
+    rl.close();
+  }
+}
+
+main();

package/scripts/release-notes.ts

@@ -1,9 +1,10 @@
 #!/usr/bin/env bun
-// scripts/release-notes.ts — generates a human-readable release description
-// from git history between the previous tag and HEAD. Grouped by change type,
-// conventional-commit aware, no gh dependency.
+// scripts/release-notes.ts — generates a detailed GitHub Release description
+// from git history between the previous tag and HEAD. Pulls the full commit
+// message (subject + body), groups by conventional-commit type, flags breaking
+// changes, and lists the affected scopes. No gh dependency.
 //
-//   bun scripts/release-notes.ts            notes since the last tag → stdout
+//   bun scripts/release-notes.ts                 notes since the last tag → stdout
 //   bun scripts/release-notes.ts --since v0.3.0   notes from that tag → stdout
 import { execFileSync } from 'node:child_process';
 
@@ -22,15 +23,22 @@ if (!since) {
 }
 
 const range = since ? `${since}..HEAD` : '';
-const raw = execFileSync('git', ['log', '--pretty=%s', ...(range ? [range] : [])], { encoding: 'utf8' });
-const commits = raw.split(/\r?\n/).filter(Boolean);
+const raw = execFileSync('git', ['log', '--pretty=%H%n%s%n%n%b%n__END__', ...(range ? [range] : [])], { encoding: 'utf8' });
+const commits = raw
+  .split('__END__\n')
+  .map(c => c.trim())
+  .filter(Boolean)
+  .map(c => {
+    const [sha, subject, ...rest] = c.split('\n');
+    return { sha: sha.slice(0, 7), subject: subject ?? '', body: rest.join('\n').trim() };
+  });
 
 const groups: Record<string, { label: string; items: string[] }> = {
   feat: { label: 'New', items: [] },
   fix: { label: 'Fixed', items: [] },
-  docs: { label: 'Docs', items: [] },
   refactor: { label: 'Refactored', items: [] },
   perf: { label: 'Performance', items: [] },
+  docs: { label: 'Docs', items: [] },
   chore: { label: 'Housekeeping', items: [] },
   test: { label: 'Housekeeping', items: [] },
   ci: { label: 'Housekeeping', items: [] },
@@ -38,12 +46,33 @@ const groups: Record<string, { label: string; items: string[] }> = {
 
 const order = ['feat', 'fix', 'refactor', 'perf', 'docs', 'chore'];
 
-for (const c of commits) {
-  const m = /^(\w+)(?:\(.*\))?!?: (.*)/.exec(c);
+// strip signature trailers (Co-authored-by, Signed-off-by, review notes)
+const TRAILER = /^(Co-authored-by|Signed-off-by|Reviewed-by|Helped-by|Reported-by|Tested-by|Acked-by):/i;
+
+for (const commit of commits) {
+  const m = /^(\w+)(?:\((.*?)\))?!?: (.*)/.exec(commit.subject);
   const type = m ? m[1] : 'chore';
-  const text = m ? m[2] : c;
+  const scope = m?.[2] || '';
+  const text = m ? m[3] : commit.subject;
+  const breaking = Boolean(m?.[0]?.includes('!')) || /^BREAKING CHANGE:/m.test(commit.body);
+
+  const title = text.charAt(0).toUpperCase() + text.slice(1);
+  const scopeTag = scope ? ` \`${scope}\`` : '';
+  const breakingTag = breaking ? ' ⚠️ **BREAKING**' : '';
+
+  const bodyLines = commit.body
+    .split(/\r?\n/)
+    .map(l => l.trim())
+    .filter(l => l && !TRAILER.test(l) && l !== '---')
+    // the release-version marker commit repeats the subject as body — drop it
+    .filter(l => l !== text);
+
+  let entry = `- ${title}${scopeTag}${breakingTag} \`${commit.sha}\``;
+  if (bodyLines.length) {
+    entry += '\n' + bodyLines.map(l => `  - ${l}`).join('\n');
+  }
   const g = groups[type] ?? groups.chore;
-  g.items.push(text.charAt(0).toUpperCase() + text.slice(1));
+  g.items.push(entry);
 }
 
 const lines: string[] = [];
@@ -52,11 +81,11 @@ for (const t of order) {
   if (!g.items.length) continue;
   lines.push(`## ${g.label}`);
   lines.push('');
-  for (const item of g.items) lines.push(`- ${item}`);
+  for (const item of g.items) lines.push(item);
   lines.push('');
 }
 
-const bumpIdx = commits.findIndex(c => /chore: release|chore: bump/.test(c));
+const bumpIdx = commits.findIndex(c => /chore: release|chore: bump/.test(c.subject));
 const body = commits.slice(0, bumpIdx === -1 ? commits.length : bumpIdx);
 const count = body.length || commits.length;
 

package/scripts/retrieval-eval.ts

@@ -3,7 +3,7 @@
 // Builds TF-IDF index over skill descriptions, scores prompts, reports rank-1 + top_k.
 // No model needed — pure string matching. Outputs JSON.
 
-import { readdirSync, readFileSync, existsSync, statSync } from 'node:fs';
+import { readdirSync, readFileSync, existsSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseFrontmatter } from '../src/frontmatter.ts';
 
@@ -256,6 +256,5 @@ if (ciArg !== -1) {
 }
 
 function writeJson(path: string, obj: object) {
-  const { writeFileSync } = require('node:fs');
   writeFileSync(path, JSON.stringify(obj, null, 2) + '\n');
 }

package/scripts/run-evals.ts

@@ -9,6 +9,7 @@
 // keyword match, then reports pass/fail per case and a rank-1 style score.
 // The command defaults to "claude -p" — override with MUGIWARA_EVAL_CMD.
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
 
 const root = join(import.meta.dirname, '..');
@@ -136,7 +137,6 @@ async function runCases(env: { execFileSync: typeof import('node:child_process')
 
 const runArg = process.argv.indexOf('--run');
 if (runArg !== -1) {
-  const { execFileSync } = require('node:child_process');
   const cmd = process.env.MUGIWARA_EVAL_CMD ?? 'claude -p';
   const [bin, ...pre] = cmd.split(' ');
   runCases({ execFileSync, bin, pre });