pan-wizard 3.33.0 → 3.34.0

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

@@ -55,6 +55,12 @@ const TOKENS_FILE = 'tokens.jsonl';
  * write at `cache_write` (market-ideas queue M13). OpenAI and Google report no
  * lifetime split, so their rows carry none.
  */
+// The prompt size above which a long-prompt rate applies (Haiku 5.5's tier). The
+// cost-logger hook and `cost rebuild` record the tokens of every request over it as a
+// row's `long_prompt`, with this figure as its `above`; hooks/pan-cost-logger.js keeps
+// its own copy (hooks require nothing from lib), and a test pins the two equal.
+const LONG_PROMPT_THRESHOLD = 100000;
+
 const DEFAULT_RATES = {
   // Anthropic — platform.claude.com/docs/en/about-claude/pricing, every row read
   // 2026-09-23. Opus 4.6+/Opus 5 are $5/$25 (the old $15/$75 Opus pricing ended with
@@ -91,16 +97,24 @@ 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 },
+  // Sonnet 5.5 (claude-sonnet-5-5): $2/$10, 5-minute writes $2.50, 1-hour $4, and
+  // hits at 0.05x input, $0.10 (pricing page, read 2026-10-10; Claude Code 2.1.296
+  // corrected its own figure from $0.20 the same week). Claude Code 2.1.284 points the
+  // `sonnet` alias at it on the Anthropic API (model-config, read 2026-10-03). Its own
+  // row is what keeps it off Sonnet 5's $0.20 hits through the family prefix.
+  'claude-sonnet-5-5':  { input: 2.0,  output: 10.0, cache_read: 0.10, 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).
   'claude-sonnet-4-5':  { input: 3.0,  output: 15.0, cache_read: 0.3,  cache_write: 3.75, cache_write_1h: 6.0 },
+  // Haiku 5.5 (claude-haiku-5-5): $0.10/$0.50, 5-minute writes $0.125, 1-hour $0.20,
+  // hits $0.01 — and every rate 5x for a request whose prompt is over 100,000 tokens,
+  // counting cache reads and writes (pricing page "Long context pricing", read
+  // 2026-10-10). Claude Code 2.1.293 makes it the `haiku` alias on the Anthropic API,
+  // which is PAN's fast tier there. `long` prices the part of a row that came from
+  // such requests (`long_prompt`, see computeCost).
+  'claude-haiku-5-5':   { input: 0.10, output: 0.50, cache_read: 0.01, cache_write: 0.125, cache_write_1h: 0.20,
+    long: { above: LONG_PROMPT_THRESHOLD, input: 0.50, output: 2.50, cache_read: 0.05, cache_write: 0.625, cache_write_1h: 1.0 } },
   // Haiku 4.5: API id claude-haiku-4-5-20251001, alias claude-haiku-4-5.
   'claude-haiku-4-5':   { input: 1.0,  output: 5.0,  cache_read: 0.1,  cache_write: 1.25, cache_write_1h: 2.0 },
 
@@ -242,6 +256,7 @@ const scaleRate = (rate, m) => ({
   cache_read: round6(rate.cache_read * m),
   cache_write: round6(rate.cache_write * m),
   ...(typeof rate.cache_write_1h === 'number' ? { cache_write_1h: round6(rate.cache_write_1h * m) } : {}),
+  ...(rate.long && typeof rate.long === 'object' ? { long: { above: rate.long.above, ...scaleRate(rate.long, m) } } : {}),
 });
 
 /**
@@ -388,12 +403,35 @@ function computeCost(rec, configRates) {
   // bills at the one-hour rate; the rest — and every write on a row or rate without
   // the split — at `cache_write`.
   const write1h = Math.min(cacheWrite, Math.max(0, Number(rec.cache_write_1h_tokens) || 0));
-  const rate1h = typeof rate.cache_write_1h === 'number' ? rate.cache_write_1h : rate.cache_write;
-  const usd = (input * rate.input + output * rate.output + cacheRead * rate.cache_read
-    + (cacheWrite - write1h) * rate.cache_write + write1h * rate1h) / 1_000_000;
+  const tokens = { input, output, cacheRead, cacheWrite, write1h };
+  // A long-prompt tier (Haiku 5.5): the row's `long_prompt` holds the tokens of the
+  // requests whose prompt was over the threshold, and those bill at the long rates.
+  // Measured at the same threshold only — a row split at another figure cannot be
+  // re-cut here, so it prices at the base rates as before.
+  const lp = rec.long_prompt;
+  let usd = 0;
+  if (rate.long && lp && typeof lp === 'object' && Number(lp.above) === Number(rate.long.above)) {
+    const part = {
+      input: Math.min(input, Number(lp.input_tokens) || 0),
+      output: Math.min(output, Number(lp.output_tokens) || 0),
+      cacheRead: Math.min(cacheRead, Number(lp.cache_read_tokens) || 0),
+      cacheWrite: Math.min(cacheWrite, Number(lp.cache_write_tokens) || 0),
+    };
+    part.write1h = Math.min(part.cacheWrite, write1h, Number(lp.cache_write_1h_tokens) || 0);
+    usd += priceTokens(part, rate.long);
+    for (const k of Object.keys(part)) tokens[k] -= part[k];
+  }
+  usd += priceTokens(tokens, rate);
   return Math.round(usd * 10000) / 10000;
 }
 
+/** USD for disjoint token counts at one rate row (1-hour writes at their own rate). */
+function priceTokens(t, rate) {
+  const rate1h = typeof rate.cache_write_1h === 'number' ? rate.cache_write_1h : rate.cache_write;
+  return (t.input * rate.input + t.output * rate.output + t.cacheRead * rate.cache_read
+    + (t.cacheWrite - t.write1h) * rate.cache_write + t.write1h * rate1h) / 1_000_000;
+}
+
 /**
  * Append a cost record. Non-blocking — errors are swallowed so instrumentation
  * never breaks the caller.
@@ -532,7 +570,11 @@ function aggregate(cwd, opts) {
   const records = readRecords(cwd);
   const malformedSkipped = _lastReadMalformed; // captured before any later read
   const since = opts?.since ? new Date(opts.since).getTime() : null;
-  const until = opts?.until ? new Date(opts.until).getTime() : null;
+  // A bare date is that day's first instant, so as an upper bound it left out the
+  // whole day the docs call inclusive: read it as the day's last millisecond.
+  const until = opts?.until
+    ? new Date(/^\d{4}-\d{2}-\d{2}$/.test(String(opts.until)) ? `${opts.until}T23:59:59.999Z` : opts.until).getTime()
+    : null;
   const config = loadConfig(cwd);
   const configRates = effectiveRates(config);
 
@@ -699,10 +741,12 @@ function renderChart(agg) {
 function cmdCostReport(cwd, opts, raw) {
   const format = opts?.format || 'json';
   const agg = aggregate(cwd, opts);
+  // `--format table|chart` asks for text, so it prints text with or without
+  // `--raw`; without `--raw` it used to print the JSON report unchanged.
   if (format === 'table') {
-    output(agg, raw, renderTable(agg));
+    output(agg, true, renderTable(agg));
   } else if (format === 'chart') {
-    output(agg, raw, renderChart(agg));
+    output(agg, true, renderChart(agg));
   } else {
     output(agg, raw);
   }
@@ -722,6 +766,86 @@ function cmdCostClear(cwd, raw) {
   }
 }
 
+// ─── Host usage limits (Claude Code subscriptions) ───────────────────────────
+//
+// Claude Code's status-line payload carries `rate_limits.five_hour` and
+// `rate_limits.seven_day` (`used_percentage`, `resets_at` in epoch seconds;
+// code.claude.com/docs/en/statusline, read 2026-10-10). On a subscription those
+// windows, not dollars, are what a long campaign runs out of. PAN's status line
+// writes them, account-wide, to claude-limits.json in the per-user pan-hooks
+// directory; campaigns read them here. Headless `claude -p` runs no status line, so
+// there the file goes stale and nothing stops on it.
+
+const HOST_LIMITS_FILE = 'claude-limits.json';
+const HOST_LIMITS_FRESH_SECONDS = 15 * 60;
+const DEFAULT_WEEKLY_LIMIT_STOP_PCT = 90;
+
+/** The per-user pan-hooks directory when it is safe to read (ours, not a symlink, owner-only), else null. */
+function hooksDirIfSafe(tmpDir) {
+  const uid = typeof process.getuid === 'function' ? process.getuid() : (process.env.USERNAME || 'win');
+  const dir = path.join(tmpDir || require('os').tmpdir(), `pan-hooks-${uid}`);
+  try {
+    const st = fs.lstatSync(dir);
+    if (st.isSymbolicLink() || !st.isDirectory()) return null;
+    if (typeof process.getuid === 'function' && (st.uid !== process.getuid() || (st.mode & 0o077) !== 0)) return null;
+    return dir;
+  } catch { return null; }
+}
+
+/**
+ * The host's usage-limit windows as the status line last saw them, or null when no
+ * status line has written them. A window whose `resets_at` has passed reads as reset
+ * (used 0); the whole reading is `stale` past HOST_LIMITS_FRESH_SECONDS.
+ * @param {{tmpDir?: string, now?: number}} [opts] - now in epoch seconds
+ */
+function readHostLimits(opts = {}) {
+  const dir = hooksDirIfSafe(opts.tmpDir);
+  if (!dir) return null;
+  let raw;
+  try { raw = JSON.parse(fs.readFileSync(path.join(dir, HOST_LIMITS_FILE), 'utf8')); } catch { return null; }
+  if (!raw || typeof raw !== 'object') return null;
+  const now = Number.isFinite(opts.now) ? opts.now : Math.floor(Date.now() / 1000);
+  const win = (w) => {
+    if (!w || typeof w !== 'object' || !Number.isFinite(Number(w.used_percentage))) return null;
+    const resetsAt = Number.isFinite(Number(w.resets_at)) ? Number(w.resets_at) : null;
+    const reset = resetsAt !== null && resetsAt <= now;
+    return { used_pct: reset ? 0 : Math.max(0, Math.min(100, Number(w.used_percentage))), resets_at: resetsAt, reset_since_read: reset };
+  };
+  const age = Number.isFinite(Number(raw.timestamp)) ? now - Number(raw.timestamp) : null;
+  return {
+    five_hour: win(raw.five_hour),
+    seven_day: win(raw.seven_day),
+    age_seconds: age,
+    stale: age === null || age > HOST_LIMITS_FRESH_SECONDS,
+  };
+}
+
+/**
+ * Whether a campaign should stop on the 7-day window: a fresh reading at or past
+ * `cost.weekly_limit_stop_pct` (default 90; 0 or false turns it off).
+ */
+function weeklyLimitStop(cwd, limits = readHostLimits()) {
+  let pct = DEFAULT_WEEKLY_LIMIT_STOP_PCT;
+  try {
+    const v = loadConfig(cwd)?.cost?.weekly_limit_stop_pct;
+    if (v === false || v === 0) pct = 0;
+    else if (Number.isFinite(Number(v)) && Number(v) > 0 && Number(v) <= 100) pct = Number(v);
+  } catch { /* defaults */ }
+  const used = limits && !limits.stale && limits.seven_day ? limits.seven_day.used_pct : null;
+  return { stop: pct > 0 && used !== null && used >= pct, threshold_pct: pct, seven_day_used_pct: used };
+}
+
+function cmdCostLimits(cwd, raw) {
+  const limits = readHostLimits();
+  const stop = weeklyLimitStop(cwd, limits);
+  output({
+    available: !!limits,
+    ...(limits || { five_hour: null, seven_day: null, age_seconds: null, stale: true }),
+    weekly_limit_stop_pct: stop.threshold_pct,
+    weekly_limit_reached: stop.stop,
+  }, raw, stop.stop ? 'weekly_limit_reached' : (limits ? 'ok' : 'no_reading'));
+}
+
 // ─── Rate-table staleness ───────────────────────────────────────────────────
 
 // Date DEFAULT_RATES was last verified against published provider pricing — ALL
@@ -738,7 +862,7 @@ function cmdCostClear(cwd, raw) {
 // a default-model change inside the window — that is the job of the
 // documented-default-ids fixture test (tests/fixtures/documented-default-models.json,
 // R31), which fails the suite the day a documented default id has no exact row.
-const RATES_VERIFIED_AT = '2026-09-23';
+const RATES_VERIFIED_AT = '2026-10-10';
 const RATES_STALE_AFTER_DAYS = 60;
 const RATE_TIERS = ['reasoning', 'mid', 'fast'];
 
@@ -784,6 +908,11 @@ module.exports = {
   renderTable,
   renderChart,
   resolveRate,
+  LONG_PROMPT_THRESHOLD,
+  readHostLimits,
+  weeklyLimitStop,
+  cmdCostLimits,
+  HOST_LIMITS_FILE,
   ratesFromModelPricing,
   managedSettingsDir,
   loadManagedModelPricing,

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

@@ -21,8 +21,10 @@ const SCANNABLE_EXTS = ['.js', '.cjs', '.mjs', '.ts', '.tsx', '.jsx', '.py'];
 
 // ─── Pass 1: Deterministic static analysis ───────────────────────────────────
 
-// Calls that genuinely CANNOT throw when given any single argument, so a
-// try/catch wrapping only such a call is truly phantom (dead catch clause).
+// Calls the matcher treats as non-throwing: none of them throws on a string or a
+// number, so a try/catch wrapping only such a call is usually phantom. Number, String,
+// parseInt and parseFloat do throw on an object whose toString throws (all but String
+// on a Symbol too), which is why findPhantomTryCatch tiers it review_required.
 // Deliberately EXCLUDES throwing calls — JSON.parse (SyntaxError on bad input),
 // JSON.stringify (TypeError on circular refs / BigInt), new RegExp, fs.*Sync,
 // etc. — because their try/catch is load-bearing and must not be flagged for
@@ -431,7 +433,7 @@ function writePatternsMemory(cwd, findings, opts) {
   const lines = [
     '---',
     'name: distill-patterns',
-    'description: Cross-session memory of AI-bloat patterns detected and resolved',
+    'description: Cross-session memory of AI-bloat patterns detected (it records detections, not fixes)',
     'type: project',
     '---',
     '',
@@ -520,6 +522,7 @@ module.exports = {
   findUnreferencedExports,
   SAFETY_TIERS,
   DEFAULT_BLOAT_THRESHOLD,
+  PATTERNS_FILE,
   MAX_FUNCTION_LOC,
   MAX_PARAM_COUNT,
   MAX_NESTING_DEPTH,

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

@@ -44,11 +44,21 @@ const DEFAULT_SCHEMA_PATH = path.join(
  *   calls it must pass its verdict as output()'s 4th argument; a bare
  *   process.exit() after an output() call is unreachable.
  */
+/**
+ * A missing path or a file where a directory is expected ends in error(), not in the
+ * stack trace walkMarkdownFiles' throw used to print (`doc-lint counts README.md`).
+ * @param {string} targetDir
+ */
+function requireDirectory(targetDir) {
+  let stat = null;
+  try { stat = fs.statSync(targetDir); } catch { /* absent */ }
+  if (!stat) error(`directory not found: ${targetDir}`);
+  if (!stat.isDirectory()) error(`not a directory: ${targetDir} — doc-lint scans a directory of markdown files`);
+}
+
 function cmdDocLint(cwd, dir, opts = {}) {
   const targetDir = path.isAbsolute(dir) ? dir : path.join(cwd, dir);
-  if (!fs.existsSync(targetDir)) {
-    error(`directory not found: ${targetDir}`);
-  }
+  requireDirectory(targetDir);
 
   const schemaPath = opts.schema
     ? (path.isAbsolute(opts.schema) ? opts.schema : path.join(cwd, opts.schema))
@@ -209,7 +219,6 @@ function isCountAllowed(relativePath) {
 // Things that LOOK like counts but are stable identities (allowed everywhere):
 const STABLE_IDENTITIES = [
   /\b5\s+(target\s+)?runtimes\b/i,                          // 5 target runtimes
-  /\b5\s+hooks\b/i,                                          // 5 hooks (named individually)
   /\bLAYER\s+\d+\b/,                                         // architecture layer labels
   /\b5\s+(parallel\s+)?(researchers?|research\s+)/i,         // 5 parallel researchers
   /\b6\s+(parallel\s+)?agents\b/i,                           // 6 parallel agents (codebase mapper)
@@ -218,9 +227,17 @@ const STABLE_IDENTITIES = [
   /\bthree\s+phases\b|\bfour\s+phases\b/i,                   // generic phase counts in narrative
 ];
 
-function isStableIdentity(matchText, surrounding) {
+function isStableIdentity(matchText, surrounding, matchIndex = 0) {
   for (const re of STABLE_IDENTITIES) {
-    if (re.test(matchText) || re.test(surrounding)) return true;
+    if (re.test(matchText)) return true;
+    // Only an identity that overlaps the count excuses it ("LAYER 6 modules"). One
+    // elsewhere on the line excused every count there: "52 commands on all 5 runtimes".
+    const all = new RegExp(re.source, re.flags.includes('g') ? re.flags : `${re.flags}g`);
+    let s;
+    while ((s = all.exec(surrounding)) !== null) {
+      if (s.index < matchIndex + matchText.length && matchIndex < s.index + s[0].length) return true;
+      if (s[0].length === 0) all.lastIndex++;
+    }
   }
   return false;
 }
@@ -233,9 +250,7 @@ function isStableIdentity(matchText, surrounding) {
  */
 function cmdDocLintCounts(cwd, dir, opts = {}) {
   const targetDir = path.isAbsolute(dir) ? dir : path.join(cwd, dir);
-  if (!fs.existsSync(targetDir)) {
-    error(`directory not found: ${targetDir}`);
-  }
+  requireDirectory(targetDir);
 
   const exclude = opts.exclude || [];
   const files = walkMarkdownFiles(targetDir, { exclude });
@@ -260,8 +275,8 @@ function cmdDocLintCounts(cwd, dir, opts = {}) {
         re.lastIndex = 0; // reset for /g
         let m;
         while ((m = re.exec(line)) !== null) {
-          // Skip if this whole line is in a stable-identity surrounding
-          if (isStableIdentity(m[0], line)) continue;
+          // Skip a count that is part of a stable identity
+          if (isStableIdentity(m[0], line, m.index)) continue;
           violations.push({
             file: file.relativePath,
             line: i + 1,
@@ -363,6 +378,10 @@ function scanDocFlags(cwd, opts = {}) {
 }
 
 function cmdDocLintFlags(cwd, opts = {}, raw) {
+  for (const d of opts.docDirs || []) {
+    const abs = path.isAbsolute(d) ? d : path.join(cwd, d);
+    if (fs.existsSync(abs)) requireDirectory(abs);
+  }
   const r = scanDocFlags(cwd, opts);
   if (raw) {
     if (r.violation_count === 0) {

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

@@ -276,6 +276,13 @@ function disposeFindings(cwd, input) {
   return { contract: V.VERDICT_CONTRACT, disposition: as, disposed, skipped };
 }
 
+/**
+ * Milestone versions compare with or without the leading `v`: the ledger stores
+ * `getMilestoneInfo`'s `v1.0`, while milestone-audit names its version `1.0` (its
+ * report is `v{version}-milestone-audit.md`), so `--milestone 1.0` found no debt.
+ */
+const sameMilestone = (a, b) => String(a || '').trim().replace(/^v/i, '') === String(b || '').trim().replace(/^v/i, '');
+
 /** Findings with their folded status, filtered. */
 function listFindings(cwd, filters = {}) {
   const { rows, malformed } = readLedger(cwd);
@@ -285,7 +292,7 @@ function listFindings(cwd, filters = {}) {
   if (filters.agent) list = list.filter((f) => f.agent === filters.agent);
   if (filters.status) list = list.filter((f) => f.status === filters.status);
   if (filters.class) list = list.filter((f) => f.class === filters.class);
-  if (filters.milestone) list = list.filter((f) => f.milestone === filters.milestone);
+  if (filters.milestone) list = list.filter((f) => sameMilestone(f.milestone, filters.milestone));
   const findings = list.map(publicFinding);
   return {
     contract: V.VERDICT_CONTRACT,
@@ -306,7 +313,7 @@ function findingsDebt(cwd, opts = {}) {
   const fold = foldFindings(rows);
   const byPhase = new Map();
   for (const f of fold.findings.values()) {
-    if (milestone && f.milestone !== milestone) continue;
+    if (milestone && !sameMilestone(f.milestone, milestone)) continue;
     if (f.status !== 'deferred' && f.status !== 'open') continue;
     const key = V.comparablePhase(f.phase);
     if (!byPhase.has(key)) byPhase.set(key, { phase: f.phase, deferred: [], open: [] });

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

@@ -22,6 +22,7 @@ const {
 const { extractFrontmatter, extractPriorityEffort } = require('./frontmatter.cjs');
 const { enumerateRoadmapPhases } = require('./roadmap.cjs');
 const { readErrorPatterns } = require('./commands.cjs');
+const { weeklyLimitStop } = require('./cost.cjs');
 const { planningPath, listPhaseDirs, classifyPhaseStatus, filterPlanFiles, filterSummaryFiles, planningRel } = require('./utils.cjs');
 
 // ─── Scan helpers ───────────────────────────────────────────────────────────
@@ -302,10 +303,13 @@ function allocateBudget(items, budget, mode) {
   } else if (mode === 'features') {
     const { picked: mPicked, used: mUsed } = allocatePass(items, budget, { maxPriority: 0, minPriority: 0, track: 'mandatory' });
     addToBatch(mPicked);
-    const featureBudget = Math.floor(budget * FEATURE_RATIO);
+    // The feature/stability split shares what the P0 pass left: splitting the
+    // whole budget again let a batch reach nearly twice the budget.
+    const rest = budget - mUsed;
+    const featureBudget = Math.floor(rest * FEATURE_RATIO);
     const { picked: fPicked, used: fUsed } = allocatePass(items, featureBudget, { minPriority: 3, maxPriority: 5, track: 'feature', exclude: batchIds });
     addToBatch(fPicked);
-    const { picked: sPicked, used: sUsed } = allocatePass(items, budget - featureBudget, { minPriority: 1, maxPriority: 2, track: 'stability', exclude: batchIds });
+    const { picked: sPicked, used: sUsed } = allocatePass(items, rest - featureBudget, { minPriority: 1, maxPriority: 2, track: 'stability', exclude: batchIds });
     addToBatch(sPicked);
     allocated = mUsed + fUsed + sUsed;
   } else {
@@ -920,9 +924,14 @@ function focusAutoUpdate(cwd, raw, getVal) {
   run.totals.tests_current = cycle.tests_after;
   run.status = AUTORUN_STATUSES.IN_PROGRESS;
 
-  const stopReason = determineStopReason(cycle, run);
+  // The host's 7-day usage window (Claude Code subscriptions, read from what PAN's
+  // status line last saw): past cost.weekly_limit_stop_pct the run stops resumable,
+  // so the rest of the window stays the user's. No fresh reading never stops it.
+  const weekly = weeklyLimitStop(cwd);
+  cycle.weekly_limit_used_pct = weekly.seven_day_used_pct;
+  const stopReason = determineStopReason(cycle, run) || (weekly.stop ? 'weekly_limit' : null);
   if (stopReason) {
-    run.status = stopReason === 'regression' ? AUTORUN_STATUSES.STOPPED : AUTORUN_STATUSES.COMPLETED;
+    run.status = stopReason === 'regression' || stopReason === 'weekly_limit' ? AUTORUN_STATUSES.STOPPED : AUTORUN_STATUSES.COMPLETED;
     run.stop_reason = stopReason;
   }
 

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

@@ -4,7 +4,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { safeReadFile, output, error, escapeRegex } = require('./core.cjs');
+const { safeReadFile, output, error, escapeRegex, toLf, dominantEol, withEol } = require('./core.cjs');
 const { FIELD_VALUE_RE, PRIORITY_LEVELS, EFFORT_SIZES } = require('./constants.cjs');
 
 // --- Inline array rendering thresholds -------------------------------------------
@@ -169,7 +169,21 @@ function renderYamlEntry(lines, key, value, depth) {
       lines.push(`${indent}${key}:`);
       const itemIndent = '  '.repeat(depth + 1);
       for (const item of value) {
-        lines.push(`${itemIndent}- ${quoteIfNeeded(item)}`);
+        if (item && typeof item === 'object' && !Array.isArray(item)) {
+          // A list of maps (a plan's must_haves artifacts and key_links): the first
+          // key on the dash line, the rest under it. Written as a scalar, each item
+          // came out "[object Object]".
+          const entries = Object.entries(item).filter(([, v]) => v !== null && v !== undefined);
+          entries.forEach(([k, v], idx) => {
+            // An array value goes out as a flow sequence of JSON strings, which the
+            // parser reads back as an array (`exports: ["GET", "POST"]`).
+            const text = Array.isArray(v) ? `[${v.map((x) => JSON.stringify(String(x))).join(', ')}]`
+              : quoteIfNeeded(typeof v === 'object' ? JSON.stringify(v) : v);
+            lines.push(`${itemIndent}${idx === 0 ? '- ' : '  '}${k}: ${text}`);
+          });
+        } else {
+          lines.push(`${itemIndent}- ${quoteIfNeeded(item)}`);
+        }
       }
     }
   } else if (typeof value === 'object') {
@@ -201,34 +215,76 @@ function quoteIfNeeded(value) {
  */
 function spliceFrontmatter(content, newObj) {
   const yamlStr = reconstructFrontmatter(newObj);
-  const match = content.match(/^---\n[\s\S]+?\n---/);
+  // Match on LF and give the file back in its own ending. The LF-only match
+  // missed the block in a CRLF file, so `frontmatter set` and `merge` stacked a
+  // second frontmatter on top of the first instead of replacing it.
+  const eol = dominantEol(content);
+  const text = toLf(content);
+  const match = text.match(/^---\n[\s\S]+?\n---/);
   if (match) {
-    return `---\n${yamlStr}\n---` + content.slice(match[0].length);
+    return withEol(`---\n${yamlStr}\n---` + text.slice(match[0].length), eol);
+  }
+  return withEol(`---\n${yamlStr}\n---\n\n` + text, eol);
+}
+
+/**
+ * A YAML scalar as written in a must_haves value: a double-quoted one unescapes `\\`
+ * and `\"`, a single-quoted one `''`, a plain one is taken as written. The raw `\\.`
+ * of the shipped key-link example reached `new RegExp` in `verify key-links`, so
+ * `pattern: "prisma\\.message\\.(find|create)"` never matched.
+ * @param {string} raw - The value text after `key:` (or after `- `)
+ * @returns {string}
+ */
+function yamlScalar(raw) {
+  const s = String(raw).trim();
+  // A flow sequence (`exports: ["GET", "POST"]`, as the plan template writes it) is an
+  // array of scalars: taken whole it was one string, and `verify artifacts` then
+  // reported every export missing.
+  if (s.length >= 2 && s.startsWith('[') && s.endsWith(']')) {
+    const items = [];
+    let cur = '';
+    let quote = null;
+    const inner = s.slice(1, -1);
+    for (let i = 0; i < inner.length; i++) {
+      const c = inner[i];
+      if (quote) {
+        cur += c;
+        if (c === '\\' && quote === '"' && i + 1 < inner.length) cur += inner[++i];
+        else if (c === quote) quote = null;
+      } else if (c === '"' || c === "'") { quote = c; cur += c; }
+      else if (c === ',') { items.push(cur); cur = ''; }
+      else cur += c;
+    }
+    items.push(cur);
+    return items.map((x) => yamlScalar(x)).filter((x) => x !== '');
   }
-  return `---\n${yamlStr}\n---\n\n` + content;
+  if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) return s.slice(1, -1).replace(/\\(["\\])/g, '$1');
+  if (s.length >= 2 && s.startsWith("'") && s.endsWith("'")) return s.slice(1, -1).replace(/''/g, "'");
+  return s;
 }
 
 /**
  * Parse a specific block (artifacts, key_links, truths) from must_haves in raw YAML frontmatter.
  *
- * Block structure being parsed:
- *   The must_haves section is a 3-level nested YAML structure:
- *     must_haves:           (level 1 -- 2-space indent)
- *       artifacts:          (level 2 -- 4-space indent, the blockName)
- *         - path: foo       (level 3 -- 6-space indent, list items)
- *           provides: bar   (level 3+ -- 8-space indent, continuation k-v pairs)
+ * Block structure being parsed (indents are relative, never fixed columns):
+ *     must_haves:
+ *       artifacts:          (the blockName, deeper than must_haves)
+ *         - path: foo       (list items)
+ *           provides: bar   (continuation k-v pairs, deeper than the item's dash)
  *
- *   This function finds the named block at the 4-space level, then parses
- *   its list items (at 6-space indent) and their nested key-value pairs
- *   (at 8+ space indent) into an array of objects or strings.
+ *   This function finds the named block under must_haves, then parses its list
+ *   items and their nested key-value pairs into an array of objects or strings.
+ *   Values go through yamlScalar.
  *
  * @param {string} content - Full markdown content with frontmatter
  * @param {string} blockName - Block name to extract (e.g., "artifacts", "key_links")
  * @returns {Array} Parsed array of block items (objects or strings)
  */
 function parseMustHavesBlock(content, blockName) {
-  // Extract raw YAML between --- delimiters
-  const fmMatch = content.match(/^---\n([\s\S]+?)\n---/);
+  // Extract raw YAML between --- delimiters. On LF: a CRLF plan (every Windows
+  // field project) matched nothing here, so its must_haves read as empty and the
+  // reconcile gate below trusted the verdict again, as it did before the indent fix.
+  const fmMatch = toLf(content).match(/^---\n([\s\S]+?)\n---/);
   if (!fmMatch) return [];
 
   const yaml = fmMatch[1];
@@ -290,18 +346,18 @@ function parseMustHavesBlock(content, blockName) {
 
       const body = dashMatch[2];
       // A plain string item — no `key: value` shape.
-      const kvMatch = body.match(/^(\w+):\s*"?([^"]*)"?\s*$/);
+      const kvMatch = body.match(/^(\w+):\s*(.*?)\s*$/);
       if (kvMatch) {
         currentItem = {};
-        currentItem[kvMatch[1]] = kvMatch[2];
+        currentItem[kvMatch[1]] = yamlScalar(kvMatch[2]);
       } else {
-        currentItem = body.replace(/^"|"$/g, '').trim();
+        currentItem = yamlScalar(body);
       }
     } else if (currentItem && typeof currentItem === 'object') {
       // Continuation key-value: deeper than the item's dash (properties of it)
-      const kvMatch = line.match(/^\s+(\w+):\s*"?([^"]*)"?\s*$/);
+      const kvMatch = line.match(/^\s+(\w+):\s*(.*?)\s*$/);
       if (kvMatch) {
-        const val = kvMatch[2];
+        const val = yamlScalar(kvMatch[2]);
         // Coerce pure-integer strings to numbers for convenience
         currentItem[kvMatch[1]] = /^\d+$/.test(val) ? parseInt(val, 10) : val;
       }
@@ -309,7 +365,7 @@ function parseMustHavesBlock(content, blockName) {
       // already deeper than the list-item dash (a shallower one would have been
       // treated as a new item above), so relative depth alone identifies it —
       // no fixed column.
-      const arrMatch = line.match(/^\s+-\s+"?([^"]+)"?\s*$/);
+      const arrMatch = line.match(/^\s+-\s+(.+?)\s*$/);
       if (arrMatch) {
         // Convert the most recently added key's scalar value into an array,
         // then append this item to that array
@@ -318,7 +374,7 @@ function parseMustHavesBlock(content, blockName) {
         if (lastKey && !Array.isArray(currentItem[lastKey])) {
           currentItem[lastKey] = currentItem[lastKey] ? [currentItem[lastKey]] : [];
         }
-        if (lastKey) currentItem[lastKey].push(arrMatch[1]);
+        if (lastKey) currentItem[lastKey].push(yamlScalar(arrMatch[1]));
       }
     }
   }
@@ -354,6 +410,27 @@ const FRONTMATTER_SCHEMAS = {
   verification: { required: ['phase', 'verified', 'status', 'score'] },
 };
 
+/**
+ * extractFrontmatter cannot read a list of maps: each must_haves artifact and key
+ * link came back as the string of its first line (`path: "src/x.ts`), so the plan
+ * checker and verify-phase, which read them through `frontmatter get`, got no
+ * objects. parseMustHavesBlock reads both blocks by relative indent.
+ * @param {object} fm - extractFrontmatter output
+ * @param {string} content - the file it came from
+ * @returns {object} fm, with must_haves.artifacts and .key_links as objects
+ */
+function withParsedMustHaves(fm, content) {
+  const mh = fm && fm.must_haves;
+  if (!mh || typeof mh !== 'object' || Array.isArray(mh)) return fm;
+  const fixed = { ...mh };
+  for (const block of ['artifacts', 'key_links']) {
+    if (!(block in fixed)) continue;
+    const parsed = parseMustHavesBlock(content, block);
+    if (parsed.length) fixed[block] = parsed;
+  }
+  return { ...fm, must_haves: fixed };
+}
+
 /**
  * Get frontmatter from a file, optionally filtered to a single field.
  * @param {string} cwd - Working directory path
@@ -367,7 +444,7 @@ function cmdFrontmatterGet(cwd, filePath, field, 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 fm = extractFrontmatter(content);
+  const fm = withParsedMustHaves(extractFrontmatter(content), content);
   if (field) {
     const value = fm[field];
     if (value === undefined) { output({ error: 'Field not found', field }, raw); return; }
@@ -395,7 +472,9 @@ function cmdFrontmatterSet(cwd, filePath, field, value, raw) {
   } catch {
     output({ error: 'File not found', path: filePath }, raw); return;
   }
-  const fm = extractFrontmatter(content);
+  // The block is rewritten whole, so a plan's must_haves lists of maps must be read
+  // as maps: extractFrontmatter alone flattened each item to its first line.
+  const fm = withParsedMustHaves(extractFrontmatter(content), content);
   let parsedValue;
   // Attempt JSON parse so callers can pass structured values (arrays, objects);
   // fall back to raw string if the value is not valid JSON
@@ -427,7 +506,7 @@ function cmdFrontmatterMerge(cwd, filePath, data, raw) {
   } catch {
     output({ error: 'File not found', path: filePath }, raw); return;
   }
-  const fm = extractFrontmatter(content);
+  const fm = withParsedMustHaves(extractFrontmatter(content), content);
   let mergeData;
   // Parse the JSON data string; abort with error if the caller passed invalid JSON
   try { mergeData = JSON.parse(data); } catch { error('Invalid JSON for --data'); return; }