pan-wizard 3.32.0 → 3.33.0

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

@@ -103,6 +103,102 @@ function buildConfigDefaults(hasBraveSearch, userDefaults) {
   };
 }
 
+// What PAN reads beyond the keys buildConfigDefaults writes (market-ideas M26). The
+// rest of the known set is derived from the defaults, so a new default is known the
+// day it is added. Each entry has a reader: loadConfig's flat aliases and alias
+// sections (`planning.*`, `git.*`), the stop guard (`mode`, `workflow.stop_guard`),
+// the roadmapper and new-project (`depth`), memory-optimize (`memory`), and the
+// workflows that config-get `workflow.auto_advance`. tests/config-keys in
+// tests/config.test.cjs pins this list against the keys shipped code and prose use.
+const CONFIG_KEYS_BEYOND_DEFAULTS = Object.freeze({
+  top: Object.freeze(['research', 'plan_checker', 'verifier', 'nyquist_validation', 'mode', 'depth', 'planning', 'git',
+    'focus', 'model_overrides', 'effort_overrides', 'cost', 'cache', 'build', 'verification', 'concurrency', 'memory']),
+  sections: Object.freeze({
+    workflow: Object.freeze(['auto_advance', 'stop_guard']),
+    planning: Object.freeze(['commit_docs', 'search_gitignored']),
+    git: Object.freeze(['branching_strategy', 'phase_branch_template', 'milestone_branch_template']),
+  }),
+});
+// Sections whose keys are the user's own (model ids, agent names, file lists,
+// commands), so nothing below them is checked.
+const OPEN_CONFIG_SECTIONS = Object.freeze(['focus', 'model_overrides', 'effort_overrides', 'cost', 'cache', 'build', 'verification', 'concurrency', 'memory']);
+
+/** The known top-level keys, and the known keys one level inside each closed section. */
+function knownConfigKeys() {
+  const defaults = buildConfigDefaults(false, {});
+  const top = new Set([...Object.keys(defaults), ...CONFIG_KEYS_BEYOND_DEFAULTS.top]);
+  const sections = new Map();
+  for (const [k, v] of Object.entries(defaults)) {
+    if (v && typeof v === 'object' && !Array.isArray(v)) sections.set(k, new Set(Object.keys(v)));
+  }
+  for (const [k, list] of Object.entries(CONFIG_KEYS_BEYOND_DEFAULTS.sections)) {
+    sections.set(k, new Set([...(sections.get(k) || []), ...list]));
+  }
+  for (const k of OPEN_CONFIG_SECTIONS) sections.delete(k);
+  return { top, sections };
+}
+
+/**
+ * Whether PAN reads a dot-notation key path: the top-level key is known, and inside a
+ * closed section so is the second segment. Deeper segments are not checked.
+ * @param {string} keyPath
+ * @returns {boolean}
+ */
+function isKnownConfigPath(keyPath) {
+  const [head, sub] = String(keyPath).split('.');
+  const { top, sections } = knownConfigKeys();
+  if (!top.has(head)) return false;
+  return sub === undefined || !sections.has(head) || sections.get(head).has(sub);
+}
+
+/**
+ * The key paths in a parsed config.json that PAN does not read (market-ideas M26):
+ * unknown top-level keys, and unknown keys one level inside a closed section.
+ * @param {Object} config
+ * @returns {string[]}
+ */
+function unknownConfigKeys(config) {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) return [];
+  const { top, sections } = knownConfigKeys();
+  const unknown = [];
+  for (const [k, v] of Object.entries(config)) {
+    if (!top.has(k)) { unknown.push(k); continue; }
+    const known = sections.get(k);
+    if (!known || !v || typeof v !== 'object' || Array.isArray(v)) continue;
+    for (const sub of Object.keys(v)) if (!known.has(sub)) unknown.push(`${k}.${sub}`);
+  }
+  return unknown;
+}
+
+/** The known key path nearest an unknown one (edit distance 2 or less), or null. */
+function nearestConfigKey(keyPath) {
+  const { top, sections } = knownConfigKeys();
+  const candidates = [...top];
+  for (const [k, subs] of sections) for (const s of subs) candidates.push(`${k}.${s}`);
+  const want = String(keyPath).split('.').slice(0, 2).join('.');
+  let best = null;
+  let bestD = 3;
+  for (const c of candidates) {
+    const d = editDistance(want, c);
+    if (d < bestD) { best = c; bestD = d; }
+  }
+  return best;
+}
+
+function editDistance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const tmp = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+      prev = tmp;
+    }
+  }
+  return row[b.length];
+}
+
 function cmdConfigEnsureSection(cwd, raw) {
   const configPath = path.join(planningPath(cwd), CONFIG_FILE);
 
@@ -216,6 +312,14 @@ function cmdConfigSet(cwd, keyPath, value, raw) {
   try {
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
     const result = { updated: true, key: keyPath, value: parsedValue };
+    // A key PAN does not read is still written (a newer PAN, or the user's own
+    // note, may want it), but never silently: a typo used to look like a setting
+    // that took effect (market-ideas M26).
+    if (!isKnownConfigPath(keyPath)) {
+      const near = nearestConfigKey(keyPath);
+      result.warning = `unknown config key "${keyPath}": PAN does not read it` + (near ? `; did you mean "${near}"?` : '');
+      process.stderr.write(`pan-tools: ${result.warning}\n`);
+    }
     output(result, raw, `${keyPath}=${parsedValue}`);
   } catch (err) {
     // Config file could not be written — disk full, permissions, etc.
@@ -664,6 +768,12 @@ function cmdStandardsTools(cwd, standardId, raw) {
 
 module.exports = {
   buildConfigDefaults,
+  CONFIG_KEYS_BEYOND_DEFAULTS,
+  OPEN_CONFIG_SECTIONS,
+  knownConfigKeys,
+  isKnownConfigPath,
+  unknownConfigKeys,
+  nearestConfigKey,
   cmdConfigEnsureSection,
   cmdConfigSet,
   cmdConfigGet,

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

@@ -207,16 +207,18 @@ const STANDARDS_CATALOG = {
     level: 'foundational',
     url: 'https://owasp.org/www-project-top-ten/',
     checklist: [
-      'A01: Broken Access Control — verify authorization checks on all endpoints',
-      'A02: Cryptographic Failures — verify sensitive data encryption at rest and in transit',
-      'A03: Injection — verify input validation and parameterized queries',
-      'A04: Insecure Design — verify threat modeling and secure design patterns',
-      'A05: Security Misconfiguration — verify default credentials removed, headers set',
-      'A06: Vulnerable Components — verify dependency scanning, no known CVEs',
+      // The 2025 list (top10.owasp.org): until 2026-10-03 this held the 2021 list
+      // under the 2025 name (prompt audit, market-ideas M34). SSRF is now part of A01.
+      'A01: Broken Access Control — verify authorization checks on all endpoints, and allowlists for server-side requests (SSRF)',
+      'A02: Security Misconfiguration — verify default credentials removed, headers set',
+      'A03: Software Supply Chain Failures — verify dependency scanning, no known CVEs, pinned and verified packages and build tooling',
+      'A04: Cryptographic Failures — verify sensitive data encryption at rest and in transit',
+      'A05: Injection — verify input validation and parameterized queries',
+      'A06: Insecure Design — verify threat modeling and secure design patterns',
       'A07: Authentication Failures — verify MFA support, session management, credential storage',
-      'A08: Software and Data Integrity — verify CI/CD pipeline integrity, signed updates',
-      'A09: Logging and Monitoring — verify security events logged, alerts configured',
-      'A10: SSRF — verify server-side request validation, allowlists',
+      'A08: Software or Data Integrity Failures — verify CI/CD pipeline integrity, signed updates',
+      'A09: Security Logging and Alerting Failures — verify security events logged, alerts configured',
+      'A10: Mishandling of Exceptional Conditions — verify errors fail closed, are handled, and release resources',
     ],
   },
   'owasp-asvs-l1': {

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

@@ -39,8 +39,13 @@ const { planningPath, planningRel } = require('./utils.cjs');
 // budget-profile project on Codex or OpenCode was told to spawn a model called
 // "mid" (reality check R28).
 //   - openai: Codex's subagent docs (learn.chatgpt.com/docs/agent-configuration/
-//     subagents, read 2026-09-23): "start with gpt-6-sol. Use gpt-6-luna when you
-//     want a faster, lower-cost option". gpt-6-astra is the flagship above both.
+//     subagents, re-read 2026-10-03) now start demanding agents on gpt-6.1-sol "when
+//     your signed-in account or workspace has access", and keep gpt-6-luna as the
+//     "faster, lower-cost option". The mid tier stays gpt-6-sol: GPT-6.1 Sol's launch
+//     keeps it off on Enterprise and Edu until an administrator enables it
+//     (learn.chatgpt.com/docs/models, read 2026-10-03), so pinning it would hand
+//     those users a model they cannot run. The inherit tier runs Codex's own
+//     default, which is gpt-6.1-sol where available. gpt-6-astra is the flagship.
 //   - google: the newest stable Flash and Flash-Lite on ai.google.dev's models page
 //     (read 2026-09-23). The 2.5 family these rows used is "not deprecated" but
 //     limited to users who have used it before, so a new project may not reach it.
@@ -58,12 +63,14 @@ const PROVIDER_MODELS = {
 // packages/web/src/content/docs/models.mdx and models.dev/api.json, both read
 // 2026-09-26; every id below exists there under that provider). Same tiers as
 // PROVIDER_MODELS, provider-qualified; `default` is Anthropic as it is there.
-// Reality check R41.
+// Reality check R41. The Anthropic mid tier follows the `sonnet` alias, which
+// resolves to Sonnet 5.5 on the Anthropic API from Claude Code 2.1.284;
+// models.dev lists `anthropic/claude-sonnet-5-5` (api.json, read 2026-10-03).
 const OPENCODE_MODELS = {
-  anthropic: { reasoning: 'inherit', mid: 'anthropic/claude-sonnet-5', fast: 'anthropic/claude-haiku-4-5' },
-  openai:    { reasoning: 'inherit', mid: 'openai/gpt-6-sol',          fast: 'openai/gpt-6-luna' },
-  google:    { reasoning: 'inherit', mid: 'google/gemini-3.8-flash',   fast: 'google/gemini-3.5-flash-lite' },
-  default:   { reasoning: 'inherit', mid: 'anthropic/claude-sonnet-5', fast: 'anthropic/claude-haiku-4-5' },
+  anthropic: { reasoning: 'inherit', mid: 'anthropic/claude-sonnet-5-5', fast: 'anthropic/claude-haiku-4-5' },
+  openai:    { reasoning: 'inherit', mid: 'openai/gpt-6-sol',            fast: 'openai/gpt-6-luna' },
+  google:    { reasoning: 'inherit', mid: 'google/gemini-3.8-flash',     fast: 'google/gemini-3.5-flash-lite' },
+  default:   { reasoning: 'inherit', mid: 'anthropic/claude-sonnet-5-5', fast: 'anthropic/claude-haiku-4-5' },
 };
 
 /**
@@ -552,6 +559,18 @@ function escapeRegex(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+/**
+ * Make free text safe for one markdown table cell: escape backslashes and pipes,
+ * and fold every run of line breaks into one space. A raw `|` splits the row into
+ * an extra column, and state.md's tables are appended to for the life of a
+ * project, so one bad row breaks every later read of the table (market-ideas M21).
+ * @param {*} value - Cell text; null and undefined become ''
+ * @returns {string}
+ */
+function escapeTableCell(value) {
+  return String(value ?? '').replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/[\r\n]+/g, ' ');
+}
+
 /**
  * Normalize a phase identifier to zero-padded format.
  * Examples: "1" → "01", "3A" → "03A", "12.1" → "12.1"
@@ -1454,6 +1473,7 @@ module.exports = {
   isGitRepo,
   execGit,
   escapeRegex,
+  escapeTableCell,
   normalizePhaseName,
   comparePhaseNum,
   searchPhaseInDir,

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

@@ -91,6 +91,12 @@ const DEFAULT_RATES = {
   // 2026-08-31 was made permanent and the scheduled rise to $3/$15 cancelled.
   // Lesson: never write down a pre-announced price — this row carried the future
   // rate for a month and over-billed by half.
+  // Sonnet 5.5 (claude-sonnet-5-5): the same prices as Sonnet 5 — $2/$10, 5-minute
+  // writes $2.50, 1-hour $4, hits $0.20 (pricing page, read 2026-10-03). Claude Code
+  // 2.1.284 points the `sonnet` alias at it on the Anthropic API (model-config, read
+  // 2026-10-03). The family prefix already priced it at Sonnet 5's identical row; its
+  // own row means a later price change to either model cannot misprice the other.
+  'claude-sonnet-5-5':  { input: 2.0,  output: 10.0, cache_read: 0.20, cache_write: 2.50, cache_write_1h: 4.0 },
   'claude-sonnet-5':    { input: 2.0,  output: 10.0, cache_read: 0.20, cache_write: 2.50, cache_write_1h: 4.0 },
   'claude-sonnet-4-6':  { input: 3.0,  output: 15.0, cache_read: 0.3,  cache_write: 3.75, cache_write_1h: 6.0 },
   // Sonnet 4.5 (dated id claude-sonnet-4-5-20250929): $3/$15/$0.30/$3.75 (R7).
@@ -105,10 +111,14 @@ const DEFAULT_RATES = {
   // as plain input. Until 2026-09-22 this block said "no separate write charge" for
   // every row, which had stopped being true — Terra and Luna writes were a fifth
   // low (R27). Longest-prefix match lets each tier key win over a shorter one.
-  // GPT-6: Astra is the flagship; Sol and Luna were released 2026-09-22. Codex's
-  // config docs use gpt-6-sol as the default model and gpt-6-luna for lower-cost
-  // subagents (learn.chatgpt.com/docs/config-file/config-basic, /agent-configuration/subagents).
+  // GPT-6: Astra is the flagship; Sol and Luna were released 2026-09-22. GPT-6.1 Sol
+  // is Codex's default model from 0.159.1 (2026-09-29): `model = "gpt-6.1-sol"` in
+  // config-basic, and the subagent docs' starting model for demanding agents, with
+  // gpt-6-luna for lower-cost ones (learn.chatgpt.com/docs/config-file/config-basic,
+  // /agent-configuration/subagents, both read 2026-10-03). Its row was read from the
+  // pricing page on 2026-10-03: GPT-6 Sol's prices, except cached input at 0.05×.
   'gpt-6-astra':        { input: 10.0, output: 50.0, cache_read: 1.0,  cache_write: 12.5 },
+  'gpt-6.1-sol':        { input: 2.0,  output: 10.0, cache_read: 0.1,  cache_write: 2.5 },
   'gpt-6-sol':          { input: 2.0,  output: 10.0, cache_read: 0.2,  cache_write: 2.5 },
   'gpt-6-luna':         { input: 0.10, output: 0.50, cache_read: 0.01, cache_write: 0.125 },
   // GPT-5.6. The bare `gpt-5.6` id is an alias that "routes requests to GPT-5.6 Sol"

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

@@ -160,7 +160,10 @@ function recordVerdict(cwd, input) {
 
   const { rows } = readLedger(cwd);
   const fold = foldFindings(rows);
-  const base = { contract: V.VERDICT_CONTRACT, agent, verdict: verdict.verdict, outcome: verdict.outcome, source_kind: parsed.source_kind, warnings: parsed.warnings };
+  // `not_checked` (M23): what the judge could not run. A pass with entries here is a
+  // pass over less than the whole phase, and the record says so.
+  const notChecked = verdict.not_checked || [];
+  const base = { contract: V.VERDICT_CONTRACT, agent, verdict: verdict.verdict, outcome: verdict.outcome, not_checked: notChecked, source_kind: parsed.source_kind, warnings: parsed.warnings };
 
   const dup = fold.verdicts.find((r) => r.record_sig === recordSig && r.agent === agent && samePhase(r.phase, phase));
   if (dup) {
@@ -204,6 +207,7 @@ function recordVerdict(cwd, input) {
     v: LEDGER_V, kind: 'verdict', ts, verdict_id: verdictId, record_sig: recordSig, phase, milestone, agent,
     verdict: verdict.verdict, outcome: verdict.outcome, attempt, source, finding_ids: ids,
     by_severity: bySeverity, by_class: byClass, warnings: parsed.warnings,
+    ...(notChecked.length ? { not_checked: notChecked } : {}),
   });
   appendRows(cwd, [...findingRows, ...newRows, ...autoFixRows]);
 
@@ -216,7 +220,7 @@ function recordVerdict(cwd, input) {
     phase,
     description: `${agent} ${verdict.verdict || verdict.outcome} on phase ${phase} (attempt ${attempt}, ${ids.length} finding${ids.length === 1 ? '' : 's'})`,
     impact: verdict.outcome === 'fail' ? (serious ? 'major' : 'minor') : 'minor',
-    context: { agent, phase, verdict: verdict.verdict, attempt, findings: ids.length, by_severity: bySeverity, by_class: byClass, verdict_id: verdictId },
+    context: { agent, phase, verdict: verdict.verdict, attempt, findings: ids.length, by_severity: bySeverity, by_class: byClass, verdict_id: verdictId, not_checked: notChecked.map((n) => n.check) },
   });
   if (previous && previous.outcome === 'fail') {
     traceEvent(cwd, {

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

@@ -4,7 +4,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { loadConfig, resolveModelInternal, findPhaseInternal, getRoadmapPhaseInternal, pathExistsInternal, generateSlugInternal, getMilestoneInfo, normalizePhaseName, toPosix, output, error, scanPendingTodos, isGitRepo, execGit } = require('./core.cjs');
+const { loadConfig, resolveModelInternal, findPhaseInternal, getRoadmapPhaseInternal, pathExistsInternal, generateSlugInternal, getMilestoneInfo, normalizePhaseName, toPosix, output, error, scanPendingTodos, isGitRepo, execGit, escapeTableCell } = require('./core.cjs');
 const { PHASES_DIR, CODEBASE_DIR, QUICK_DIR, MILESTONES_DIR, STATE_FILE, ROADMAP_FILE, CONFIG_FILE, PROJECT_FILE, REQUIREMENTS_FILE, isPlanFile, isSummaryFile, isResearchFile, isContextFile, isVerificationFile, PLAN_SUFFIX, SUMMARY_SUFFIX, CONTEXT_SUFFIX, RESEARCH_SUFFIX, VERIFICATION_SUFFIX, UAT_SUFFIX, MAX_SLUG_LENGTH } = require('./constants.cjs');
 const { planningPath, phasesPath, filterPlanFiles, filterSummaryFiles, classifyPhaseStatus, hasBraveSearchKey, parsePhaseDir, planningRel } = require('./utils.cjs');
 const { classifyPlanTier } = require('./phase.cjs');
@@ -445,6 +445,10 @@ function cmdInitQuick(cwd, description, raw) {
     next_num: nextNum,
     slug: slug,
     description: description || null,
+    // The description as one markdown table cell (pipes escaped, line breaks
+    // folded). The workflow writes this, never the raw text, into state.md's
+    // "Quick Tasks Completed" table, where a raw `|` would break the table.
+    description_cell: description ? escapeTableCell(description) : null,
 
     // Timestamps
     date: now.toISOString().split('T')[0],

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

@@ -239,7 +239,7 @@ function cmdFindPhase(cwd, phase, raw) {
  * @param {boolean} raw - If true, output raw value instead of JSON
  * @returns {void}
  */
-function cmdPhasePlanIndex(cwd, phase, raw) {
+function cmdPhasePlanIndex(cwd, phase, raw, opts = {}) {
   if (!phase) {
     error('phase required for phase-plan-index');
   }
@@ -280,7 +280,52 @@ function cmdPhasePlanIndex(cwd, phase, raw) {
 
   const { plans, waves, incomplete, hasCheckpoints } = buildPlanIndex(phaseDir, planFiles, summaryFiles);
 
-  output({ phase: normalized, plans, waves, incomplete, has_checkpoints: hasCheckpoints }, raw);
+  const result = { phase: normalized, plans, waves, incomplete, has_checkpoints: hasCheckpoints };
+  // `--failed <ids>` (market-ideas M28): the plans that must not run after those
+  // failed, because a dependency, direct or transitive, is among them.
+  if (opts.failed) {
+    const failed = String(opts.failed).split(',').map((s) => s.trim()).filter(Boolean);
+    result.failed = failed;
+    result.blocked = blockedPlans(plans, failed);
+  }
+  output(result, raw);
+}
+
+/** Whether a `depends_on` entry names this plan: its full id ("03-02") or its plan number ("02", "2"). */
+function dependencyNames(dep, planId) {
+  const d = String(dep).trim();
+  if (d === planId) return true;
+  const own = planId.split('-').pop();
+  const strip = (s) => s.replace(/^0+(?=\d)/, '');
+  return /^\d+$/.test(d) && /^\d+$/.test(own) && strip(d) === strip(own);
+}
+
+/**
+ * The plans that must not run because a plan they depend on failed (market-ideas
+ * M28). Transitive: a plan waiting on a blocked plan is blocked too. Plans that
+ * already have a summary are done and never blocked.
+ * @param {Array<{id: string, depends_on: string[], has_summary: boolean}>} plans
+ * @param {string[]} failedIds
+ * @returns {Array<{id: string, blocked_by: string[]}>} in plan order; blocked_by names the failed plans
+ */
+function blockedPlans(plans, failedIds) {
+  const failed = new Set(failedIds);
+  const blockedBy = new Map(); // plan id → Set of failed ids behind it
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const p of plans) {
+      if (p.has_summary || failed.has(p.id)) continue;
+      const roots = blockedBy.get(p.id) || new Set();
+      const before = roots.size;
+      for (const dep of p.depends_on || []) {
+        for (const f of failed) if (dependencyNames(dep, f)) roots.add(f);
+        for (const [b, bRoots] of blockedBy) if (dependencyNames(dep, b)) for (const r of bRoots) roots.add(r);
+      }
+      if (roots.size > before) { blockedBy.set(p.id, roots); changed = true; }
+    }
+  }
+  return plans.filter((p) => blockedBy.has(p.id)).map((p) => ({ id: p.id, blocked_by: [...blockedBy.get(p.id)].sort() }));
 }
 
 /**
@@ -339,10 +384,14 @@ function buildPlanIndex(phaseDir, planFiles, summaryFiles) {
     const hasSummary = completedPlanIds.has(planId);
     if (!hasSummary) incomplete.push(planId);
 
+    const rawDeps = frontmatter.depends_on || frontmatter['depends-on'];
+    const dependsOn = (Array.isArray(rawDeps) ? rawDeps : (rawDeps ? [rawDeps] : [])).map(String).filter((d) => d.trim());
+
     plans.push({
       id: planId, wave, autonomous,
       objective,
       files_modified: filesModified,
+      depends_on: dependsOn,
       task_count: taskCount,
       has_summary: hasSummary,
     });
@@ -930,6 +979,7 @@ module.exports = {
   cmdPhaseNextDecimal,
   cmdFindPhase,
   cmdPhasePlanIndex,
+  blockedPlans,
   cmdPhaseAdd,
   cmdPhaseInsert,
   cmdPhaseRemove,

package/pan-wizard-core/bin/lib/review-deep.cjs

@@ -19,7 +19,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { output, error, safeReadFile, toPosix } = require('./core.cjs');
+const { output, error, safeReadFile, toPosix, escapeTableCell } = require('./core.cjs');
 const { planningPath } = require('./utils.cjs');
 const { publish } = require('./bus.cjs');
 const { findVerdictBlocks, validateVerdict } = require('./verdict.cjs');
@@ -235,7 +235,7 @@ function writeDeepReview(cwd, phaseNum, payload, opts) {
       const loc = f.file ? `\`${f.file}${f.line ? `:${f.line}` : ''}\`` : '—';
       // Neutralize markdown-table-breaking chars: escape pipes and flatten any
       // newlines so a finding description can't corrupt the table structure.
-      const desc = String(f.description).replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/[\r\n]+/g, ' ');
+      const desc = escapeTableCell(f.description);
       lines.push(`| ${f.severity} | ${f.source} | ${f.category} | ${desc} | ${loc} |`);
     }
     lines.push('');

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

@@ -4,7 +4,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { loadConfig, getMilestoneInfo, escapeRegex, safeReadFile, output, error } = require('./core.cjs');
+const { loadConfig, getMilestoneInfo, escapeRegex, escapeTableCell, safeReadFile, output, error } = require('./core.cjs');
 const { extractFrontmatter, reconstructFrontmatter } = require('./frontmatter.cjs');
 const { withFileLock, writeFileAtomic } = require('./lock.cjs');
 const {
@@ -300,7 +300,8 @@ function cmdStateRecordMetric(cwd, options, raw) {
 
   if (metricsMatch) {
     let tableBody = metricsMatch[2].trimEnd();
-    const newRow = `| Phase ${phase} P${plan} | ${duration} | ${tasks || '-'} tasks | ${files || '-'} files |`;
+    const cell = escapeTableCell;
+    const newRow = `| Phase ${cell(phase)} P${cell(plan)} | ${cell(duration)} | ${cell(tasks || '-')} tasks | ${cell(files || '-')} files |`;
 
     if (tableBody.trim() === '' || tableBody.includes('None yet')) {
       tableBody = newRow;

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

@@ -40,7 +40,9 @@ const KNOWN_VERDICTS = Object.freeze({
   'pan-design-checker': Object.freeze({ PASS: 'pass', GAPS: 'fail' }),
 });
 
-const LIMITS = Object.freeze({ findings: 100, where: 200, summary: 300, verdict: 40, score: 40 });
+const LIMITS = Object.freeze({ findings: 100, where: 200, summary: 300, verdict: 40, score: 40, not_checked: 20, check: 80 });
+// What the verifier's test gate can report (verify-phase.md, run_test_suite).
+const TEST_GATE_VALUES = Object.freeze(['passed', 'failed', 'skipped']);
 const AGENT_RE = /^[a-z][a-z0-9-]{0,63}$/;
 const OPEN_FENCE_RE = /^[ \t]*(`{3,}|~{3,})[ \t]*pan-verdict[ \t]*$/;
 const CLOSE_FENCE_RE = /^[ \t]*(`{3,}|~{3,})[ \t]*$/;
@@ -195,7 +197,32 @@ function validateVerdict(obj, opts = {}) {
     findings.push({ class: cls, severity, where, summary });
   });
 
-  return { ok: true, verdict: { contract, agent, outcome, verdict, phase, score, findings }, warnings };
+  const notChecked = normaliseNotChecked(obj.not_checked, warnings);
+  return { ok: true, verdict: { contract, agent, outcome, verdict, phase, score, findings, not_checked: notChecked }, warnings };
+}
+
+/**
+ * The checks a judge could not run, each `{check, reason}` (market-ideas M23).
+ * A verdict that carries them says what it did not see: a `pass` with tests that
+ * never ran is recorded as exactly that, never as a plain pass. Accepts bare
+ * strings as checks with no reason; drops entries with no check.
+ */
+function normaliseNotChecked(value, warnings) {
+  if (value == null) return [];
+  if (!Array.isArray(value)) {
+    warnings.push('not_checked_not_an_array');
+    return [];
+  }
+  const out = [];
+  for (const entry of value.slice(0, LIMITS.not_checked)) {
+    const obj = typeof entry === 'string' ? { check: entry } : (entry && typeof entry === 'object' && !Array.isArray(entry) ? entry : null);
+    const check = obj ? truncate(cleanText(obj.check ?? obj.gate ?? ''), LIMITS.check) : '';
+    if (!check) continue;
+    const reason = obj.reason == null || cleanText(obj.reason) === '' ? null : truncate(cleanText(obj.reason), LIMITS.summary);
+    out.push({ check, reason });
+  }
+  if (value.length > LIMITS.not_checked) warnings.push(`not_checked_truncated: ${value.length} reported, ${LIMITS.not_checked} kept`);
+  return out;
 }
 
 // ─── verification.md frontmatter adapter ─────────────────────────────────────
@@ -354,7 +381,23 @@ function verdictFromVerificationFrontmatter(text, agent = 'pan-verifier') {
     const summary = what || (path ? `unrequested change to ${path}` : '');
     if (summary) findings.push({ class: 'unrequested', severity: 'low', where: path, summary });
   }
-  return { contract: VERDICT_CONTRACT, agent, verdict: status, outcome, findings };
+  // The test gate (M23). `not_checked` lists what the verifier could not run; a
+  // `test_gate: skipped` with no tests entry there still counts as one, so a model
+  // that records the gate but forgets the list cannot turn it into a plain pass.
+  let notChecked = listOfMappings(yaml, 'not_checked').map((n) => ({ check: n.check || n.gate || '', reason: n.reason || null }));
+  const testGateRaw = frontmatterScalar(yaml, 'test_gate');
+  const testGate = testGateRaw ? String(testGateRaw).toLowerCase() : null;
+  const isTests = (n) => /test/i.test(String(n.check));
+  let contradicted = false;
+  if (testGate === 'skipped' && !notChecked.some(isTests)) {
+    notChecked.push({ check: 'tests', reason: frontmatterScalar(yaml, 'test_gate_reason') || 'the test gate was skipped' });
+  } else if ((testGate === 'passed' || testGate === 'failed') && notChecked.some(isTests)) {
+    // The gate ran, so a `tests` entry is the template's example copied over: the
+    // recorded gate is the measurement, and the entry goes.
+    notChecked = notChecked.filter((n) => !isTests(n));
+    contradicted = true;
+  }
+  return { contract: VERDICT_CONTRACT, agent, verdict: status, outcome, findings, not_checked: notChecked, test_gate: testGate, not_checked_contradicted: contradicted };
 }
 
 /**
@@ -383,7 +426,14 @@ function parseVerdictText(text, opts = {}) {
       return { ok: false, error: 'unknown_status', reason: `verification status "${adapted.verdict}" is not passed, gaps_found or human_needed` };
     }
     const r = validateVerdict(adapted, opts);
-    return r.ok ? { ...r, source_kind: 'frontmatter' } : r;
+    if (!r.ok) return r;
+    // Say when the verification does not record its test gate, or records a failed
+    // gate under a pass: both make "passed" claim more than the verifier checked.
+    if (!adapted.test_gate) r.warnings.push('test_gate_unrecorded: the verification does not say whether the test suite ran');
+    else if (!TEST_GATE_VALUES.includes(adapted.test_gate)) r.warnings.push(`test_gate_unknown: "${adapted.test_gate}" is not passed, failed or skipped`);
+    else if (adapted.test_gate === 'failed' && adapted.outcome === 'pass') r.warnings.push('test_gate_failed_under_pass: the test gate failed but the status is passed');
+    if (adapted.not_checked_contradicted) r.warnings.push(`not_checked_contradicted: test_gate is ${adapted.test_gate}, so the not_checked tests entry was dropped`);
+    return { ...r, source_kind: 'frontmatter' };
   }
   return { ok: false, error: 'no_verdict', reason: 'no pan-verdict block and no verification frontmatter status' };
 }

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

@@ -13,14 +13,24 @@ const {
 const { planningPath } = require('./utils.cjs');
 
 /**
- * Parse convention rules from CONVENTIONS.md markdown content.
+ * The codebase map's conventions document. map-codebase writes `conventions.md`;
+ * a map from an older PAN, or one written by hand, may be `CONVENTIONS.md`. Only a
+ * case-sensitive filesystem tells the two apart, which is why reading the uppercase
+ * name alone found nothing on Linux (prompt audit, market-ideas M34).
+ */
+function readConventions(cwd) {
+  const dir = path.join(planningPath(cwd), 'codebase');
+  return safeReadFile(path.join(dir, 'conventions.md')) || safeReadFile(path.join(dir, 'CONVENTIONS.md'));
+}
+
+/**
+ * Parse convention rules from the conventions document's markdown content.
  * Extracts anti-pattern rules from prose containing "instead of", "not", "never".
  * Run drift check internally and return result object (no output).
  * Used by cmdValidateHealth --drift.
  */
 function runDriftCheck(cwd) {
-  const conventionsPath = path.join(planningPath(cwd), 'codebase', 'CONVENTIONS.md');
-  const conventionsContent = safeReadFile(conventionsPath);
+  const conventionsContent = readConventions(cwd);
   const claudeMdContent = safeReadFile(path.join(cwd, 'CLAUDE.md'));
   const combined = [conventionsContent, claudeMdContent].filter(Boolean).join('\n');
   const rules = parseConventionRules(combined || null);
@@ -198,8 +208,7 @@ function cmdDriftCheck(cwd, raw, args) {
   }
 
   // Load convention rules
-  const conventionsPath = path.join(planningPath(cwd), 'codebase', 'CONVENTIONS.md');
-  const conventionsContent = safeReadFile(conventionsPath);
+  const conventionsContent = readConventions(cwd);
   const claudeMdContent = safeReadFile(path.join(cwd, 'CLAUDE.md'));
   const combined = [conventionsContent, claudeMdContent].filter(Boolean).join('\n');
   const rules = parseConventionRules(combined || null);

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

@@ -18,7 +18,7 @@ const fs = require('fs');
 const path = require('path');
 const { safeReadFile, execGit, findPhaseInternal, toPosix, output, escapeRegex } = require('./core.cjs');
 const { extractFrontmatter } = require('./frontmatter.cjs');
-const { isPlanFile, isSummaryFile } = require('./constants.cjs');
+const { isPlanFile, isSummaryFile, isVerificationFile } = require('./constants.cjs');
 const { planningRel } = require('./utils.cjs');
 
 const LOCKFILES = new Set([
@@ -153,4 +153,71 @@ function cmdVerifyScope(cwd, phase, raw) {
   output(r, raw, r.error ? undefined : String(r.candidates.length));
 }
 
-module.exports = { scopePhase, cmdVerifyScope, LOCKFILES };
+// ─── Stale verification (market-ideas M27) ───────────────────────────────────
+// A verification describes the code at one commit. Until 2026-10-03 nothing tied it
+// to that commit, so a phase edited after it passed still read as verified. The
+// verifier now records `verified_commit`; any file the phase covers that changed
+// since then, committed or not, makes the verification stale.
+
+const SHA_RE = /^[0-9a-f]{7,40}$/i;
+
+/**
+ * The files a phase's verification covered: the plans' declared `files_modified` and
+ * the summaries' `key-files`, minus the planning tree, lockfiles and PAN's runtime
+ * directories. No git log scan, so `progress` can afford it for every phase.
+ */
+function coveredFiles(cwd, info) {
+  const dir = path.join(cwd, info.directory);
+  const files = new Set();
+  for (const f of info.plans.filter(isPlanFile)) {
+    const fm = extractFrontmatter(safeReadFile(path.join(dir, f)) || '');
+    for (const p of asList(fm.files_modified || fm['files-modified'])) files.add(normalisePath(p));
+  }
+  for (const f of info.summaries.filter(isSummaryFile)) {
+    const fm = extractFrontmatter(safeReadFile(path.join(dir, f)) || '');
+    const kf = fm['key-files'] || fm.key_files || {};
+    for (const p of [...asList(kf.created), ...asList(kf.modified)]) files.add(normalisePath(p));
+  }
+  const planningPrefix = normalisePath(planningRel());
+  return [...files].filter((f) => f && !exclusionReason(f, planningPrefix)).sort();
+}
+
+/**
+ * Whether a phase's verification still describes the code.
+ * @param {string} cwd
+ * @param {string} phase
+ * @param {Object} [info] - findPhaseInternal's result, when the caller already has it
+ * @returns {Object} `{phase, state, verified_commit, verification, changed_since, reason?}` or `{error, reason}`.
+ *   state: `fresh` · `stale` (covered files changed since the verified commit) ·
+ *   `unverified` (no verification file) · `unknown` (no usable verified_commit, or no git)
+ */
+function verificationFreshness(cwd, phase, info) {
+  info = info || findPhaseInternal(cwd, phase);
+  if (!info) return { error: 'phase_not_found', reason: `no phase directory for phase ${phase}` };
+  const dir = path.join(cwd, info.directory);
+  let names = [];
+  try { names = fs.readdirSync(dir); } catch { /* unreadable: no verification */ }
+  const verification = names.filter(isVerificationFile).sort().pop() || null;
+  const base = { phase: info.phase_number, state: 'unverified', verified_commit: null, verification: verification ? toPosix(path.join(info.directory, verification)) : null, changed_since: [] };
+  if (!verification) return base;
+  const fm = extractFrontmatter(safeReadFile(path.join(dir, verification)) || '');
+  const sha = String(fm.verified_commit || '').trim();
+  if (!SHA_RE.test(sha)) return { ...base, state: 'unknown', reason: 'the verification records no verified_commit' };
+  const known = execGit(cwd, ['cat-file', '-e', `${sha}^{commit}`]);
+  if (known.exitCode !== 0) return { ...base, state: 'unknown', verified_commit: sha, reason: 'the verified commit is not in this repository (rebased, squashed, or no git)' };
+  const covered = coveredFiles(cwd, info);
+  if (!covered.length) return { ...base, state: 'unknown', verified_commit: sha, reason: 'the phase declares no files to compare' };
+  // Against the working tree, not HEAD: an uncommitted edit makes the pass stale too.
+  const diff = execGit(cwd, ['-c', 'core.quotepath=off', 'diff', '--name-only', '--relative', sha, '--', ...covered]);
+  if (diff.exitCode !== 0) return { ...base, state: 'unknown', verified_commit: sha, reason: 'git diff failed' };
+  const changed = diff.stdout.split('\n').map(normalisePath).filter(Boolean).sort();
+  return { ...base, state: changed.length ? 'stale' : 'fresh', verified_commit: sha, changed_since: changed };
+}
+
+function cmdVerifyStale(cwd, phase, raw) {
+  if (!phase) { output({ error: 'phase_required', reason: 'Usage: verify stale <phase>' }, raw); return; }
+  const r = verificationFreshness(cwd, phase);
+  output(r, raw, r.error ? undefined : r.state);
+}
+
+module.exports = { scopePhase, cmdVerifyScope, verificationFreshness, cmdVerifyStale, coveredFiles, LOCKFILES };