pan-wizard 3.35.0 → 3.37.0

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

@@ -168,6 +168,36 @@ function checkCheckpointTask(type, attrs, body, errors, warnings) {
   return { name: label, type, auto_select: autoMatch ? autoMatch[1] : null };
 }
 
+// The elements a plan nests. A file that ends with one of them still open was cut
+// off: runtimes cap tool output, and a long plan has been truncated mid-tag while
+// the write reported success (market-ideas M47; gsd-core v1.18.0).
+const PLAN_TAGS = ['tasks', 'task', 'name', 'files', 'action', 'verify', 'done'];
+const TRUNCATION_MARKER = /\[\s*\.{0,3}\s*(?:output\s+)?truncated\b|<!--\s*(?:continue|continued|truncated)\b|\(output truncated\)|\bcontinued in next (?:message|write)\b/i;
+
+/**
+ * Signs that a plan file was cut off. Pure; tags inside fenced code blocks do not count.
+ * @param {string} content - plan file content
+ * @returns {string[]} one message per problem, empty when the file is whole
+ */
+function detectPlanTruncation(content) {
+  const text = String(content || '').replace(/\r\n/g, '\n').replace(/^(`{3,}|~{3,})[^\n]*\n[\s\S]*?^\1[ \t]*$/gm, '');
+  const out = [];
+  const open = [];
+  const tagRe = new RegExp(`<(/?)(${PLAN_TAGS.join('|')})\\b[^>]*?(/?)>`, 'g');
+  let m;
+  while ((m = tagRe.exec(text)) !== null) {
+    const [, closing, tag, selfClosing] = m;
+    if (selfClosing) continue;
+    if (!closing) { open.push(tag); continue; }
+    const at = open.lastIndexOf(tag);
+    if (at >= 0) open.splice(at);
+  }
+  if (open.length) out.push(`Plan looks truncated: the file ends with ${open.map((t) => `<${t}>`).join(' > ')} still open`);
+  const marker = text.match(TRUNCATION_MARKER);
+  if (marker) out.push(`Plan looks truncated: it contains a continuation marker ("${marker[0].trim()}")`);
+  return out;
+}
+
 /**
  * Validate a plan.md structure: required frontmatter, task elements, and consistency.
  * @param {string} cwd - Working directory path
@@ -180,11 +210,19 @@ function cmdVerifyPlanStructure(cwd, filePath, raw) {
   const fullPath = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
   const content = safeReadFile(fullPath);
   if (!content) { output({ error: 'File not found', path: filePath }, raw); return; }
+  const r = planStructure(content);
+  output(r, raw, r.valid ? 'valid' : 'invalid');
+}
 
+/** A plan's structure check (cmdVerifyPlanStructure without the output). Pure. */
+function planStructure(content) {
   const fm = extractFrontmatter(content);
   const errors = [];
   const warnings = [];
 
+  // A cut-off plan first: its task count and fields would mislead (M47).
+  errors.push(...detectPlanTruncation(content));
+
   // Check required frontmatter fields
   const required = ['phase', 'plan', 'type', 'wave', 'depends_on', 'files_modified', 'autonomous', 'must_haves'];
   for (const field of required) {
@@ -246,14 +284,14 @@ function cmdVerifyPlanStructure(cwd, filePath, raw) {
     errors.push('Has checkpoint tasks but autonomous is not false');
   }
 
-  output({
+  return {
     valid: errors.length === 0,
     errors,
     warnings,
     task_count: tasks.length,
     tasks,
     frontmatter_fields: Object.keys(fm),
-  }, raw, errors.length === 0 ? 'valid' : 'invalid');
+  };
 }
 
 /**
@@ -572,8 +610,31 @@ function reconcilePhase(cwd, phaseNum) {
       contradictions.push(`verification status "${status}" but ${keyLinks.total - keyLinks.verified}/${keyLinks.total} key-link(s) UNWIRED`);
     }
   }
+  // The engine's test run (V2) is the record the verifier copies its test gate from: a
+  // verification that says otherwise, or passes over a failed run, contradicts it.
+  const testRun = require('./test-gate.cjs').readTestRun(cwd, phaseNum);
+  const writtenGate = (verRaw.match(/^test_gate:\s*([A-Za-z_]+)/m) || [])[1] || null;
+  if (testRun && testRun.status) {
+    const why = testRun.reason ? ` (${testRun.reason})` : '';
+    if (writtenGate && writtenGate.toLowerCase() !== testRun.status) {
+      contradictions.push(`verification test_gate "${writtenGate}" but the engine's test run recorded "${testRun.status}"${why}`);
+    } else if (!writtenGate && claimsPass && testRun.status === 'failed') {
+      contradictions.push(`verification status "${status}" but the engine's test run failed${why}`);
+    }
+  }
+  // V5G: in gate mode, a mutation score below the floor means the tests do not pin the
+  // code, so a passed verification is a contradiction until they do.
+  const mutFile = files.find((f) => /-mutation\.json$/.test(f));
+  if (claimsPass && mutFile) {
+    let mut = null;
+    try { mut = JSON.parse(safeReadFile(path.join(dir, mutFile)) || 'null'); } catch {}
+    if (mut && mut.mode === 'gate' && mut.gate && mut.gate.failed) {
+      contradictions.push(`verification status "${status}" but the mutation score ${mut.score} is below the floor ${mut.gate.floor} (workflow.mutation_gate: gate): ${mut.survived} of ${mut.sampled} mutants survived`);
+    }
+  }
   return {
     phase: String(phaseNum), found: true, verification_status: status, claims_pass: claimsPass,
+    test_run: testRun ? { status: testRun.status, head: testRun.head || null, regressions: (testRun.regressions || []).length } : undefined,
     mechanical_signals: signals, artifacts, key_links: keyLinks, contradictions,
     reconciled: contradictions.length === 0,
     note: signals === 0 ? 'no must_haves declared — mechanical reconciliation unavailable; verdict trusted' : undefined,
@@ -1460,9 +1521,13 @@ function cmdValidateHealth(cwd, options, raw) {
   }
 
   // Perform repairs if requested and there are repairable issues
+  // L6a: health asks per repair class. Without --repair the result lists the classes;
+  // --only limits a repair to the ones the user chose.
+  const only = Array.isArray(options.only) && options.only.length ? new Set(options.only) : null;
+  const chosen = only ? repairs.filter((r) => only.has(r)) : repairs;
   let repairActions = [];
-  if (options.repair && repairs.length > 0) {
-    repairActions = repairIssues(cwd, repairs);
+  if (options.repair && chosen.length > 0) {
+    repairActions = repairIssues(cwd, chosen);
   }
 
   // Check 10 (optional): full validation — run tests and build
@@ -1535,6 +1600,7 @@ function cmdValidateHealth(cwd, options, raw) {
     warnings,
     info,
     repairable_count: repairableCount,
+    repairs_available: repairs.length > 0 ? [...new Set(repairs)] : undefined,
     repairs_performed: repairActions.length > 0 ? repairActions : undefined,
   };
   if (options.full) {
@@ -1557,35 +1623,22 @@ function cmdValidateHealth(cwd, options, raw) {
 }
 
 /**
- * Run node --test and capture result.
+ * Run the project's tests through the engine's test gate (V2): any language, the
+ * project's own command, and a crash reads failed. `pass` is null when there was nothing
+ * to run (no test command, or one that ran no tests).
  */
 function runFullTestCheck(cwd) {
-  try {
-    const result = execFileSync('node', ['--test'], {
-      cwd,
-      timeout: 120000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      encoding: 'utf-8',
-    });
-    // Match both TAP ("# tests N") and spec-reporter ("ℹ tests N") summaries —
-    // modern node --test defaults to the spec reporter, which the old "# "-only
-    // regex silently missed (returning tests: null).
-    const testMatch = result.match(/[#ℹ]\s*tests\s+(\d+)/);
-    const passMatch = result.match(/[#ℹ]\s*pass\s+(\d+)/);
-    return {
-      pass: true,
-      exitCode: 0,
-      tests: testMatch ? parseInt(testMatch[1], 10) : null,
-      passing: passMatch ? parseInt(passMatch[1], 10) : null,
-    };
-  } catch (err) {
-    return {
-      pass: false,
-      exitCode: err.status || 1,
-      tests: null,
-      passing: null,
-    };
-  }
+  const rec = require('./test-gate.cjs').runTests(cwd, { timeoutMs: 120000 });
+  return {
+    pass: rec.status === 'passed' ? true : (rec.status === 'failed' ? false : null),
+    exitCode: rec.exit,
+    tests: rec.total,
+    passing: rec.passed,
+    status: rec.status,
+    command: rec.command,
+    reason: rec.reason || undefined,
+    failing: rec.failing && rec.failing.length ? rec.failing.slice(0, 20) : undefined,
+  };
 }
 
 /**
@@ -1623,8 +1676,10 @@ function runFullBuildCheck(cwd) {
 // ─── Deployment validation — extracted to verify-deploy.cjs (re-exported below)
 
 module.exports = {
+  planStructure,
   cmdVerifySummary,
   cmdVerifyPlanStructure,
+  detectPlanTruncation,
   cmdVerifyPhaseCompleteness,
   cmdVerifyReferences,
   cmdVerifyCommits,

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

@@ -208,7 +208,77 @@ function cmdWorktreeCleanup(cwd, raw, opts) {
   output(r, raw, lines.length ? lines.join('\n') : 'nothing to clean');
 }
 
+// ─── Shadow-merge preflight (program A3) ────────────────────────────────────
+// Branches that each pass the oracle can still break it together. Before merging a
+// sub-wave back, merge every branch onto the base in a throwaway worktree, in order,
+// and run the test command there. A conflict is named; a red result is bisected to
+// "each passes alone" (break_together) or the branches that fail on their own.
+
+const GIT_IDENTITY = ['-c', 'user.name=PAN preflight', '-c', 'user.email=preflight@pan.local', '-c', 'commit.gpgsign=false'];
+
+function runOracle(dir, test) {
+  const { spawnSync } = require('child_process');
+  const r = spawnSync(test, { cwd: dir, shell: true, encoding: 'utf8', timeout: 20 * 60 * 1000 });
+  return r.status === 0;
+}
+
+/**
+ * @param {string} cwd
+ * @param {{base?: string, branches: string[], test?: string}} opts
+ * @returns {{ok: boolean, verdict: 'clean'|'conflict'|'break_together'|'branch_fails'|'base_failing'|'no_test', ...}}
+ */
+function shadowMergePreflight(cwd, opts = {}) {
+  if (!isGitRepo(cwd)) return { error: 'not_git', reason: 'the preflight needs a git repository' };
+  const base = opts.base || 'HEAD';
+  const branches = (opts.branches || []).filter(Boolean);
+  let test = opts.test;
+  if (!test) {
+    try { test = require('./test-gate.cjs').detectTestCommand(cwd).command; } catch { test = null; }
+  }
+  if (!test) return { ok: false, verdict: 'no_test', base, branches, reason: 'no test command: pass --test or set one for the project' };
+  const os = require('os');
+  const fsx = require('fs');
+  const dir = fsx.mkdtempSync(path.join(os.tmpdir(), 'pan-preflight-'));
+  fsx.rmSync(dir, { recursive: true, force: true });
+  const add = execGit(cwd, ['worktree', 'add', '--detach', dir, base]);
+  if (add.exitCode !== 0) return { error: 'worktree_failed', reason: add.stderr.trim() };
+  const g = (args) => execGit(dir, [...GIT_IDENTITY, ...args]);
+  const result = { base, branches, test, merged: [], alone: {} };
+  try {
+    if (!runOracle(dir, test)) return { ...result, ok: false, verdict: 'base_failing', reason: 'the oracle already fails on the base: a merge cannot be judged' };
+    for (const b of branches) {
+      const m = g(['merge', '--no-ff', '--no-edit', b]);
+      if (m.exitCode !== 0) {
+        const files = g(['diff', '--name-only', '--diff-filter=U']).stdout.split('\n').map((x) => x.trim()).filter(Boolean);
+        g(['merge', '--abort']);
+        return { ...result, ok: false, verdict: 'conflict', conflict: { branch: b, files, after: [...result.merged] } };
+      }
+      result.merged.push(b);
+    }
+    if (runOracle(dir, test)) return { ...result, ok: true, verdict: 'clean' };
+    for (const b of branches) {
+      g(['reset', '--hard', '-q', base]);
+      result.alone[b] = g(['merge', '--no-ff', '--no-edit', b]).exitCode === 0 && runOracle(dir, test);
+    }
+    const failing = branches.filter((b) => !result.alone[b]);
+    return failing.length
+      ? { ...result, ok: false, verdict: 'branch_fails', failing }
+      : { ...result, ok: false, verdict: 'break_together', reason: 'each branch passes alone; merged together they fail' };
+  } finally {
+    execGit(cwd, ['worktree', 'remove', '--force', dir]);
+    try { fsx.rmSync(dir, { recursive: true, force: true }); } catch {}
+    execGit(cwd, ['worktree', 'prune']);
+  }
+}
+
+function cmdWorktreePreflight(cwd, opts, raw) {
+  const r = shadowMergePreflight(cwd, opts);
+  output(r, raw, r.verdict || r.error);
+}
+
 module.exports = {
+  shadowMergePreflight,
+  cmdWorktreePreflight,
   ARMY_BRANCH_PREFIX,
   createTaskWorktree,
   removeTaskWorktree,