pan-wizard 3.33.0 → 3.35.0

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

@@ -3,7 +3,7 @@
  */
 const fs = require('fs');
 const path = require('path');
-const { safeReadFile, loadConfig, isGitIgnored, isGitRepo, execGit, normalizePhaseName, comparePhaseNum, getArchivedPhaseDirs, generateSlugInternal, getMilestoneInfo, resolveModelInternal, resolveModelDetailed, resolveEffortInternal, detectProvider, resolveTierToModel, estimateCostMultiplier, MODEL_PROFILES, output, error, findPhaseInternal, scanPendingTodos, toPosix } = require('./core.cjs');
+const { safeReadFile, loadConfig, isGitIgnored, isGitRepo, execGit, normalizePhaseName, comparePhaseNum, getArchivedPhaseDirs, generateSlugInternal, getMilestoneInfo, resolveModelInternal, resolveModelDetailed, resolveEffortInternal, detectProvider, resolveTierToModel, estimateCostMultiplier, MODEL_PROFILES, output, error, findPhaseInternal, scanPendingTodos, toPosix, toLf } = require('./core.cjs');
 const { extractFrontmatter } = require('./frontmatter.cjs');
 const { PHASES_DIR, MILESTONES_DIR, QUICK_DIR, STATE_FILE, ROADMAP_FILE, PROJECT_FILE, PATTERNS_FILE, SESSION_HISTORY_FILE, LEARNINGS_FILE, CONTEXT_SUFFIX, UAT_SUFFIX, VERIFICATION_SUFFIX, isPlanFile, isSummaryFile, ARCHIVE_DIR_RE, PHASE_DIR_RE, CONTEXT_WINDOW, WARNING_THRESHOLD, CRITICAL_THRESHOLD, VALID_COMMIT_TYPES, DEFAULT_SENSITIVE_PATTERNS, STATE_CONTRACT } = require('./constants.cjs');
 const { planningPath, phasesPath, filterPlanFiles, filterSummaryFiles, planningRel } = require('./utils.cjs');
@@ -153,9 +153,12 @@ function buildDigest(summaries, techStack) {
       frontmatter.provides.forEach(item => phases[phaseNum].provides.add(item));
     }
 
-    // Merge affects from nested dependency-graph
+    // Merge affects from either nested dependency-graph or the flat `affects:` list the
+    // summary templates write (only the nested form was read, so `affects` stayed empty)
     if (frontmatter['dependency-graph'] && Array.isArray(frontmatter['dependency-graph'].affects)) {
       frontmatter['dependency-graph'].affects.forEach(item => phases[phaseNum].affects.add(item));
+    } else if (Array.isArray(frontmatter.affects)) {
+      frontmatter.affects.forEach(item => phases[phaseNum].affects.add(item));
     }
 
     // Merge established patterns
@@ -315,7 +318,9 @@ function runCommitSafetyChecks(cwd, config, force) {
   if (statusResult.exitCode === 0 && statusResult.stdout) {
     for (const line of statusResult.stdout.split('\n').filter(Boolean)) {
       if (line.startsWith(' D') || line.startsWith('D ') || line.startsWith('D')) {
-        const fileName = line.slice(3).trim();
+        // execGit trims stdout, so a first line of ` D gone.txt` arrives as `D gone.txt`:
+        // strip the status code by pattern, not by a fixed three-character slice
+        const fileName = line.replace(/^\s*[A-Z?!]{1,2}\s+/, '').trim();
         if (fileName) safetyChecks.deleted_files.push(fileName);
       }
     }
@@ -333,7 +338,13 @@ function runCommitSafetyChecks(cwd, config, force) {
     if (patterns.length > 0) {
       const stagedFiles = stagedResult.stdout.split('\n').filter(Boolean);
       const regexes = patterns.map(p => { try { return new RegExp(p, 'i'); } catch { return null; } }).filter(Boolean);
+      // PAN's own cost ledger matches the bare `token` pattern, which blocked every
+      // commit that staged .planning/ once the cost logger had written to it. It holds
+      // token counts, never a credential. The hook always writes the root tree's copy.
+      const { METRICS_DIR, TOKENS_FILE } = require('./cost.cjs');
+      const ownLedger = new Set([planningRel(METRICS_DIR, TOKENS_FILE), `.planning/${METRICS_DIR}/${TOKENS_FILE}`]);
       for (const f of stagedFiles) {
+        if (ownLedger.has(f)) continue;
         if (regexes.some(re => re.test(f))) safetyChecks.sensitive_files_blocked.push(f);
       }
     }
@@ -463,6 +474,22 @@ function cmdCommit(cwd, message, files, raw, amend, opts) {
   output({ committed: true, hash, reason: 'committed', type: commitType || null, safety_checks: safety.safetyChecks }, raw, hash || 'committed');
 }
 
+/**
+ * A summary's one-liner: the `one-liner` frontmatter key, else the bold line under the
+ * `# Phase … Summary` title, which is where the summary templates put it (none writes
+ * the key, so reading only the key gave `one_liner: null` for every summary PAN writes).
+ * Read on LF: the body match failed on a CRLF summary.
+ * @param {string} content - Whole summary.md
+ * @returns {string|null}
+ */
+function summaryOneLiner(content) {
+  const text = toLf(String(content || ''));
+  const fm = extractFrontmatter(text);
+  if (fm['one-liner']) return fm['one-liner'];
+  const m = text.replace(/^?---\n[\s\S]*?\n---\n/, '').match(/^#\s[^\n]*\n+\*\*([^\n*][^\n]*?)\*\*\s*$/m);
+  return m ? m[1].trim() : null;
+}
+
 /**
  * Extract structured data from a summary.md frontmatter with optional field filtering.
  * @param {string} cwd - Working directory path
@@ -502,10 +529,11 @@ function cmdSummaryExtract(cwd, summaryPath, fields, raw) {
     });
   };
 
+
   // Build full result
   const fullResult = {
     path: summaryPath,
-    one_liner: frontmatter['one-liner'] || null,
+    one_liner: summaryOneLiner(content),
     key_files: frontmatter['key-files'] || [],
     tech_added: (frontmatter['tech-stack'] && frontmatter['tech-stack'].added) || [],
     patterns: frontmatter['patterns-established'] || [],
@@ -528,6 +556,21 @@ function cmdSummaryExtract(cwd, summaryPath, fields, raw) {
   output(fullResult, raw);
 }
 
+/**
+ * Map a --freshness value to Brave's `freshness` parameter, which accepts only
+ * pd/pw/pm/py or a YYYY-MM-DDtoYYYY-MM-DD range. Returns null for anything else.
+ * @param {string} value - day|week|month|year, or a value Brave accepts as is
+ * @returns {string|null}
+ */
+function braveFreshness(value) {
+  const v = String(value || '').trim().toLowerCase();
+  const named = { day: 'pd', week: 'pw', month: 'pm', year: 'py' };
+  if (named[v]) return named[v];
+  if (/^p[dwmy]$/.test(v)) return v;
+  if (/^\d{4}-\d{2}-\d{2}to\d{4}-\d{2}-\d{2}$/.test(v)) return v;
+  return null;
+}
+
 /**
  * Search the web using Brave Search API and return structured results.
  *
@@ -560,6 +603,12 @@ async function cmdWebsearch(query, options, raw) {
     return;
   }
 
+  const freshness = options.freshness ? braveFreshness(options.freshness) : null;
+  if (options.freshness && !freshness) {
+    output({ available: false, error: `Invalid --freshness "${options.freshness}": use day, week, month, year, pd, pw, pm, py or YYYY-MM-DDtoYYYY-MM-DD` }, raw, '');
+    return;
+  }
+
   const params = new URLSearchParams({
     q: query,
     count: String(options.limit || 10),
@@ -568,8 +617,8 @@ async function cmdWebsearch(query, options, raw) {
     text_decorations: 'false'
   });
 
-  if (options.freshness) {
-    params.set('freshness', options.freshness);
+  if (freshness) {
+    params.set('freshness', freshness);
   }
 
   try {
@@ -1131,7 +1180,9 @@ module.exports = {
   cmdEstimateCost,
   cmdCommit,
   cmdSummaryExtract,
+  summaryOneLiner,
   cmdWebsearch,
+  braveFreshness,
   cmdProgressRender,
   cmdTodoComplete,
   cmdScaffold,

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

@@ -53,10 +53,15 @@ function buildConfigDefaults(hasBraveSearch, userDefaults) {
       verifier: true,
       nyquist_validation: false,
       phase_record_compact: false,
+      // V1: the phase gate. `warn` reports refusals and completes; `enforce` refuses.
+      phase_gate: 'warn',
       // M2: opt-in per-phase HTML reports at the verify→complete gate.
       phase_reports: { enabled: false, open: false, theme: 'auto', index: true },
     },
     parallelization: true,
+    // A7: the pre-tool guard. `report` logs to <planning>/guard.jsonl; `enforce` also
+    // denies a write that puts a credential in a file; `off` disables it.
+    hooks: { guard: 'report' },
     brave_search: hasBraveSearch,
     budget: {
       default_points: 50,
@@ -365,7 +370,8 @@ function cmdConfigGet(cwd, keyPath, raw) {
     error(`Key not found: ${keyPath}`);
   }
 
-  output(current, raw, String(current));
+  // An object or array prints as JSON under --raw: String() gave "[object Object]".
+  output(current, raw, current !== null && typeof current === 'object' ? JSON.stringify(current) : String(current));
 }
 
 // ─── Standards commands ─────────────────────────────────────────────────────

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

@@ -34,6 +34,9 @@ const RESEARCH_SUFFIX = '-research.md';
 const VERIFICATION_SUFFIX = '-verification.md';
 const UAT_SUFFIX = '-uat.md';
 const VALIDATION_SUFFIX = '-validation.md';
+// A phase's roadmap slice (roadmap slice --write), which phase agents and plans read
+// in place of the whole roadmap.md and requirements.md.
+const ROADMAP_SLICE_SUFFIX = '-roadmap-slice.md';
 
 // ─── File matching helpers ───────────────────────────────────────────────────
 
@@ -576,17 +579,23 @@ const TOTAL_BUDGET_MIN = 5;
 const TOTAL_BUDGET_MAX = 5000;
 
 // Memory read/budget (ADR-0036 FW-2/FW-3): distill-and-select on the memory axis.
-const MEMORY_SELECT_BUDGET_TOKENS = 2000; // per-agent cap for cue-scoped memory injection
+const MEMORY_SELECT_BUDGET_TOKENS = 2000; // per-agent cap for a cue-scoped `memory select`
 const MEMORY_RECENCY_FLOOR = 5;           // always keep this many newest entries (recall never empty)
 const MEMORY_SOFT_CAP_MULT = 2;           // soft auto-compaction trigger = DEFAULT_MAX_ENTRIES × this
 const MEMORY_LOAD_WARN_TOKENS = 4000;     // memory-budget telemetry: warn threshold (absolute tokens)
 const MEMORY_LOAD_CRIT_TOKENS = 8000;     // memory-budget telemetry: critical threshold (absolute tokens)
 const MEMORY_LOAD_MAX_FRACTION = 0.15;    // memory-budget telemetry: max fraction of median agent input
-
-// Cached prompt context (ADR-0044). The files in CACHEABLE_CONTEXT_FILES are
-// re-read into EVERY agent call, so their combined size is the single largest
-// recurring cost in a PAN project — cache reads dominate token traffic by roughly
-// two orders of magnitude over generation. These thresholds mirror the
+// Cited, verified, expiring memory (memory optimisation O4; the Copilot Memory
+// pattern). An entry not used for this many days is no longer selected and
+// `memory prune` archives it; `memory select --mark-used` refreshes it.
+const MEMORY_EXPIRE_DAYS = 60;
+const MEMORY_CITED_FILE_MAX_BYTES = 2 * 1024 * 1024; // larger cited files: existence is the evidence
+
+// Stable planning files (ADR-0044): what `cache prime`, `context-budget` and
+// hygiene's cache-context check measure. state.md among them is re-read on every
+// agent call, the largest recurring cost in a PAN project; roadmap.md and
+// requirements.md are read whole only by the roadmapper and milestone work, since
+// phase agents read `roadmap slice` (O2). These thresholds mirror the
 // MEMORY_LOAD_* pattern above: measured, classified, and surfaced.
 const CACHE_BLOCK_WARN_TOKENS = 15000;    // cached context block: warn threshold (absolute tokens)
 const CACHE_BLOCK_CRIT_TOKENS = 25000;    // cached context block: critical threshold
@@ -780,6 +789,7 @@ module.exports = {
   VERIFICATION_SUFFIX,
   UAT_SUFFIX,
   VALIDATION_SUFFIX,
+  ROADMAP_SLICE_SUFFIX,
   // File matchers
   isPlanFile,
   isSummaryFile,
@@ -862,6 +872,8 @@ module.exports = {
   MEMORY_LOAD_WARN_TOKENS,
   MEMORY_LOAD_CRIT_TOKENS,
   MEMORY_LOAD_MAX_FRACTION,
+  MEMORY_EXPIRE_DAYS,
+  MEMORY_CITED_FILE_MAX_BYTES,
   // Hygiene
   CACHE_BLOCK_WARN_TOKENS,
   CACHE_BLOCK_CRIT_TOKENS,

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

@@ -267,8 +267,8 @@ function cmdContextBudget(cwd, raw) {
     }
   }
 
-  // E-8: cache metrics — surface how much of the total context would be
-  // served from prompt cache when Opus 4.7 cache_control is active.
+  // E-8: cache metrics — how much of the total context is the stable set that
+  // agents re-read, which the host serves from its prompt cache when it can.
   const { buildCachedContext } = require('./core.cjs');
   let cache = null;
   try {
@@ -277,10 +277,10 @@ function cmdContextBudget(cwd, raw) {
     const eligiblePct = totalTokens > 0
       ? Math.round((cacheTokens / totalTokens) * 1000) / 10
       : 0;
-    // The cached block is re-read into EVERY agent call, so its size is the
-    // project's largest recurring cost. This used to be measured and reported
-    // with no threshold attached, which meant a block that had grown to ~28k
-    // tokens of mostly closed history looked exactly like a healthy one.
+    // The stable planning files; state.md among them is re-read on every agent
+    // call, the project's largest recurring cost. This used to be measured and
+    // reported with no threshold attached, which meant a block that had grown to
+    // ~28k tokens of mostly closed history looked exactly like a healthy one.
     // Classifying it is what turns the measurement into a signal.
     const { CACHE_BLOCK_WARN_TOKENS, CACHE_BLOCK_CRIT_TOKENS, CACHE_FILE_WARN_TOKENS } = require('./constants.cjs');
     const largest = cached.blocks
@@ -292,12 +292,15 @@ function cmdContextBudget(cwd, raw) {
     else if (cacheTokens >= CACHE_BLOCK_CRIT_TOKENS) cacheStatus = 'critical';
     else if (cacheTokens >= CACHE_BLOCK_WARN_TOKENS) cacheStatus = 'warn';
 
+    // PAN primes no cache (ADR-0023, amended): an absent block means nothing to
+    // measure, not that the host stops caching.
     const advice = cacheStatus === 'absent'
-      ? 'no cacheable context files — every agent call re-sends its context uncached'
+      ? 'none of the stable planning files exist yet, so there is nothing to measure'
       : cacheStatus === 'ok'
         ? null
-        : `cached context is re-read on every agent call; largest file ${largest[0].path} (~${largest[0].tokens} tokens)`
-          + (largest[0].path.endsWith('state.md') ? ' — run `pan-tools state compact`' : '');
+        : `stable planning files past the budget; largest file ${largest[0].path} (~${largest[0].tokens} tokens)`
+          + (largest[0].path.endsWith('state.md') ? ' — re-read on every agent call; run `pan-tools state compact`'
+            : largest[0].path.endsWith('roadmap.md') ? ' — read whole by the roadmapper and milestone work; run `pan-tools roadmap compact`' : '');
 
     // Lifetime signal from the ledger (suspect rows excluded — they carry
     // poisoned counters, not real writes). Absent ledger → zero rows, no advice.

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

@@ -65,12 +65,14 @@ const PROVIDER_MODELS = {
 // PROVIDER_MODELS, provider-qualified; `default` is Anthropic as it is there.
 // 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).
+// models.dev lists `anthropic/claude-sonnet-5-5` (api.json, read 2026-10-03). The fast
+// tier follows the `haiku` alias, which resolves to Haiku 5.5 on the Anthropic API from
+// Claude Code 2.1.293; models.dev lists `anthropic/claude-haiku-5-5` (read 2026-10-10).
 const OPENCODE_MODELS = {
-  anthropic: { reasoning: 'inherit', mid: 'anthropic/claude-sonnet-5-5', fast: 'anthropic/claude-haiku-4-5' },
+  anthropic: { reasoning: 'inherit', mid: 'anthropic/claude-sonnet-5-5', fast: 'anthropic/claude-haiku-5-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' },
+  default:   { reasoning: 'inherit', mid: 'anthropic/claude-sonnet-5-5', fast: 'anthropic/claude-haiku-5-5' },
 };
 
 /**
@@ -389,6 +391,32 @@ function safeReadFile(filePath) {
   }
 }
 
+// ─── Line endings ───────────────────────────────────────────────────────────
+// A Windows working tree (core.autocrlf=true) holds planning files with CRLF
+// endings, and a parser written for '\n' finds nothing in them without saying so:
+// on 2026-10-04 every Windows field project measured was CRLF throughout, and the
+// memory optimizer, the must-haves parser and `frontmatter set` had all been
+// silently no-op (or worse) there. Parse on LF; write back in the file's own ending.
+
+/** LF text: CRLF → LF and a leading BOM dropped. */
+function toLf(text) {
+  return String(text == null ? '' : text).replace(/^/, '').replace(/\r\n/g, '\n');
+}
+
+/** The ending a text mostly uses: '\r\n' when its CRLF lines outnumber its bare LF ones. */
+function dominantEol(text) {
+  const s = String(text == null ? '' : text);
+  const crlf = (s.match(/\r\n/g) || []).length;
+  const lf = (s.match(/\n/g) || []).length - crlf;
+  return crlf > lf ? '\r\n' : '\n';
+}
+
+/** LF text given back in the ending `eol` names. */
+function withEol(text, eol) {
+  const s = String(text == null ? '' : text);
+  return eol === '\r\n' ? s.replace(/\r?\n/g, '\r\n') : s;
+}
+
 /**
  * Load project config from .planning/config.json, merging with defaults.
  * Handles nested config sections (planning.*, workflow.*, git.*) and flat keys.
@@ -462,10 +490,10 @@ function loadConfig(cwd) {
       // Cost dashboard config: `cost.rates` per-model overrides (surfaced so the
       // documented override actually reaches cost.cjs — it was dropped before).
       cost: parsed.cost || {},
-      // Prompt-cache config: `cache.extra_files` lets a project add its own
-      // stable documents to the cached context block. Needed because the
-      // built-in list is the phase-model spine, so a focus-model project had
-      // an empty block and therefore no prompt caching at all.
+      // Cache config: `cache.extra_files` lets a project add its own stable
+      // documents to the block `cache prime` and the size checks measure. Needed
+      // because the built-in list is the phase-model spine, so a focus-model
+      // project had an empty block and nothing measured.
       cache: parsed.cache || {},
       // ADR-0031: project build/verification commands. null = not configured
       // (focus-auto --clean-seal then asks or skips rather than guessing).
@@ -634,7 +662,7 @@ function searchPhaseInDir(baseDir, relBase, normalized) {
   try {
     const entries = fs.readdirSync(baseDir, { withFileTypes: true });
     const dirs = entries.filter(e => e.isDirectory()).map(e => e.name).sort((a, b) => comparePhaseNum(a, b));
-    const match = dirs.find(d => d.startsWith(normalized));
+    const match = dirs.find(d => d === normalized || d.startsWith(normalized + '-'));
     if (!match) return null;
 
     const dirMatch = match.match(PHASE_DIR_RE);
@@ -785,7 +813,11 @@ function getRoadmapPhaseInternal(cwd, phaseNum) {
     const restOfContent = content.slice(headerIndex);
     const nextHeaderMatch = restOfContent.match(/\n#{2,4}\s+Phase\s+\d/i);
     const sectionEnd = nextHeaderMatch ? headerIndex + nextHeaderMatch.index : content.length;
-    const section = content.slice(headerIndex, sectionEnd).trim();
+    let section = content.slice(headerIndex, sectionEnd).trim();
+    // A phase moved out by `roadmap compact` leaves a stub; the full section
+    // (and any model_tier override with it) is in roadmap-history.md.
+    const compacted = require('./roadmap-compact.cjs').compactedPhaseSection(cwd, unpadded, section);
+    if (compacted && compacted.section) section = compacted.section;
 
     const goalMatch = section.match(/(?:\*\*Goal:\*\*|\*\*Goal\*\*:)\s*([^\n]+)/i);
     const goal = goalMatch ? goalMatch[1].trim() : null;
@@ -796,6 +828,7 @@ function getRoadmapPhaseInternal(cwd, phaseNum) {
       phase_name: phaseName,
       goal,
       section,
+      ...(compacted ? { compacted: true } : {}),
     };
   } catch {
     return null;
@@ -1362,12 +1395,12 @@ function scanPendingTodos(cwd, area) {
  *
  * Reads files from .planning/ that are stable across agent calls within a phase
  * (project.md, requirements.md, roadmap.md, state.md, standards.md). Each block
- * is tagged `cache: true` so the host runtime (or installer) can translate to
- * the appropriate per-runtime caching syntax (Anthropic cache_control, etc.).
+ * is tagged `cache: true`. Nothing translates that tag into a cache marker: the
+ * host caches each agent's prompt prefix by itself, so this list is what PAN
+ * measures (context-budget, hygiene's cache-context check), not what it primes.
  *
  * Files that don't exist are skipped silently. The order matches the file list
- * in constants.cjs to keep prompt prefixes byte-stable across calls (which is
- * what cache key matching requires).
+ * in constants.cjs, so the `sha` of an unchanged set stays the same.
  *
  * @param {string} cwd - Project root
  * @returns {{blocks: Array<{path: string, content: string, cache: true}>, total_bytes: number, sha: string}}
@@ -1380,14 +1413,12 @@ function buildCachedContext(cwd) {
   const hasher = crypto.createHash('sha256');
 
   // The built-in list is the PHASE-model spine. A focus-model project has none
-  // of those files, so its cached block came out empty and it silently received
-  // no prompt caching at all. `cache.extra_files` lets such a project name its
-  // own stable documents rather than PAN inventing a convention it doesn't
-  // otherwise define.
+  // of those files, so its measured block came out empty and the size checks had
+  // nothing to read. `cache.extra_files` lets such a project name its own stable
+  // documents rather than PAN inventing a convention it doesn't otherwise define.
   //
   // Entries are planning-root-relative, must stay inside it, and are appended
-  // after the built-ins so the prefix stays byte-stable for projects that set
-  // nothing — changing the prefix would invalidate every existing cache key.
+  // after the built-ins, so the `sha` of a project that sets nothing does not change.
   const extra = [];
   try {
     const configured = loadConfig(cwd)?.cache?.extra_files;
@@ -1468,6 +1499,9 @@ module.exports = {
   error,
   verbose,
   safeReadFile,
+  toLf,
+  dominantEol,
+  withEol,
   loadConfig,
   isGitIgnored,
   isGitRepo,

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

@@ -39,7 +39,7 @@ const os = require('os');
 const path = require('path');
 const { output, error, loadConfig } = require('./core.cjs');
 const { planningPath } = require('./utils.cjs');
-const { readRecords, computeCost, effectiveRates, isSuspectRecord, isEmptyRecord, METRICS_DIR, TOKENS_FILE } = require('./cost.cjs');
+const { readRecords, computeCost, effectiveRates, isSuspectRecord, isEmptyRecord, LONG_PROMPT_THRESHOLD, METRICS_DIR, TOKENS_FILE } = require('./cost.cjs');
 
 const SCHEMA_V = 4; // matches hooks/pan-cost-logger.js SCHEMA_V
 const MAIN_THREAD_AGENT = '(main thread)';
@@ -144,6 +144,17 @@ function sumTranscriptUsage(file) {
       totals.cache_write_1h_tokens = (totals.cache_write_1h_tokens || 0) + num(cc, 'ephemeral_1h_input_tokens');
       totals.cache_write_5m_tokens = (totals.cache_write_5m_tokens || 0) + num(cc, 'ephemeral_5m_input_tokens');
     }
+    // A request whose prompt is over LONG_PROMPT_THRESHOLD bills at a model's long
+    // rate where it has one (Haiku 5.5); the same rule as the cost-logger hook.
+    const prompt = num(u, 'input_tokens') + num(u, 'cache_read_input_tokens') + num(u, 'cache_creation_input_tokens');
+    if (prompt > LONG_PROMPT_THRESHOLD) {
+      const lp = totals.long_prompt || (totals.long_prompt = { above: LONG_PROMPT_THRESHOLD, input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_write_tokens: 0, cache_write_1h_tokens: 0 });
+      lp.input_tokens += num(u, 'input_tokens');
+      lp.output_tokens += num(u, 'output_tokens');
+      lp.cache_read_tokens += num(u, 'cache_read_input_tokens');
+      lp.cache_write_tokens += num(u, 'cache_creation_input_tokens');
+      if (cc && typeof cc === 'object') lp.cache_write_1h_tokens += num(cc, 'ephemeral_1h_input_tokens');
+    }
   }
   totals.turns = byMessage.size;
   let best = null;
@@ -304,6 +315,7 @@ function makeRow(fields) {
     ...(typeof fields.usage.cache_write_1h_tokens === 'number'
       ? { cache_write_1h_tokens: fields.usage.cache_write_1h_tokens, cache_write_5m_tokens: fields.usage.cache_write_5m_tokens || 0 }
       : {}),
+    ...(fields.usage.long_prompt ? { long_prompt: fields.usage.long_prompt } : {}),
     cost_usd: null,
     duration_ms: fields.usage.first_ts && fields.usage.last_ts ? Date.parse(fields.usage.last_ts) - Date.parse(fields.usage.first_ts) : null,
     phase: null,