pan-wizard 3.35.0 → 3.37.0

package/pan-wizard-core/bin/lib/findings.cjs

@@ -27,6 +27,12 @@
  *   - IDEMPOTENCY: recording the same artifact twice is a no-op that returns the
  *     first verdict (record_sig). That is why exec-phase and verify-phase may both
  *     record one verification.md.
+ *   - LEARNED SUPPRESSIONS (R3): a dismissed finding is noise for its file as it was
+ *     when dismissed. The same judge raising it again (same signature, sameFinding)
+ *     is filtered, in the dismissal's phase (candidate) or, once dismissed in two
+ *     phases, in any phase (promoted). When the file changes the suppression retires
+ *     and the finding comes back open. Security and logic findings, and findings
+ *     with no file, are never suppressed: a re-report reopens them.
  */
 const fs = require('fs');
 const path = require('path');
@@ -40,6 +46,11 @@ const LEDGER_V = 1;
 const REASON_MAX = 300;
 const FINDING_ID_RE = /^f_[0-9a-f]{10}$/;
 const STATUSES = Object.freeze(['open', ...V.DISPOSITIONS]);
+// Logic findings are never suppressed (R3): what the code does wrong, or not at all.
+const LOGIC_CLASSES = Object.freeze(['defect', 'contradicts', 'missing', 'partial']);
+// Security findings are never suppressed either, whatever class a judge gave them.
+const SECURITY_RE = /secur|inject|xss|csrf|ssrf|secret|credential|password|authenticat|authoriz|\bauth\b|token|crypt|traversal|privilege|sanitiz|escap|cve-|owasp|\brce\b|deserializ/i;
+const SECURITY_AGENTS = Object.freeze(['pan-hardener']);
 
 function ledgerPath(cwd) {
   return planningPath(cwd, FINDINGS_FILE);
@@ -80,7 +91,9 @@ function foldFindings(rows) {
         id: r.id, phase: r.phase, milestone: r.milestone || null, agent: r.agent, class: r.class,
         severity: r.severity, where: r.where || null, summary: r.summary, first_seen: r.ts,
         first_verdict_id: r.verdict_id || null, reports: 0, last_reported: null, _reportedSeq: -1,
-        disposition: null, reason: null, disposed_at: null, auto: false, _disposedSeq: -1,
+        disposition: null, reason: null, disposed_at: null, auto: false, file_sha: null, _disposedSeq: -1, _returnedSeq: -1,
+        ...(r.pre_existing === true ? { pre_existing: true } : {}),
+        proof: null,
       });
     } else if (r.kind === 'verdict') {
       verdicts.push({ ...r, _seq: seq });
@@ -91,6 +104,15 @@ function foldFindings(rows) {
         f.last_reported = r.ts;
         f._reportedSeq = seq;
       }
+      // A dismissed finding raised again once its suppression no longer holds (R3).
+      for (const id of Array.isArray(r.returned_ids) ? r.returned_ids : []) {
+        const f = findings.get(id);
+        if (f) f._returnedSeq = seq;
+      }
+    } else if (r.kind === 'proof' && typeof r.id === 'string') {
+      // R5: the latest catching-test run for a finding.
+      const f = findings.get(r.id);
+      if (f) f.proof = { status: r.status, test: r.test };
     } else if (r.kind === 'disposition' && typeof r.id === 'string') {
       const f = findings.get(r.id);
       if (!f || !V.DISPOSITIONS.includes(r.disposition)) return;
@@ -98,12 +120,14 @@ function foldFindings(rows) {
       f.reason = r.reason || null;
       f.disposed_at = r.ts;
       f.auto = r.auto === true;
+      f.file_sha = r.file_sha || null;
       f._disposedSeq = seq;
     }
   });
   for (const f of findings.values()) {
     if (!f.disposition) f.status = 'open';
     else if (f.disposition === 'fixed' && f._reportedSeq > f._disposedSeq) f.status = 'open';
+    else if (f._returnedSeq > f._disposedSeq) f.status = 'open';
     else f.status = f.disposition;
   }
   return { verdicts, findings };
@@ -111,8 +135,9 @@ function foldFindings(rows) {
 
 /** A finding as the CLI shows it (internal sequence fields removed). */
 function publicFinding(f) {
-  const { _reportedSeq, _disposedSeq, ...rest } = f;
-  return rest;
+  const { _reportedSeq, _disposedSeq, _returnedSeq, ...rest } = f;
+  // R5: confirmed only with a catching test that passed its proof; a candidate otherwise.
+  return { ...rest, confidence: f.proof && f.proof.status === 'confirmed' ? 'confirmed' : 'candidate' };
 }
 
 function countBy(list, key) {
@@ -168,6 +193,52 @@ function truncateReason(s) {
   return String(s).replace(/\s+/g, ' ').trim().slice(0, REASON_MAX);
 }
 
+// ─── Learned suppressions (R3) ──────────────────────────────────────────────
+
+/** Security and logic findings are always reported, dismissed or not. */
+function neverSuppressed(f, agent) {
+  return LOGIC_CLASSES.includes(f.class) || SECURITY_AGENTS.includes(agent) || SECURITY_RE.test(String(f.summary || ''));
+}
+
+/** The content hash of the project file a `where` names, or null (no file, outside the project, unreadable). */
+function fileSha(cwd, where) {
+  const file = fileOf(where);
+  if (!file || file.startsWith('code-fact:')) return null;
+  const abs = path.resolve(cwd, file);
+  const rel = path.relative(path.resolve(cwd), abs);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+  try { return crypto.createHash('sha256').update(fs.readFileSync(abs)).digest('hex'); } catch { return null; }
+}
+
+/**
+ * Every learned suppression: a dismissed finding scoped to a file, of a kind that may
+ * be suppressed. `active` while the file is as it was when dismissed; `promoted` once
+ * the same judge dismissed the same signature in two phases (active ones only).
+ */
+function learnedSuppressions(cwd, fold) {
+  const shas = new Map();
+  const current = (where) => {
+    const k = fileOf(where);
+    if (!shas.has(k)) shas.set(k, fileSha(cwd, where));
+    return shas.get(k);
+  };
+  const all = [...fold.findings.values()]
+    .filter((f) => f.status === 'dismissed' && f.file_sha && !neverSuppressed(f, f.agent))
+    .map((f) => ({ f, active: current(f.where) === f.file_sha }));
+  return all.map((s) => {
+    const phases = new Set(all.filter((o) => o.active && o.f.agent === s.f.agent && sameFinding(o.f, s.f)).map((o) => V.comparablePhase(o.f.phase)));
+    return { ...s, scope: phases.size >= 2 ? 'promoted' : 'candidate' };
+  });
+}
+
+/** The suppression that filters this judge's finding in this phase, or null. */
+function suppressionFor(supps, agent, phase, f) {
+  if (neverSuppressed(f, agent)) return null;
+  const hits = supps.filter((s) => s.active && s.f.agent === agent && sameFinding(s.f, f)
+    && (s.scope === 'promoted' || samePhase(s.f.phase, phase)));
+  return hits.find((s) => samePhase(s.f.phase, phase)) || hits[0] || null;
+}
+
 /**
  * How stable a judge's findings are across its reports on one phase (V6): between
  * consecutive verdicts, how many ids appeared and how many disappeared. A judge whose
@@ -218,8 +289,14 @@ function recordVerdict(cwd, input) {
   const text = typeof input.text === 'string' ? input.text : '';
   if (!text.trim()) return { error: 'empty_input', reason: 'nothing to record' };
 
-  const parsed = V.parseVerdictText(text, { agent: input.agent, phase });
+  let parsed = V.parseVerdictText(text, { agent: input.agent, phase });
   if (!parsed.ok) return { error: parsed.error, reason: parsed.reason };
+  // A verification is read against the engine's test run (V2): a failed run is a code
+  // fact that lowers the verifier's pass, as a failed test_gate already does (V9).
+  if (parsed.verdict.agent === 'pan-verifier') {
+    const facts = require('./test-gate.cjs').testRunFacts(cwd, phase);
+    if (facts.length) parsed = V.parseVerdictText(text, { agent: input.agent, phase, facts });
+  }
   const verdict = parsed.verdict;
   const agent = verdict.agent;
   const recordSig = V.recordSig(text);
@@ -237,7 +314,7 @@ function recordVerdict(cwd, input) {
 
   const dup = fold.verdicts.find((r) => r.record_sig === recordSig && r.agent === agent && samePhase(r.phase, phase));
   if (dup) {
-    return { ...base, recorded: false, duplicate: true, verdict_id: dup.verdict_id, attempt: dup.attempt, phase, findings: (dup.finding_ids || []).length, new: 0, rematched: 0, resolved: 0, unaddressed: [], reopened: 0 };
+    return { ...base, recorded: false, duplicate: true, verdict_id: dup.verdict_id, attempt: dup.attempt, phase, findings: (dup.finding_ids || []).length, new: 0, rematched: 0, resolved: 0, unaddressed: [], reopened: 0, suppressed: dup.suppressed || [], returned: (dup.returned_ids || []).length };
   }
 
   const prior = fold.verdicts.filter((r) => r.agent === agent && samePhase(r.phase, phase));
@@ -251,6 +328,10 @@ function recordVerdict(cwd, input) {
   const newRows = [];
   const findingRows = [];
   const mine = [...fold.findings.values()].filter((e) => e.agent === agent && samePhase(e.phase, phase));
+  const supps = learnedSuppressions(cwd, fold);
+  const suppressed = [];
+  const returned = [];
+  const preExisting = [];
   let rematched = 0;
   for (const f of verdict.findings) {
     let id = V.findingId(phase, agent, f);
@@ -261,9 +342,21 @@ function recordVerdict(cwd, input) {
       if (earlier) { id = earlier.id; rematched++; }
     }
     if (ids.includes(id)) continue; // the same finding twice in one report is one finding
+    // A learned suppression (R3) filters it; a dismissed finding no suppression
+    // covers any more comes back open.
+    const existing = fold.findings.get(id);
+    if (!existing || existing.status === 'dismissed') {
+      const s = suppressionFor(supps, agent, phase, f);
+      if (s) {
+        suppressed.push({ id: s.f.id, scope: s.scope, summary: f.summary });
+        continue;
+      }
+      if (existing) returned.push(id);
+    }
     ids.push(id);
     if (!fold.findings.has(id)) {
-      findingRows.push({ v: LEDGER_V, kind: 'finding', ts, id, verdict_id: verdictId, phase, milestone, agent, class: f.class, severity: f.severity, where: f.where, summary: f.summary });
+      findingRows.push({ v: LEDGER_V, kind: 'finding', ts, id, verdict_id: verdictId, phase, milestone, agent, class: f.class, severity: f.severity, where: f.where, summary: f.summary, ...(f.pre_existing ? { pre_existing: true } : {}) });
+      if (f.pre_existing) preExisting.push(id);
     }
   }
 
@@ -307,13 +400,19 @@ function recordVerdict(cwd, input) {
   newRows.push({
     v: LEDGER_V, kind: 'verdict', ts, verdict_id: verdictId, record_sig: recordSig, phase, milestone, agent,
     verdict: verdict.verdict, outcome: verdict.outcome, ...lowered, attempt, source, finding_ids: ids,
+    ...(returned.length ? { returned_ids: returned } : {}),
+    ...(suppressed.length ? { suppressed } : {}),
     by_severity: bySeverity, by_class: byClass, warnings: parsed.warnings,
     ...(notChecked.length ? { not_checked: notChecked } : {}),
+    ...(verdict.declined && verdict.declined.length ? { declined: verdict.declined } : {}),
     // A plan check is bound to the plans it checked (V7): exec-phase compares this
     // hash with the plans it is about to run.
     ...(agent === 'pan-plan-checker' ? { plans_sha: require('./verify-plan-set.cjs').plansShaFor(cwd, phase) } : {}),
   });
-  appendRows(cwd, [...findingRows, ...newRows, ...resolveRows]);
+  // A pre-existing finding (M52) is in code the phase did not change: debt the milestone
+  // audit reads, never a blocker for this phase.
+  const deferRows = preExisting.map((id) => ({ v: LEDGER_V, kind: 'disposition', ts, id, disposition: 'deferred', reason: `pre-existing: in code phase ${phase} did not change; recorded as debt, not a blocker`, auto: true, verdict_id: verdictId }));
+  appendRows(cwd, [...findingRows, ...newRows, ...resolveRows, ...deferRows]);
 
   const category = { pass: 'verdict_passed', fail: 'verdict_failed', needs_human: 'verdict_needs_human' }[verdict.outcome];
   const serious = (bySeverity.critical || 0) + (bySeverity.high || 0) > 0;
@@ -338,7 +437,7 @@ function recordVerdict(cwd, input) {
     });
   }
 
-  return { ...base, recorded: true, duplicate: false, verdict_id: verdictId, attempt, phase, findings: ids.length, new: findingRows.length, rematched, resolved: resolveRows.length, unaddressed, reopened, ledger: planningRel(FINDINGS_FILE) };
+  return { ...base, recorded: true, duplicate: false, verdict_id: verdictId, attempt, phase, findings: ids.length, new: findingRows.length, rematched, resolved: resolveRows.length, unaddressed, reopened, suppressed, returned: returned.length, pre_existing: preExisting.length, ...(verdict.declined && verdict.declined.length ? { declined: verdict.declined } : {}), ledger: planningRel(FINDINGS_FILE) };
 }
 
 /**
@@ -373,7 +472,10 @@ function disposeFindings(cwd, input) {
     const f = fold.findings.get(id);
     if (!f) { skipped.push({ id, why: 'unknown id' }); continue; }
     if (f.status === as) { skipped.push({ id, why: `already ${as}` }); continue; }
-    out.push({ v: LEDGER_V, kind: 'disposition', ts, id, disposition: as, reason: reason || null, auto: false });
+    // A dismissal remembers its file as it was (R3): it suppresses the finding only
+    // until that file changes.
+    const fsha = as === 'dismissed' ? fileSha(cwd, f.where) : null;
+    out.push({ v: LEDGER_V, kind: 'disposition', ts, id, disposition: as, reason: reason || null, auto: false, ...(fsha ? { file_sha: fsha } : {}) });
     disposed.push(id);
   }
   appendRows(cwd, out);
@@ -408,6 +510,19 @@ function listFindings(cwd, filters = {}) {
   };
 }
 
+/** Learned suppressions (R3), each with its scope and whether its file is unchanged. */
+function listSuppressions(cwd, filters = {}) {
+  const fold = foldFindings(readLedger(cwd).rows);
+  let list = learnedSuppressions(cwd, fold);
+  if (filters.agent) list = list.filter((s) => s.f.agent === filters.agent);
+  if (filters.phase) list = list.filter((s) => s.scope === 'promoted' || samePhase(s.f.phase, filters.phase));
+  const suppressions = list.map((s) => ({
+    id: s.f.id, agent: s.f.agent, phase: s.f.phase, class: s.f.class, file: fileOf(s.f.where), summary: s.f.summary,
+    reason: s.f.reason, scope: s.scope, active: s.active,
+  }));
+  return { contract: V.VERDICT_CONTRACT, suppressions, active: suppressions.filter((s) => s.active).length };
+}
+
 /**
  * Tech debt for a milestone audit: deferred findings (with the reason recorded at
  * the time) and findings nobody disposed, grouped by phase.
@@ -470,6 +585,26 @@ function cmdFindingsList(cwd, opts, raw) {
   output(r, raw, String(r.counts.total));
 }
 
+function cmdFindingsSuppressions(cwd, opts, raw) {
+  const r = listSuppressions(cwd, opts);
+  output(r, raw, String(r.active));
+}
+
+/**
+ * `findings prove <id> --test <file>` (program R5): run the catching test at the phase's
+ * base and at HEAD, and record the proof. Exit 1 unless it confirms the finding.
+ */
+function cmdFindingsProve(cwd, opts, raw) {
+  if (!requirePlanningTree(cwd)) { output({ error: 'not_a_pan_project', reason: 'no .planning/ directory here' }, raw); return; }
+  const id = opts.id;
+  if (!id || !FINDING_ID_RE.test(id) || !opts.test) error('Usage: findings prove <f_id> --test <test-file> [--timeout <ms>]');
+  const f = foldFindings(readLedger(cwd).rows).findings.get(id);
+  if (!f) { output({ error: 'finding_not_found', id }, raw, 'error', 1); return; }
+  const p = require('./verify-red.cjs').proveFinding(cwd, f.phase, opts.test, { timeoutMs: opts.timeout ? Number(opts.timeout) : undefined });
+  appendRows(cwd, [{ v: LEDGER_V, kind: 'proof', ts: new Date().toISOString(), id, test: p.test, status: p.status }]);
+  output({ id, ...p, confidence: p.status === 'confirmed' ? 'confirmed' : 'candidate' }, raw, p.status, p.status === 'confirmed' ? 0 : 1);
+}
+
 function cmdFindingsDebt(cwd, opts, raw) {
   const r = findingsDebt(cwd, opts);
   output(r, raw, `${r.deferred_count} deferred, ${r.open_count} open`);
@@ -482,12 +617,15 @@ function findingIdsIn(args) {
 
 module.exports = {
   FINDINGS_FILE,
+  sameFinding,
+  cmdFindingsProve,
   STATUSES,
   readLedger,
   foldFindings,
   recordVerdict,
   disposeFindings,
   listFindings,
+  listSuppressions,
   findingsDebt,
   findingsChurn,
   sameFinding,
@@ -496,4 +634,5 @@ module.exports = {
   cmdFindingsDispose,
   cmdFindingsList,
   cmdFindingsDebt,
+  cmdFindingsSuppressions,
 };

package/pan-wizard-core/bin/lib/focus.cjs

@@ -608,7 +608,7 @@ function listBatchFiles(cwd) {
  *
  * Newest, not oldest. v2.10.0 (E-12) sorted ascending so "older unfinished batches
  * execute before newer ones", but nothing ever marks a batch finished, so it returned
- * the first batch a project planned, every time. `/pan:focus-exec` executes the newest
+ * the first batch a project planned, every time. `/pan:focus-auto --step exec` executes the newest
  * batch, so its `classify-stages` step was classifying a different batch from the one it
  * ran. A batch is a snapshot of the backlog: a newer plan already carries whatever an
  * older one left undone.

package/pan-wizard-core/bin/lib/git.cjs

@@ -175,7 +175,7 @@ function cmdGitPush(cwd, opts, raw) {
 function cmdGitStatus(cwd, opts, raw) {
   if (!isGitRepo(cwd)) { _notGitRepo(raw); return; }
   const branch = getCurrentBranch(cwd);
-  const r = execGit(cwd, ['status', '--porcelain']);
+  const r = execGit(cwd, ['status', '--porcelain'], { keepLeading: true });
   if (r.exitCode !== 0) {
     output({ error: 'status_failed', detail: r.stderr }, raw, 'status failed');
     return;

package/pan-wizard-core/bin/lib/hosts.cjs

@@ -0,0 +1,88 @@
+'use strict';
+/**
+ * One host table (program A0): how PAN runs each host CLI.
+ *
+ *   runner    the autonomous runner (experiments; the autodev launch builds on it):
+ *             `buildArgs(prompt, opts)` for a run that acts on its own, and `shell`
+ *             ('win32' launches the npm .cmd shim through a shell on Windows, where
+ *             spawnSync cannot resolve it). null: no adapter is written yet.
+ *   family    the model family the host runs by default; the cross-family review lane
+ *             (R4) exists to get a second opinion from a different one. Copilot and
+ *             OpenCode route to several vendors, so theirs names the router.
+ *   review    the cross-family review lane (R4): a read-only run, `promptVia` and
+ *             `args(prompt)`. No flag that writes or auto-approves tools: the reviewer
+ *             reads the change it is given and answers with a verdict block.
+ *   headless  the harness's model steps: `promptVia` ('stdin' | 'arg'), `args(prompt)`
+ *             for hosts whose JSON is not parsed yet, and `parse: true` for the one
+ *             whose output and usage PAN reads (Claude Code; its argv is built by the
+ *             harness with the step's options).
+ *
+ * runner.cjs and harness/src/model.cjs used to keep their own tables, and a host change
+ * had to be made twice. tests/hosts.test.cjs pins the argv both produce.
+ */
+
+const HOSTS = Object.freeze({
+  claude: Object.freeze({
+    bin: 'claude',
+    family: 'anthropic',
+    review: Object.freeze({ promptVia: 'stdin', args: () => ['-p', '--allowedTools', 'Read,Grep,Glob', '--output-format', 'text'] }),
+    runner: Object.freeze({
+      bin: 'claude',
+      buildArgs: (prompt, opts) => {
+        const args = ['-p', '--dangerously-skip-permissions'];
+        if (opts && opts.captureMetrics) args.push('--output-format', 'json');
+        args.push(prompt);
+        return args;
+      },
+      shell: 'win32',
+    }),
+    headless: Object.freeze({ bin: 'claude', promptVia: 'stdin', parse: true }),
+  }),
+  codex: Object.freeze({
+    bin: 'codex',
+    family: 'openai',
+    review: Object.freeze({ promptVia: 'stdin', args: () => ['exec', '--sandbox', 'read-only', '--skip-git-repo-check', '-'] }),
+    runner: Object.freeze({ bin: 'codex', buildArgs: (prompt) => ['exec', prompt], shell: 'win32' }),
+    // `codex exec -` reads the prompt from stdin; --json streams JSONL events.
+    headless: Object.freeze({ bin: 'codex', promptVia: 'stdin', args: () => ['exec', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', '-'] }),
+  }),
+  copilot: Object.freeze({
+    bin: 'copilot',
+    family: 'github',
+    // No --allow-all-tools: a non-interactive run is refused any tool it would ask about.
+    review: Object.freeze({ promptVia: 'arg', args: (p) => ['-p', p] }),
+    // No autonomous adapter yet: `copilot -p` exists, but nothing is written around it.
+    runner: null,
+    // `-p` takes the prompt as an argument; --output-format json is JSONL.
+    headless: Object.freeze({ bin: 'copilot', promptVia: 'arg', args: (p) => ['-p', p, '--output-format', 'json', '--allow-all-tools', '--allow-all-paths'] }),
+  }),
+  gemini: Object.freeze({
+    bin: 'gemini',
+    family: 'google',
+    // Headless `-p` appends standard input to its prompt; default approval refuses writes.
+    review: Object.freeze({ promptVia: 'stdin', args: () => ['-p', 'Review the change on standard input. Reply with the pan-verdict block only.'] }),
+    runner: Object.freeze({ bin: 'gemini', buildArgs: (prompt) => ['-p', '--yolo', prompt], shell: 'win32' }),
+    // `-p` runs headless; -o json; --approval-mode yolo auto-approves tools.
+    headless: Object.freeze({ bin: 'gemini', promptVia: 'arg', args: (p) => ['-p', p, '-o', 'json', '--approval-mode', 'yolo'] }),
+  }),
+  opencode: Object.freeze({
+    bin: 'opencode',
+    family: 'opencode',
+    review: Object.freeze({ promptVia: 'arg', args: (p) => ['run', p] }),
+    runner: Object.freeze({ bin: 'opencode', buildArgs: (prompt) => [prompt], shell: 'win32' }),
+    // `run <message..>` with --format json (raw JSON events).
+    headless: Object.freeze({ bin: 'opencode', promptVia: 'arg', args: (p) => ['run', '--format', 'json', p] }),
+  }),
+});
+
+/** The runner adapters by host, as runner.cjs exposes them (RUNTIME_RUNNERS). */
+function runnerTable() {
+  return Object.freeze(Object.fromEntries(Object.entries(HOSTS).map(([k, h]) => [k, h.runner])));
+}
+
+/** The headless model-step entries by host, as the harness exposes them (MODEL_RUNTIMES). */
+function headlessTable() {
+  return Object.fromEntries(Object.entries(HOSTS).map(([k, h]) => [k, h.headless]));
+}
+
+module.exports = { HOSTS, runnerTable, headlessTable };

package/pan-wizard-core/bin/lib/init.cjs

@@ -71,6 +71,11 @@ function attachPhaseArtifactPaths(result, cwd, phaseDirectory) {
     if (uatFile) {
       result.uat_path = toPosix(path.join(phaseDirectory, uatFile));
     }
+    // L6b: the user's corrections to /pan:assumptions, which discuss and plan read.
+    const assumptionsFile = files.find((f) => f.endsWith('-assumptions.md') || f === 'assumptions.md');
+    if (assumptionsFile) {
+      result.assumptions_path = toPosix(path.join(phaseDirectory, assumptionsFile));
+    }
   } catch {
     // Phase directory may not exist yet or may be unreadable
   }
@@ -150,6 +155,8 @@ function cmdInitExecutePhase(cwd, phase, raw, opts) {
     // Config flags
     commit_docs: config.commit_docs,
     parallelization: config.parallelization,
+    // A3: each pan-exec-waves executor in its own git worktree (Claude Code's Workflow tool).
+    worktree_isolation: (require('./test-gate.cjs').rawConfig(cwd).workflow || {}).worktree_isolation === true,
     branching_strategy: config.branching_strategy,
     phase_branch_template: config.phase_branch_template,
     milestone_branch_template: config.milestone_branch_template,
@@ -337,7 +344,6 @@ function cmdInitNewProject(cwd, raw) {
   const result = {
     // Models
     researcher_model: resolveModelInternal(cwd, 'pan-project-researcher'),
-    synthesizer_model: resolveModelInternal(cwd, 'pan-research-synthesizer'),
     roadmapper_model: resolveModelInternal(cwd, 'pan-roadmapper'),
 
     // Config
@@ -386,7 +392,6 @@ function cmdInitNewMilestone(cwd, raw) {
   const result = {
     // Models
     researcher_model: resolveModelInternal(cwd, 'pan-project-researcher'),
-    synthesizer_model: resolveModelInternal(cwd, 'pan-research-synthesizer'),
     roadmapper_model: resolveModelInternal(cwd, 'pan-roadmapper'),
 
     // Config

package/pan-wizard-core/bin/lib/knowledge.cjs

@@ -51,6 +51,8 @@ const CITATION_ROOTS = [
   '.planning/phases',
   '.planning/milestones',
   '.planning/memory',
+  // P5: resolved debug sessions are evidence a later question can cite.
+  '.planning/debug/resolved',
   'docs',
   'CHANGELOG.md',
   'README.md',

package/pan-wizard-core/bin/lib/merge.cjs

@@ -0,0 +1,50 @@
+'use strict';
+/**
+ * The human merge gate on the CLI (program L6a): what `/pan:army`'s release step uses.
+ *
+ * `merge request <branch> [--phase N] [--ci-green]` stages a merge through the same
+ * gate the MCP bridge uses (mcp/merge-gate.cjs). With `--phase`, verify_pass is the
+ * phase gate's verdict, not the caller's word. The approval token is never printed: it
+ * is for a person, not for the agent that staged the merge.
+ *
+ * `merge confirm <branch>` performs the squash-merge only in an interactive terminal,
+ * after the person types the branch name. An agent runs commands without a TTY, so it
+ * can stage a merge but never approve one. There is deliberately no environment
+ * variable or flag that skips the terminal check: anything an agent can set, an agent
+ * can set to approve itself.
+ */
+const readline = require('readline');
+const { output, error, execGit } = require('./core.cjs');
+const gate = require('../../mcp/merge-gate.cjs');
+
+function cmdMergeRequest(cwd, branch, opts, raw) {
+  if (!branch) error('Usage: merge request <branch> [--phase N] [--ci-green]');
+  let rec;
+  try {
+    rec = gate.requestMerge(cwd, { branch, phase: opts.phase, ci_green: !!opts.ciGreen, now: new Date().toISOString() });
+  } catch (e) { output({ error: 'invalid_branch', reason: e.message }, raw, 'error', 1); return; }
+  const { approval_token: _token, ...shown } = rec;
+  output({ ...shown, next: `A person runs, in their own terminal: pan-tools merge confirm ${rec.branch}` }, raw, rec.status);
+}
+
+function cmdMergeConfirm(cwd, branch, raw) {
+  if (!branch) error('Usage: merge confirm <branch>');
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    output({ error: 'human_terminal_required', reason: 'merge confirm runs only in an interactive terminal: an agent can stage a merge, a person approves it', branch }, raw, 'error', 1);
+    return;
+  }
+  let record;
+  try { record = JSON.parse(require('fs').readFileSync(require('path').join(gate.approvalsDir(cwd), `${gate.slugify(gate.validateBranch(branch))}.json`), 'utf8')); } catch { record = null; }
+  if (!record) { output({ error: 'no_merge_request', branch }, raw, 'error', 1); return; }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  rl.question(`Squash-merge ${record.branch} into the current branch? CI green: ${record.ci_green}, verified: ${record.verify_pass}. Type the branch name to approve: `, (answer) => {
+    rl.close();
+    if (answer.trim() !== record.branch) { output({ merged: false, reasons: ['not_confirmed'], branch: record.branch }, raw, 'not_confirmed', 1); return; }
+    const env = { ...process.env, PAN_MERGE_APPROVAL: record.approval_token };
+    const git = (argv) => { const r = execGit(cwd, argv); return { ok: r.exitCode === 0, stdout: r.stdout, stderr: r.stderr }; };
+    const r = gate.confirmMerge(cwd, { branch: record.branch }, env, git);
+    output(r, raw, r.merged ? 'merged' : 'refused', r.merged ? 0 : 1);
+  });
+}
+
+module.exports = { cmdMergeRequest, cmdMergeConfirm };