@ionivetech/mugiwara 0.8.2 → 0.9.1

package/scripts/write-metrics.ts

@@ -3,7 +3,7 @@
 // Deterministic, no network. Runs retrieval-eval --json and verify-install --json.
 
 import { execSync } from 'node:child_process';
-import { mkdirSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 const root = join(import.meta.dirname, '..');
@@ -71,3 +71,27 @@ const outPath = join(outDir, 'latest.json');
 writeFileSync(outPath, JSON.stringify(metrics, null, 2) + '\n');
 console.log(`✓ wrote ${outPath}`);
 console.log(JSON.stringify(metrics, null, 2));
+
+// Sync the README metrics table in the same run, so neither AI nor human
+// opens a PR with stale numbers (the classic first-push CI red). The
+// --check-readme-metrics gate stays as the backstop: if these patterns stop
+// matching, it fails loudly instead of silently drifting.
+{
+  const readmePath = join(root, 'README.md');
+  const before = readFileSync(readmePath, 'utf8');
+  let after = before;
+  after = after.replace(
+    /\*\*[\d.]+%\*\*, \d+ probes/,
+    `**${rank1Str}**, ${probes} probes`,
+  );
+  after = after.replace(
+    /\*\*\d+\/\d+\*\*(, \d+ targets)/,
+    `**${pointersTotal}/${pointersTotal}**$1`,
+  );
+  if (after !== before) {
+    writeFileSync(readmePath, after);
+    console.log('✓ README metrics table synced');
+  } else {
+    console.log('✓ README metrics table already current');
+  }
+}

package/src/args.ts

@@ -6,7 +6,7 @@ export type Args = {
   flags: Record<string, FlagValue>;
 };
 
-const VALUE_FLAGS: Record<string, string> = { '--project': 'project', '--target': 'target', '--before': 'before', '--backend': 'backend', '--mission': 'mission' };
+const VALUE_FLAGS: Record<string, string> = { '--project': 'project', '--target': 'target', '--before': 'before', '--backend': 'backend', '--mission': 'mission', '--to-team': 'toTeam', '--to-solo': 'toSolo' };
 const BOOL_FLAGS: Record<string, string> = {
   '--global': 'global', '--yes': 'yes', '-y': 'yes', '--force': 'force',
   '--dry-run': 'dryRun', '--keep-logs': 'keepLogs', '--check': 'check', '--all': 'all', '--verify': 'verify',

package/src/cli.ts

@@ -19,6 +19,7 @@ import { ensureConfig } from './config.ts';
 import { costEnvelope } from './cost.ts';
 import { computeLiveSlop } from './slop.ts';
 import { loadRegistry } from './evidence.ts';
+import { runInitiative } from './initiative.ts';
 import { buildCostLedger, toCostJSON } from './reporting.ts';
 import { enforceHarnessPolicy } from './policy.ts';
 
@@ -80,7 +81,9 @@ export async function run(argv: string[]): Promise<void> {
     case 'blame': return blameCmd(flags, _);
     case 'handoff': return handoffCmd(flags, _);
     case 'sign': return signCmd(flags, _);
-    case 'migrate': return migrateCmd(flags);
+    case 'migrate': return migrateCmd(flags, _);
+    case 'lesson': return lessonCmd(flags, _);
+    case 'initiative': return initiativeCmd(flags, _);
     default: throw new Error(`Unknown command: ${command}`);
   }
 }
@@ -196,7 +199,13 @@ async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; pro
         targetIds = idx.includes(0) ? [...TARGET_IDS] : idx.map(i => TARGET_IDS[i - 1]);
       }
     }
+    const MARKETPLACE = new Set(['cursor', 'kimi', 'pi']);
     for (const id of targetIds) {
+      if (MARKETPLACE.has(id)) {
+        console.error(`mugiwara: ${id} installs through its marketplace manifest, not --target.`);
+        console.error('  See docs/reference/harness-matrix.md — marketplace row.');
+        process.exit(1);
+      }
       if (!targets[id]) throw new Error(`Unknown target: ${id} (valid: ${TARGET_IDS.join(', ')}, all)`);
     }
 
@@ -581,9 +590,150 @@ function handoffCmd(flags: Args['flags'], positionals: string[]): void {
   console.log(`\nwritten: ${out}`);
 }
 
-export function migrateCmd(flags: Args['flags']): void {
+function lessonCmd(flags: Args['flags'], positionals: string[]): void {
+  const projectDir = resolveProjectDir(str(flags.project));
+  const text = positionals.slice(1).join(' ').trim();
+  if (!text) { console.error('usage: mugiwara lesson "<text>" [--project <dir>]'); process.exit(1); }
+  const file = join(projectDir, '.mugiwara', 'lessons.md');
+  const date = new Date().toISOString().slice(0, 10);
+  const sanitized = text.replace(/\|/g, '/').replace(/\r?\n/g, ' ').trim();
+  const line = `| ${date} | manual | general | ${sanitized} |`;
+  const header = '| Date | Mission | Area | Lesson |\n|---|---|---|---|';
+  let existing = '';
+  try { existing = readFileSync(file, 'utf8'); } catch {}
+  if (!existing) {
+    mkdirSync(join(projectDir, '.mugiwara'), { recursive: true });
+    writeFileSync(file, header + '\n' + line + '\n');
+  } else {
+    // ensure file ends with newline
+    const needsNewline = !existing.endsWith('\n');
+    writeFileSync(file, existing + (needsNewline ? '\n' : '') + line + '\n');
+  }
+  console.log(`lesson appended: ${line}`);
+}
+
+/** `mugiwara initiative <status|conflict-check> <plan>` — sub-mission checks. */
+function initiativeCmd(_flags: Args['flags'], positionals: string[]): void {
+  const r = runInitiative(positionals[1], positionals[2]);
+  process.stdout.write(r.output);
+  if (r.code !== 0) process.exit(r.code);
+}
+
+export function migrateCmd(flags: Args['flags'], positionals: string[] = []): void {
   const projectDir = resolveProjectDir(str(flags.project));
   const dryRun = flag(flags.dryRun);
+  // --to-team / --to-solo: solo<->team layout switch (W4). Moves, not copies.
+  const toTeam = str(flags.toTeam);
+  const toSolo = str(flags.toSolo);
+  if (toTeam || toSolo) {
+    const member = (toTeam ?? toSolo) as string;
+    if (!/^[A-Za-z0-9._-]+$/.test(member) || /^\.+$/.test(member) || member === 'state' || member === 'continue') {
+      console.error(`invalid member name "${member}" (allowlist: [a-zA-Z0-9._-], not a dot-path, not state/continue)`);
+      process.exit(1);
+    }
+    if (toTeam && toSolo) {
+      console.error('use either --to-team or --to-solo, not both');
+      process.exit(1);
+    }
+    const missionsRootInner = join(projectDir, '.mugiwara', 'missions');
+    let mission = str(flags.mission) ?? (positionals[1] ? String(positionals[1]) : null);
+    const inferMission = (): string | null => {
+      if (!existsSync(missionsRootInner)) return null;
+      const all = readdirSync(missionsRootInner, { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name);
+      if (mission && all.includes(mission)) return mission;
+      if (mission) return mission;
+      // try to find candidate missions for the requested operation
+      if (toTeam) {
+        const candidates = all.filter(m => existsSync(join(missionsRootInner, m, 'state.json')));
+        if (candidates.length === 1) return candidates[0];
+        if (candidates.length === 0) {
+          console.error('no solo mission with state.json found for --to-team');
+          process.exit(1);
+        }
+        console.error(`multiple solo missions: ${candidates.join(', ')} — specify --mission <id>`);
+        process.exit(1);
+      } else {
+        const candidates = all.filter(m => existsSync(join(missionsRootInner, m, `${member}.json`)));
+        if (candidates.length === 1) return candidates[0];
+        if (candidates.length === 0) {
+          console.error(`no mission with ${member}.json found for --to-solo`);
+          process.exit(1);
+        }
+        console.error(`multiple missions with ${member}.json: ${candidates.join(', ')} — specify --mission <id>`);
+        process.exit(1);
+      }
+      return null;
+    };
+    const targetMission = inferMission();
+    if (!targetMission) {
+      console.error('could not infer mission — specify --mission <id>');
+      process.exit(1);
+    }
+    const dir = join(missionsRootInner, targetMission);
+    if (toTeam) {
+      const srcState = join(dir, 'state.json');
+      const srcContinue = join(dir, 'continue.json');
+      const destState = join(dir, `${member}.json`);
+      const destContinue = join(dir, `continue-${member}.json`);
+      if (!existsSync(srcState)) {
+        console.error(`mission "${targetMission}" has no state.json — already team or not found`);
+        process.exit(1);
+      }
+      if (existsSync(destState)) {
+        console.error(`destination ${destState} already exists`);
+        process.exit(1);
+      }
+      const toMove: Array<{ src: string; dest: string }> = [{ src: srcState, dest: destState }];
+      if (existsSync(srcContinue)) toMove.push({ src: srcContinue, dest: destContinue });
+      for (const m of toMove) {
+        console.log(`${dryRun ? 'would migrate' : 'migrated'} ${m.src} → ${m.dest}`);
+        if (!dryRun) {
+          mkdirSync(dirname(m.dest), { recursive: true });
+          try { renameSync(m.src, m.dest); } catch { /* fallback copy */ 
+            try { writeFileSync(m.dest, readFileSync(m.src)); rmSync(m.src, { force: true }); } catch {}
+          }
+        }
+      }
+      console.log(`${dryRun ? 'would migrate' : 'migrated'} ${toMove.length} file(s)${dryRun ? ' (dry run)' : ''}`);
+      return;
+    } else {
+      // --to-solo
+      const srcState = join(dir, `${member}.json`);
+      const srcContinue = join(dir, `continue-${member}.json`);
+      const destState = join(dir, 'state.json');
+      const destContinue = join(dir, 'continue.json');
+      if (!existsSync(srcState)) {
+        console.error(`mission "${targetMission}" has no ${member}.json`);
+        process.exit(1);
+      }
+      const files = readdirSync(dir).filter(f => {
+        const stem = f.replace(/\.json$/, '');
+        return f.endsWith('.json') && stem !== 'continue' && !stem.startsWith('continue-');
+      });
+      const members = files.filter(f => f !== 'state.json');
+      if (members.length > 1) {
+        console.error(`mission "${targetMission}" has ${members.length} members (${members.join(', ')}) — refusing --to-solo (would orphan)`);
+        process.exit(1);
+      }
+      if (existsSync(destState)) {
+        console.error(`destination ${destState} already exists`);
+        process.exit(1);
+      }
+      const toMove: Array<{ src: string; dest: string }> = [{ src: srcState, dest: destState }];
+      if (existsSync(srcContinue)) toMove.push({ src: srcContinue, dest: destContinue });
+      for (const m of toMove) {
+        console.log(`${dryRun ? 'would migrate' : 'migrated'} ${m.src} → ${m.dest}`);
+        if (!dryRun) {
+          mkdirSync(dirname(m.dest), { recursive: true });
+          try { renameSync(m.src, m.dest); } catch {
+            try { writeFileSync(m.dest, readFileSync(m.src)); rmSync(m.src, { force: true }); } catch {}
+          }
+        }
+      }
+      console.log(`${dryRun ? 'would migrate' : 'migrated'} ${toMove.length} file(s)${dryRun ? ' (dry run)' : ''}`);
+      return;
+    }
+  }
   const legacyState = join(projectDir, '.mugiwara', 'state');
   const legacyContinue = join(projectDir, '.mugiwara', 'continue');
   const missionsRoot = join(projectDir, '.mugiwara', 'missions');
@@ -718,7 +868,12 @@ Usage:
   mugiwara sign --gen-key [--backend pure|minisign]
                          create signing keys (pure ed25519 default)
   mugiwara migrate [--dry-run] [--project <dir>]
-                          move legacy .mugiwara/state/ layout to .mugiwara/missions/
+                           move legacy .mugiwara/state/ layout to .mugiwara/missions/
+  mugiwara migrate --to-team <member> [--mission <id>] [--dry-run]
+                           move state.json -> <member>.json (solo -> team)
+  mugiwara migrate --to-solo <member> [--mission <id>] [--dry-run]
+                           move <member>.json -> state.json (team -> solo; refuses if >1 member)
+  mugiwara lesson "<text>" append a dated row to .mugiwara/lessons.md
   mugiwara run <script> [args...]
                           run a bundled harness script here (${RUNNABLE.join(', ')})
   mugiwara savepoint <mission> [member] [flow] [mode]

package/src/config.ts

@@ -9,24 +9,43 @@ import { join } from 'node:path';
 
 /** The default config body, identical to what the installer has always written. */
 export const DEFAULT_CONFIG = [
-  'mode=guided',
+  '# Mugiwara config. Project overrides ~/.mugiwara/config.',
+  '# Every key here is read by code. Delete a line to take its default.',
+  '',
+  '# -- Autonomy ---------------------------------------------',
+  'mode=guided                  # guided | semi | auto — how much the crew does without asking',
+  'verbosity=normal             # normal | full — how much the crew echoes',
+  '',
+  '# -- Team -------------------------------------------------',
+  '# team_member=              # your member id; set it and state isolates per person',
+  '# team_members=1            # how many people on this mission; >1 enables team-scoped posture',
+  '',
+  '# -- Git --------------------------------------------------',
   'branch=feature/{type}-{issue}-{slug}',
   'commit=conventional',
-  'auto_commit=on',
+  'auto_commit=off              # on | off — off hands you an uncommitted tree in guided/semi',
+  '',
+  '# -- Gates ------------------------------------------------',
   'coverage_new=85',
   'coverage_modified=90',
-  'review_depth=full',
+  'review_depth=full            # full | standard | quick',
   'quality_depth=full',
   'verify_merged=off',
-  'delegate_threshold=60',
-  'heal_max_cycles=3',
-  'verbosity=normal',
-  '# context_budget_chars=150000  # optional: fail archive if trail exceeds this (measured in report Cost section)',
-  '# investigation_max_passes=2  # optional: cap investigation passes (spec §13)',
+  '',
+  '# -- Limits -----------------------------------------------',
+  'delegate_threshold=60        # % of budget before delegation is advised',
+  'heal_max_cycles=3            # heal loop halts here and escalates',
+  '',
+  '# -- Monorepo ---------------------------------------------',
+  '# lane_scope_glob=packages/api/**   # count only matching files when sizing the lane',
+  '',
+  '# -- Optional ---------------------------------------------',
+  '# context_budget_chars=150000       # fail archive if the trail exceeds this',
+  '# investigation_max_passes=2',
   '# investigation_max_unrelated_files=5',
   '# investigation_repeated_read_threshold=2',
-  '# sign=auto            # optional: auto | minisign | pure | off — report attestation',
-  '# enforce=block                # optional: off | warn | block — pipeline-guard policy',
+  '# sign=auto                         # auto | minisign | pure | off',
+  '# enforce=block                     # off | warn | block — pipeline-guard policy',
 ].join('\n') + '\n';
 
 /** Config file path candidates: project first, then user home. */
@@ -57,7 +76,10 @@ export function readConfig(projectDir: string): Record<string, string> {
       const key = t.slice(0, eq).trim();
       if (!key) continue;
       if (key in out) continue; // project value already set — keep it
-      out[key] = t.slice(eq + 1).trim();
+      let rawVal = t.slice(eq + 1).trim();
+      const hash = rawVal.indexOf('#');
+      if (hash !== -1) rawVal = rawVal.slice(0, hash).trim();
+      out[key] = rawVal;
     }
   }
   return out;

package/src/guards.ts

@@ -0,0 +1,40 @@
+// src/guards.ts — shared irreversible-command predicates (E4, E5).
+//
+// Single source of truth for the FORBIDDEN table. hooks/pretool-guard.ts
+// imports it (bundled into the .js by build-hooks). The opencode plugin
+// (.opencode/plugins/mugiwara.mjs) embeds a copy of the table delimited by
+// the same GUARDS-TABLE markers — test/plugin.test.ts asserts the two blocks
+// are byte-identical, so a drift fails CI instead of silently forking
+// enforcement across harnesses.
+
+export const FORBIDDEN: Array<[RegExp, string]> = [
+// GUARDS-TABLE-START
+  [/\bgh\s+pr\s+(create|merge|ready)\b/, 'opening or merging a PR'],
+  [/\bgh\s+release\s+create\b/, 'creating a release'],
+  [/\bgit\s+merge\b/, 'merging a branch'],
+  [/\bgit\s+push\b[^|;&]*\b(main|master|production|release)\b/, 'pushing to a protected branch'],
+  [/\bgit\s+push\b[^|;&]*--force/, 'force-pushing'],
+  [/\bnpm\s+publish\b|\byarn\s+publish\b|\bpnpm\s+publish\b/, 'publishing a package'],
+  [/\bkubectl\s+(apply|delete|rollout)\b/, 'changing a cluster'],
+  [/\bterraform\s+(apply|destroy)\b/, 'changing infrastructure'],
+  [/\bdocker\s+push\b/, 'pushing an image'],
+  [/\baws\s+\w+\s+(create|delete|update|put)\b/, 'changing cloud resources'],
+// GUARDS-TABLE-END
+];
+
+/** The refused action for a shell command, or null when it may run. */
+export function checkCommand(command: string): string | null {
+  for (const [re, action] of FORBIDDEN) {
+    if (re.test(command)) return action;
+  }
+  return null;
+}
+
+/** Deny message: names the action, the human terminal step, the escape hatch. */
+export function refusalMessage(action: string): string {
+  return (
+    `Mugiwara: refusing to ${action}. The crew never creates a PR, merges, or ` +
+    `deploys — the human does, from the branch and the verdict the crew hands over. ` +
+    `Run it yourself, or set enforce=off in .mugiwara/config.`
+  );
+}

package/src/initiative.ts

@@ -0,0 +1,174 @@
+// src/initiative.ts — sub-mission dashboard + conflict detection (N1).
+//
+// Flow 2 produces a `## Sub-missions` table on team missions; nothing checked
+// it after the original command was deleted. `status` renders the dashboard,
+// `conflict-check` exits 1 when one file is touched by two sub-missions.
+import { existsSync, readFileSync } from 'node:fs';
+
+export interface SubMission {
+  id: string;
+  name: string;
+  assignee: string;
+  branch: string;
+  status: string;
+  dependsOn: string;
+  touchedFiles: string[];
+}
+
+/** Canonical header — printed as the hint when a table fails to parse. */
+export const SUB_MISSIONS_HEADER =
+  '| ID | Name | Assignee | Branch | Status | Depends On | Touched Files |';
+
+/** Split a Touched Files cell on commas AND whitespace; no trailing commas survive. */
+export function splitTouchedFiles(cell: string): string[] {
+  return cell
+    .split(/[,\s]+/)
+    .map((s) => s.trim().replace(/,+$/, ''))
+    .filter(Boolean);
+}
+
+export interface ParseResult {
+  /** True when a `## Sub-missions` section exists (any case). */
+  hasSection: boolean;
+  rows: SubMission[];
+}
+
+function splitRow(line: string): string[] {
+  let t = line.trim();
+  if (t.startsWith('|')) t = t.slice(1);
+  if (t.endsWith('|')) t = t.slice(0, -1);
+  return t.split('|').map((c) => c.trim());
+}
+
+/**
+ * Parse the `## Sub-missions` table. Header match is case-insensitive
+ * (`| id | name |` and `| ID | Name |` both work). Returns zero rows — not an
+ * error here — when the section exists but no data rows parse; the caller
+ * decides what that means (conflict-check treats it as a defect, never as a
+ * solo mission).
+ */
+export function parseSubMissions(planText: string): ParseResult {
+  const lines = planText.split('\n');
+  const sectionIdx = lines.findIndex((l) => /^##\s+sub-missions\s*$/i.test(l.trim()));
+  if (sectionIdx < 0) return { hasSection: false, rows: [] };
+  const endIdx = lines.findIndex((l, i) => i > sectionIdx && /^##\s+\S/.test(l.trim()));
+  const body = lines.slice(sectionIdx + 1, endIdx < 0 ? undefined : endIdx);
+
+  const isTableLine = (l: string): boolean => /^\s*\|.*\|\s*$/.test(l);
+  const isSeparator = (l: string): boolean => /^\s*\|?[\s:|-]+\|?[\s:|.-]*$/.test(l) && /-/.test(l);
+  const table = body.filter((l) => isTableLine(l));
+  if (!table.length) return { hasSection: true, rows: [] };
+  const header = splitRow(table[0]).map((c) => c.toLowerCase());
+  // Case-insensitive header match: must at least identify id + name columns.
+  const idIdx = header.findIndex((c) => c === 'id');
+  const nameIdx = header.findIndex((c) => c === 'name');
+  if (idIdx < 0 || nameIdx < 0) return { hasSection: true, rows: [] };
+  const col = (name: string, fallback: number): number => {
+    const i = header.findIndex((c) => c === name);
+    return i < 0 ? fallback : i;
+  };
+  const touchedIdx = header.findIndex((c) => /touch/.test(c));
+  const dataStart = table.length > 1 && isSeparator(table[1]) ? 2 : 1;
+  const rows: SubMission[] = [];
+  for (const line of table.slice(dataStart)) {
+    if (isSeparator(line)) continue;
+    const cells = splitRow(line);
+    const id = cells[idIdx] ?? '';
+    if (!id) continue;
+    rows.push({
+      id,
+      name: cells[nameIdx] ?? '',
+      assignee: cells[col('assignee', 2)] ?? '',
+      branch: cells[col('branch', 3)] ?? '',
+      status: cells[col('status', 4)] ?? '',
+      dependsOn: cells[col('depends on', 5)] ?? '',
+      touchedFiles: touchedIdx < 0 ? [] : splitTouchedFiles(cells[touchedIdx] ?? ''),
+    });
+  }
+  return { hasSection: true, rows };
+}
+
+const DONE = /(\[x\]|done|complete|merged|closed)/i;
+
+/** Rows whose Depends On names an unfinished sub-mission. */
+export function blockedRows(rows: SubMission[]): Array<{ id: string; blockedBy: string }> {
+  const statusOf = new Map(rows.map((r) => [r.id.toLowerCase(), r.status]));
+  const out: Array<{ id: string; blockedBy: string }> = [];
+  for (const r of rows) {
+    const dep = r.dependsOn.trim();
+    if (!dep || dep === '-') continue;
+    for (const part of dep.split(/[,\s]+/).filter(Boolean)) {
+      const st = statusOf.get(part.toLowerCase());
+      if (st !== undefined && !DONE.test(st)) {
+        out.push({ id: r.id, blockedBy: part });
+        break;
+      }
+      if (st === undefined && !DONE.test(dep)) {
+        out.push({ id: r.id, blockedBy: part });
+        break;
+      }
+    }
+  }
+  return out;
+}
+
+export interface Conflict {
+  file: string;
+  ids: string[];
+}
+
+/** Files touched by more than one sub-mission. */
+export function findConflicts(rows: SubMission[]): Conflict[] {
+  const owners = new Map<string, string[]>();
+  for (const r of rows) {
+    for (const f of r.touchedFiles) {
+      const list = owners.get(f) ?? [];
+      if (!list.includes(r.id)) list.push(r.id);
+      owners.set(f, list);
+    }
+  }
+  return [...owners.entries()]
+    .filter(([, ids]) => ids.length > 1)
+    .map(([file, ids]) => ({ file, ids }));
+}
+
+export interface InitiativeResult {
+  code: number;
+  output: string;
+}
+
+export function runInitiative(sub: string | undefined, planPath: string | undefined): InitiativeResult {
+  if (!sub || (sub !== 'status' && sub !== 'conflict-check')) {
+    return { code: 1, output: 'usage: mugiwara initiative <status|conflict-check> <plan>\n' };
+  }
+  if (!planPath) {
+    return { code: 1, output: `usage: mugiwara initiative ${sub} <plan>\n` };
+  }
+  if (!existsSync(planPath)) {
+    return { code: 1, output: `mugiwara: plan not found: ${planPath}\n` };
+  }
+  const { hasSection, rows } = parseSubMissions(readFileSync(planPath, 'utf8'));
+  if (!hasSection) {
+    return { code: 0, output: 'solo mission (no ## Sub-missions section)\n' };
+  }
+  if (!rows.length) {
+    return {
+      code: 1,
+      output: `mugiwara: ## Sub-missions section present but no rows parsed — expected header:\n${SUB_MISSIONS_HEADER}\n`,
+    };
+  }
+  if (sub === 'status') {
+    const blocked = new Map(blockedRows(rows).map((b) => [b.id, b.blockedBy]));
+    const lines = ['id | name | assignee | branch | status | blocked-by'];
+    for (const r of rows) {
+      lines.push(
+        `${r.id} | ${r.name} | ${r.assignee} | ${r.branch} | ${r.status} | ${blocked.get(r.id) ?? '-'}`,
+      );
+    }
+    return { code: 0, output: lines.join('\n') + '\n' };
+  }
+  const conflicts = findConflicts(rows);
+  if (!conflicts.length) return { code: 0, output: 'no conflicts: no file is touched by two sub-missions\n' };
+  const lines = conflicts.map((c) => `conflict: ${c.file} touched by ${c.ids.join(', ')}`);
+  return { code: 1, output: lines.join('\n') + '\n' };
+}