pan-wizard 3.27.0 → 3.29.0

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

@@ -47,19 +47,39 @@ const TOKENS_FILE = 'tokens.jsonl';
  * Override per-model in config.json → cost.rates.
  */
 const DEFAULT_RATES = {
-  // Anthropic — verified against platform pricing 2026-08. Opus 4.6+/Opus 5 are
+  // Anthropic — verified against platform pricing 2026-09-10. Opus 4.6+/Opus 5 are
   // $5/$25 (the old $15/$75 Opus pricing ended with the 4.5 generation). Cache
-  // rates follow Anthropic's convention: read ≈ 0.1× input, write ≈ 1.25× input.
+  // rates follow Anthropic's convention: read ≈ 0.1× input, write ≈ 1.25× input —
+  // EXCEPT Fable 5.1, whose cache reads bill at 0.025× input ($0.25). Fable 5.1
+  // needs its own row: without it the family-prefix fallback priced its reads at
+  // the Fable 5 rate, 4× too high on the model the `fable`/`best` aliases resolve to
+  // (model-config, read 2026-09-10: neither Fable model is any plan's default), and
+  // cached re-reads are the bulk of PAN's traffic (ADR-0044).
+  'claude-fable-5-1':   { input: 10.0, output: 50.0, cache_read: 0.25, cache_write: 12.5 },
   'claude-fable-5':     { input: 10.0, output: 50.0, cache_read: 1.0,  cache_write: 12.5 },
+  // Mythos 5.1 / Mythos 5 (limited availability) — platform.claude.com/docs/en/about-claude/pricing,
+  // read 2026-09-10: $10/$50; the page's cache footnote names Fable 5.1 AND Mythos 5.1 as
+  // the two models whose cache reads bill at 0.025× input; Mythos 5 follows the 0.1× rule.
+  // Added for reality check R7: resolveRate returned null for both ids.
+  'claude-mythos-5-1':  { input: 10.0, output: 50.0, cache_read: 0.25, cache_write: 12.5 },
+  'claude-mythos-5':    { input: 10.0, output: 50.0, cache_read: 1.0,  cache_write: 12.5 },
   'claude-opus-5':      { input: 5.0,  output: 25.0, cache_read: 0.5,  cache_write: 6.25 },
   'claude-opus-4-8':    { input: 5.0,  output: 25.0, cache_read: 0.5,  cache_write: 6.25 },
   'claude-opus-4-7':    { input: 5.0,  output: 25.0, cache_read: 0.5,  cache_write: 6.25 },
   'claude-opus-4-6':    { input: 5.0,  output: 25.0, cache_read: 0.5,  cache_write: 6.25 },
-  // Sonnet 5 standard is $3/$15; a launch promo runs $2/$10 through 2026-08-31.
-  // We track the stable post-promo rate (the table is indicative; the staleness
-  // checker flags it for re-verification).
-  'claude-sonnet-5':    { input: 3.0,  output: 15.0, cache_read: 0.3,  cache_write: 3.75 },
+  // Opus 4.5 (dated id claude-opus-4-5-20251101) — same pricing page, read 2026-09-10:
+  // $5/$25/$0.50/$6.25. Without this row the dated id had no family prefix to land on
+  // and priced as null (R7).
+  'claude-opus-4-5':    { input: 5.0,  output: 25.0, cache_read: 0.5,  cache_write: 6.25 },
+  // Sonnet 5 is $2/$10: the launch price announced as introductory through
+  // 2026-08-31 was made permanent and the scheduled rise to $3/$15 cancelled
+  // (pricing page, read 2026-09-10). Lesson: never write down a pre-announced
+  // price — this row carried the future rate for a month and over-billed by half.
+  'claude-sonnet-5':    { input: 2.0,  output: 10.0, cache_read: 0.20, cache_write: 2.50 },
   'claude-sonnet-4-6':  { input: 3.0,  output: 15.0, cache_read: 0.3,  cache_write: 3.75 },
+  // Sonnet 4.5 (dated id claude-sonnet-4-5-20250929) — pricing page, read 2026-09-10:
+  // $3/$15/$0.30/$3.75 (the pre-Sonnet-5 rate; Sonnet 5 is $2/$10). R7.
+  'claude-sonnet-4-5':  { input: 3.0,  output: 15.0, cache_read: 0.3,  cache_write: 3.75 },
   'claude-haiku-4-5':   { input: 1.0,  output: 5.0,  cache_read: 0.1,  cache_write: 1.25 },
 
   // OpenAI — verified against published pricing 2026-08. Prompt caching is a 90%
@@ -106,6 +126,83 @@ function familyPrefixRate(rates, model) {
   return families.length > 0 ? rates[families[0]] : null;
 }
 
+// ─── Claude Code `modelPricing` as a rate source (2026-09) ──────────────────
+//
+// Claude Code ≥2.1.243 lets an organisation pin contracted per-model rates in
+// MANAGED settings — `modelPricing: { "<modelId>": { inputCostPer1MTokens,
+// outputCostPer1MTokens } }` (settings-reference, read 2026-09-10) — and prices
+// its own /usage with them. Honouring the same block keeps PAN's ledger on the
+// numbers the organisation actually pays. The shape carries no cache fields, so
+// cache rates are DERIVED: the family's own multipliers when DEFAULT_RATES knows
+// the family (Fable 5.1 reads bill at 0.025× input, not 0.1×), otherwise the
+// Anthropic convention (read 0.1×, write 1.25×).
+
+const round6 = (n) => Number(n.toFixed(6));
+
+function ratesFromModelPricing(modelPricing) {
+  const out = {};
+  if (!modelPricing || typeof modelPricing !== 'object' || Array.isArray(modelPricing)) return out;
+  for (const [id, p] of Object.entries(modelPricing)) {
+    if (!p || typeof p !== 'object') continue;
+    const input = Number(p.inputCostPer1MTokens);
+    const output = Number(p.outputCostPer1MTokens);
+    if (!Number.isFinite(input) || !Number.isFinite(output) || input < 0 || output < 0) continue;
+    const fam = DEFAULT_RATES[id] || familyPrefixRate(DEFAULT_RATES, id);
+    const readMult = fam && fam.input > 0 ? fam.cache_read / fam.input : 0.1;
+    const writeMult = fam && fam.input > 0 ? fam.cache_write / fam.input : 1.25;
+    out[id] = { input, output, cache_read: round6(input * readMult), cache_write: round6(input * writeMult) };
+  }
+  return out;
+}
+
+// Where Claude Code reads managed settings (code.claude.com/docs/en/managed-settings,
+// read 2026-09-10): macOS `/Library/Application Support/ClaudeCode`, Linux and WSL
+// `/etc/claude-code`, Windows `C:\Program Files\ClaudeCode`. Claude Code does NOT
+// read the legacy Windows path `C:\ProgramData\ClaudeCode` — so neither does PAN.
+// `managed-settings.json` is merged first, then every `*.json` in
+// `managed-settings.d/` in alphabetical order (hidden files skipped), later
+// files winning. `PAN_MANAGED_SETTINGS_DIR` redirects the lookup (tests, and
+// hosts that relocate the directory).
+function managedSettingsDir(platform = process.platform, env = process.env) {
+  if (env.PAN_MANAGED_SETTINGS_DIR) return env.PAN_MANAGED_SETTINGS_DIR;
+  // `path.win32.join`, not `path.join`: the platform is an argument, so a POSIX
+  // host asked for the win32 directory must still get backslashes. On Windows the
+  // two are the same function.
+  if (platform === 'win32') return path.win32.join(env.ProgramFiles || 'C:\\Program Files', 'ClaudeCode');
+  if (platform === 'darwin') return '/Library/Application Support/ClaudeCode';
+  return '/etc/claude-code';
+}
+
+function loadManagedModelPricing(dir = managedSettingsDir()) {
+  const files = [path.join(dir, 'managed-settings.json')];
+  try {
+    const dropIns = path.join(dir, 'managed-settings.d');
+    files.push(...fs.readdirSync(dropIns)
+      .filter(f => !f.startsWith('.') && f.endsWith('.json'))
+      .sort()
+      .map(f => path.join(dropIns, f)));
+  } catch { /* no drop-in directory */ }
+  let merged = null;
+  for (const f of files) {
+    let parsed;
+    try { parsed = JSON.parse(fs.readFileSync(f, 'utf8')); } catch { continue; }
+    const mp = parsed && typeof parsed === 'object' ? parsed.modelPricing : null;
+    if (mp && typeof mp === 'object' && !Array.isArray(mp)) merged = { ...(merged || {}), ...mp };
+  }
+  return merged;
+}
+
+// The rate table a cost computation actually sees. Precedence, highest first:
+//   1. `.planning/config.json → cost.rates` — PAN's explicit per-project override
+//   2. managed `modelPricing` — the organisation's contracted rates
+//   3. DEFAULT_RATES — resolveRate's own fallback when neither names the model
+// Returns undefined (not {}) when nothing overrides, so callers keep the exact
+// pre-2026-09 behaviour of passing no config rates.
+function effectiveRates(config, managedPricing = loadManagedModelPricing()) {
+  const rates = { ...ratesFromModelPricing(managedPricing), ...(config?.cost?.rates || {}) };
+  return Object.keys(rates).length > 0 ? rates : undefined;
+}
+
 function resolveRate(model, tier, configRates) {
   // Config overrides win over the built-in table — including for versioned ids.
   // Without the family-prefix pass here, a cost.rates override keyed on a family
@@ -187,7 +284,7 @@ function appendRecord(cwd, rec) {
   // time, so the two producers priced identical tokens differently.
   normalized.cost_usd = typeof rec.cost_usd === 'number'
     ? rec.cost_usd
-    : computeCost(normalized, loadConfig(cwd)?.cost?.rates);
+    : computeCost(normalized, effectiveRates(loadConfig(cwd)));
 
   try {
     fs.mkdirSync(metricsDir(cwd), { recursive: true });
@@ -233,30 +330,74 @@ function readRecords(cwd) {
  */
 /**
  * A record is "suspect" when its token counts are physically implausible for a
- * single subagent — the signature of the pre-v3.12.4 transcript-oversum bug
- * (billions of cache-read, cache-read dwarfing input, 100% cache-hit). Such
- * records are quarantined from aggregates so a poisoned ledger can't report
- * millions of dollars. See docs/FIELD-REPORT-army-2026-06.md.
+ * single subagent — the oversum signature: a session's cumulative usage booked
+ * to one subagent row (billions of cache-read, cache-read dwarfing input, 100%
+ * cache-hit). Written by pre-v3.12.4 hooks, and by the parent-transcript slice
+ * path of every later hook up to v3.28 whenever a slice started at cursor 0 on a
+ * long-lived session. Such records are quarantined from aggregates so a
+ * poisoned ledger can't report millions of dollars.
+ * See docs/FIELD-REPORT-army-2026-06.md.
  * @param {Object} r - a cost record
  * @returns {boolean}
  */
+// No single subagent runs for six hours — the longest native-workflow phase runs
+// measured in the harness finish inside an hour — while a parent-transcript slice
+// that spans a working day, or the idle night between two stops, does. Mirrored by
+// the hooks' SLICE_MAX_DURATION_MS, which nulls the span on write. Calibrated on
+// eleven field ledgers (2026-09): of the timed rows the old ratio rule flagged,
+// 55 spanned under three hours and 12 spanned six to twenty-four — the latter all
+// parent slices booked to a `general-purpose` or workflow subagent.
+const SUSPECT_MAX_DURATION_MS = 6 * 60 * 60 * 1000;
+
 function isSuspectRecord(r) {
   if (!r || typeof r !== 'object') return false;
+  // Rows measured from a transcript that belongs to exactly one actor — the
+  // subagent's own file (v3.29 hooks, `cost rebuild`) or the main thread's
+  // session file (`cost rebuild`) — cannot carry another actor's usage, so the
+  // oversum signature does not apply to them: a 24-day main thread with
+  // billions of cached reads is simply a long session, measured exactly.
+  if (r.token_source === 'agent-transcript' || r.token_source === 'session-transcript') return false;
   const cr = r.cache_read_tokens || 0;
   const io = (r.input_tokens || 0) + (r.output_tokens || 0);
   if (cr > 5e8) return true;                        // no scoped subagent re-reads >500M cached tokens
-  if (cr > 1e7 && cr > 100 * (io + 1)) return true; // cache-read dwarfs input+output
   if ((r.output_tokens || 0) > 1e7) return true;    // ~10M output = cumulative oversum
+  const dur = typeof r.duration_ms === 'number' ? r.duration_ms : null;
+  if (dur != null && dur > SUSPECT_MAX_DURATION_MS) return true; // a six-hour-plus "subagent" is a session's history
+  // Cache-read dwarfing input+output is the oversum signature ONLY for a row the
+  // hook could not time (pre-v3.20 rows, unreadable transcripts). A timed row
+  // with a plausible span is a real agent: under prompt caching every turn
+  // re-reads the cached context, so a hundred-turn agent legitimately reads
+  // 300× more cached tokens than it writes. Applied to timed rows, this rule
+  // had excluded fifty sub-hour agents (~3 billion real cache-read tokens)
+  // from eleven field ledgers (2026-09).
+  if (dur == null && cr > 1e7 && cr > 100 * (io + 1)) return true;
   return false;
 }
 
+/**
+ * A record is "empty" when it carries no tokens on any axis and no model: a
+ * spawn the hook could not measure — a sibling stop that arrived before the
+ * shared parent transcript had grown (the pre-v3.29 slice path), or a payload
+ * with neither usage nor a readable transcript. It has no cost and no tokens;
+ * counting it as a call inflated call counts by up to 2x in the field (480 of
+ * 976 rows across eleven ledgers, 2026-09). A zero-token row that names a model
+ * is NOT empty — that is a measured run that happened to use nothing.
+ * @param {Object} r - a cost record
+ * @returns {boolean}
+ */
+function isEmptyRecord(r) {
+  if (!r || typeof r !== 'object') return false;
+  if (r.model) return false;
+  return !(r.input_tokens || r.output_tokens || r.cache_read_tokens || r.cache_write_tokens);
+}
+
 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;
   const config = loadConfig(cwd);
-  const configRates = config?.cost?.rates;
+  const configRates = effectiveRates(config);
 
   const filtered = records.filter(r => {
     if (!r.ts) return true;
@@ -275,6 +416,7 @@ function aggregate(cwd, opts) {
     cost_usd: 0,
     cost_unknown: 0,
     suspect_excluded: 0,
+    empty_excluded: 0,
     malformed_skipped: malformedSkipped,
   };
 
@@ -296,9 +438,11 @@ function aggregate(cwd, opts) {
   }
 
   for (const r of filtered) {
-    // Quarantine physically-impossible records (pre-v3.12.4 transcript-oversum
-    // bug) so a poisoned ledger doesn't poison the totals / HUD / /pan:cost.
+    // Quarantine physically-impossible records (the transcript-oversum
+    // signature) so a poisoned ledger doesn't poison the totals / HUD / /pan:cost.
     if (isSuspectRecord(r)) { totals.suspect_excluded += 1; continue; }
+    // Skip unmeasured spawns: no tokens, no model, nothing to price or count.
+    if (isEmptyRecord(r)) { totals.empty_excluded += 1; continue; }
     totals.calls += 1;
     totals.input_tokens += r.input_tokens || 0;
     totals.output_tokens += r.output_tokens || 0;
@@ -355,7 +499,12 @@ function renderTable(agg) {
   lines.push(window);
   lines.push('');
   lines.push('Totals');
-  lines.push(`  Calls              : ${agg.totals.calls}${agg.totals.malformed_skipped > 0 ? ` (+${agg.totals.malformed_skipped} malformed)` : ''}`);
+  const skipped = [
+    agg.totals.suspect_excluded > 0 ? `${agg.totals.suspect_excluded} suspect` : null,
+    agg.totals.empty_excluded > 0 ? `${agg.totals.empty_excluded} empty` : null,
+    agg.totals.malformed_skipped > 0 ? `${agg.totals.malformed_skipped} malformed` : null,
+  ].filter(Boolean);
+  lines.push(`  Calls              : ${agg.totals.calls}${skipped.length ? ` (excluded: ${skipped.join(', ')})` : ''}`);
   lines.push(`  Input tokens       : ${agg.totals.input_tokens.toLocaleString()}`);
   lines.push(`  Output tokens      : ${agg.totals.output_tokens.toLocaleString()}`);
   lines.push(`  Cache read         : ${agg.totals.cache_read_tokens.toLocaleString()}`);
@@ -442,7 +591,7 @@ function cmdCostClear(cwd, raw) {
 // Bump this whenever the table is re-verified; `models check` flags the table
 // once it is older than RATES_STALE_AFTER_DAYS (provider prices move faster
 // than PAN releases do).
-const RATES_VERIFIED_AT = '2026-08-03';
+const RATES_VERIFIED_AT = '2026-09-10';
 const RATES_STALE_AFTER_DAYS = 180;
 const RATE_TIERS = ['reasoning', 'mid', 'fast'];
 
@@ -460,7 +609,9 @@ function checkRatesStaleness(now = new Date()) {
 }
 
 function cmdModelsCheck(raw) {
-  const result = checkRatesStaleness();
+  // Surface the managed rates too: an organisation that pins `modelPricing`
+  // should be able to see that PAN found the block, not infer it from totals.
+  const result = { ...checkRatesStaleness(), managed_model_pricing: Object.keys(loadManagedModelPricing() || {}) };
   const human = result.stale
     ? `Rate table verified ${result.rates_verified_at} (${result.age_days} days ago) — STALE: re-verify provider pricing and bump RATES_VERIFIED_AT in cost.cjs`
     : `Rate table verified ${result.rates_verified_at} (${result.age_days} days ago) — OK`;
@@ -473,9 +624,14 @@ module.exports = {
   readRecords,
   aggregate,
   isSuspectRecord,
+  isEmptyRecord,
   renderTable,
   renderChart,
   resolveRate,
+  ratesFromModelPricing,
+  managedSettingsDir,
+  loadManagedModelPricing,
+  effectiveRates,
   checkRatesStaleness,
   cmdCostReport,
   cmdCostAppend,

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

@@ -0,0 +1,56 @@
+'use strict';
+/**
+ * Foreign planning-tree detection (reality check RC17 / plan item R15, 2026-09-10).
+ *
+ * gsd-core (open-gsd/gsd-core, the continuation of Get Shit Done) writes a `.planning/`
+ * directory with the same core files PAN's pre-v2.2 layout used — STATE.md, ROADMAP.md,
+ * PROJECT.md, REQUIREMENTS.md, MILESTONES.md in uppercase. To PAN's hygiene those read
+ * as LEGACY PAN files, and `hygiene clean --apply` would rename another tool's state.
+ * `validate health` would call the tree broken; `init new-project` would scaffold PAN
+ * files into it. This module answers one question — does this tree belong to another
+ * tool? — from POSITIVE markers PAN never writes (FOREIGN_PLANNING_MARKERS in
+ * constants.cjs, sourced from gsd-core's docs/USER-GUIDE.md, read 2026-09-10).
+ *
+ * Rule: foreign when any marker FILE exists, or at least two marker DIRECTORIES exist,
+ * or config.json carries any of the tool's flat dotted keys (PAN nests `workflow: {}`;
+ * gsd-core writes `"workflow.discuss_mode"`). An unreadable config.json is not evidence.
+ * Returns { tool, key, evidence[] } or null. Never throws.
+ */
+const fs = require('fs');
+const path = require('path');
+const { FOREIGN_PLANNING_MARKERS } = require('./constants.cjs');
+const { planningPath } = require('./utils.cjs');
+
+function detectForeignPlanningTree(planningDir) {
+  let entries;
+  try { entries = fs.readdirSync(planningDir, { withFileTypes: true }); } catch { return null; }
+  const names = new Set(entries.map(e => e.name));
+  const dirs = new Set(entries.filter(e => e.isDirectory()).map(e => e.name));
+  let cfg = null;
+  if (names.has('config.json')) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(path.join(planningDir, 'config.json'), 'utf8'));
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) cfg = parsed;
+    } catch { cfg = null; }
+  }
+  for (const [key, m] of Object.entries(FOREIGN_PLANNING_MARKERS)) {
+    const fileHits = m.files.filter(f => names.has(f));
+    const dirHits = m.dirs.filter(d => dirs.has(d));
+    const configHits = cfg ? m.configKeys.filter(k => Object.prototype.hasOwnProperty.call(cfg, k)) : [];
+    if (fileHits.length > 0 || dirHits.length >= 2 || configHits.length > 0) {
+      return {
+        tool: m.tool,
+        key,
+        evidence: [...fileHits, ...dirHits.map(d => d + '/'), ...configHits.map(k => 'config.json:' + k)],
+      };
+    }
+  }
+  return null;
+}
+
+/** Same check, addressed by project cwd (honours --planning-dir / --track). */
+function detectForeignPlanningTreeAt(cwd) {
+  return detectForeignPlanningTree(planningPath(cwd));
+}
+
+module.exports = { detectForeignPlanningTree, detectForeignPlanningTreeAt };

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

@@ -82,7 +82,11 @@ function cmdGitCommit(cwd, opts, raw) {
   const commitArgs = amend ? ['commit', '--amend', '--no-edit'] : ['commit', '-m', finalMessage];
   const r = execGit(cwd, commitArgs);
   if (r.exitCode !== 0) {
-    if (r.stdout.includes('nothing to commit') || r.stderr.includes('nothing to commit')) {
+    // Git says "nothing to commit" for a clean tree and "nothing added to commit but
+    // untracked files present" when the only changes are untracked. Both mean no change
+    // was NEEDED; only the first was recognised, so the second was reported as a failed
+    // commit with "unknown git error" (measured 2026-09-17).
+    if ((r.stdout + r.stderr).includes('nothing to commit') || (r.stdout + r.stderr).includes('nothing added to commit')) {
       // No error key, exit 0: nothing to commit means no change was NEEDED, not that
       // a change failed. Pinned as a success in CLI-REFERENCE ("Error Shape").
       output({ committed: false, reason: 'nothing_to_commit' }, raw, 'nothing to commit');

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

@@ -424,8 +424,10 @@ function fmtTokens(n) {
 /**
  * Assess whether a cost ledger is trustworthy enough to show dollar figures.
  * Two failure modes are treated as "don't quote a number":
- *   - legacy: more records were quarantined as implausible than survived (the
- *     pre-v3.12.4 transcript-oversum bug) — reset advised.
+ *   - legacy: more records were quarantined as implausible than were measured
+ *     (the transcript-oversum signature: a session's cumulative usage booked to
+ *     one subagent, written by hooks before v3.29) — quarantine advised.
+ *     Unmeasured spawns (`empty_excluded`) count on neither side.
  *   - unresolved: every surviving record lacks a resolvable model→rate, so the
  *     computed spend is a misleading $0 even though real tokens were spent.
  * Returns { ok:true } when figures are safe to display.
@@ -439,7 +441,7 @@ function ledgerReliability(totals) {
     const total = suspect + calls;
     return {
       ok: false, kind: 'legacy',
-      message: `${suspect} of ${total} cost records are implausible (the pre-v3.12.4 telemetry capture bug). Reset the ledger with <b>pan-tools cost clear</b> — records captured after the fix are accurate.`,
+      message: `${suspect} of ${total} measured cost records are implausible (a session's usage booked to one subagent — rows written by hooks before v3.29). Rebuild the ledger from the transcripts with <b>pan-tools cost rebuild --apply</b> (dry-run first without the flag); if the transcripts are gone, quarantine it with <b>pan-tools hygiene clean --apply</b>. Rows captured by v3.29+ hooks are attributed per agent.`,
     };
   }
   if (calls > 0 && unknown >= calls) {

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

@@ -5,7 +5,9 @@
  * campaigns run: runtime installs fall behind the latest version, legacy
  * uppercase planning filenames linger from pre-v2.2 layouts, atomic-write
  * .tmp orphans survive crashes, per-agent memory logs grow past the cap,
- * cost ledgers written by pre-v3.12.4 hooks are 100% poisoned, telemetry
+ * cost ledgers carry oversum rows (a session's cumulative usage booked to one
+ * subagent — pre-v3.12.4 hooks wrote nothing else, and the parent-transcript
+ * slice path kept producing them up to v3.28), telemetry
  * trace sessions pile up unboundedly, and stray fragment `.planning/`
  * directories appear where a mapping step once ran.
  *
@@ -39,9 +41,11 @@ const {
   CHARS_PER_TOKEN,
   STATE_FILE,
 } = require('./constants.cjs');
-const { planningPath, planningRel } = require('./utils.cjs');
+const { planningPath, planningRel, detectPlanningModel } = require('./utils.cjs');
+const { detectForeignPlanningTree } = require('./foreign-planning.cjs');
 const { listMemoryAgents, readMemory, compactMemory } = require('./memory.cjs');
 const { readRecords, isSuspectRecord, METRICS_DIR, TOKENS_FILE } = require('./cost.cjs');
+const { assessCacheTtl } = require('./context-budget.cjs');
 const { planningRootRel, planningRoots, withPlanningRoot, describePlanningRoot, TRACKS_DIR } = require('./planning-root.cjs');
 
 /** Runtime config dirs a PAN install can live in, relative to project root. */
@@ -251,7 +255,8 @@ function recordMass(r) {
 }
 
 /**
- * H-5: cost ledger dominated by physically implausible (pre-v3.12.4) records.
+ * H-5: cost ledger dominated by physically implausible records — the oversum
+ * signature, a session's cumulative usage booked to one subagent row.
  *
  * Gated on token MASS as well as record count. A count-only gate passes a ledger
  * whose few bad rows carry most of the tokens — field case: 24% of rows suspect
@@ -284,7 +289,7 @@ function checkCostLedger(cwd) {
       : 'token mass';
   findings.push(mkFinding('poisoned-ledger', 'critical',
     planningRel(METRICS_DIR, TOKENS_FILE),
-    `${suspect}/${records.length} records suspect (${Math.round(ratio * 100)}% of rows, ${Math.round(massRatio * 100)}% of token mass) — pre-v3.12.4 oversum signature, tripped on ${basis}; aggregates quarantine them but the file is dead weight`,
+    `${suspect}/${records.length} records suspect (${Math.round(ratio * 100)}% of rows, ${Math.round(massRatio * 100)}% of token mass) — oversum signature (a session's cumulative usage booked to one subagent row), tripped on ${basis}; aggregates quarantine them but the file is dead weight. Run \`cost rebuild\` first while the session transcripts still exist — quarantining moves the whole ledger aside, and a rebuild afterwards has no rows left to keep`,
     { action: 'quarantine-ledger' }));
   return { findings };
 }
@@ -456,6 +461,17 @@ function checkCachedContext(cwd) {
       `~${fmtTokens(tokens)} tokens re-read on every agent call (warn ${fmtTokens(CACHE_FILE_WARN_TOKENS)})${suffix}`,
       fix));
   }
+
+  // Lifetime signal (ADR-0046 D5): the ledger shows cache WRITES that followed
+  // an idle gap of five to sixty minutes — misses a one-hour subagent cache
+  // lifetime would have turned into hits. Informational and never fixable: the
+  // remedy is a Claude Code setting the user weighs against the 2× write price.
+  try {
+    const ttl = assessCacheTtl(readRecords(cwd).filter(r => !isSuspectRecord(r)));
+    if (ttl.recommend) {
+      findings.push(mkFinding('cache-context', ttl.severity, planningRel(path.join(METRICS_DIR, TOKENS_FILE)), ttl.advice, null));
+    }
+  } catch { /* no ledger, or unreadable — nothing to say */ }
   return { findings };
 }
 
@@ -481,15 +497,11 @@ function checkPlanningFragment(cwd) {
   const dir = planningPath(cwd);
   let entries = [];
   try { entries = fs.readdirSync(dir); } catch { return { findings, planning_exists: false }; }
-  const lower = entries.map(e => e.toLowerCase());
-  // Spine = anything that marks a deliberate PAN workflow: the phase model
-  // (project/state/phases/roadmap/requirements/milestones) OR the focus model
-  // (focus/quick) OR an orchestration campaign. A dir holding only generated
-  // artifacts (codebase maps, metrics, traces) is a stray fragment.
-  const SPINE = ['project.md', 'state.md', 'phases', 'roadmap.md', 'requirements.md',
-    'milestones', 'focus', 'quick', 'orchestration'];
-  const hasSpine = SPINE.some(s => lower.includes(s));
-  if (!hasSpine && entries.length > 0) {
+  // A spine is whatever marks a deliberate PAN workflow — the phase model, the focus
+  // model, or an orchestration campaign (PLANNING_MODEL_MARKERS, shared with
+  // `validate health` so the two verbs cannot disagree about a tree). A dir holding
+  // only generated artifacts (codebase maps, metrics, traces) is a stray fragment.
+  if (detectPlanningModel(dir).model === 'fragment') {
     findings.push(mkFinding('planning-fragment', 'info', planningRootRel(),
       `.planning exists with ${entries.length} entr${entries.length === 1 ? 'y' : 'ies'} (${entries.slice(0, 5).join(', ')}) but no workflow spine (project/state/phases/focus/…) — likely a stray partial run; review and delete manually`,
       null));
@@ -517,6 +529,18 @@ function checkPlanningFragment(cwd) {
  */
 function scanOneRoot(cwd, root, opts) {
   return withPlanningRoot(root.rel, () => {
+    // A .planning/ written by ANOTHER tool (gsd-core shares the directory name and
+    // PAN's pre-v2.2 uppercase file names) must never be "repaired": the legacy
+    // rename would rename its state files. One warn finding, nothing fixable, and
+    // none of the per-tree checks run on it. Reality check R15.
+    const foreign = detectForeignPlanningTree(planningPath(cwd));
+    if (foreign) {
+      const f = mkFinding('foreign-planning-tree', 'warn', planningRel(),
+        `planning tree belongs to ${foreign.tool} (${foreign.evidence.join(', ')}) — PAN will not rename or repair its files; run PAN with --planning-dir to give it a tree of its own (ADR-0043)`,
+        null);
+      f.track = root.name;
+      return { findings: [f], planning_exists: true };
+    }
     const fragment = checkPlanningFragment(cwd);
     const findings = [
       ...fragment.findings,
@@ -594,6 +618,12 @@ function applyFix(cwd, finding) {
   try {
     switch (fix.action) {
       case 'rename-lowercase': {
+        // Defence in depth for R15: the scan never emits this fix for a foreign tree,
+        // but a stale findings list or a hand-built one must not rename another
+        // tool's files either.
+        if (detectForeignPlanningTree(path.dirname(abs))) {
+          return { applied: false, detail: 'refused: this planning tree belongs to another tool (see the foreign-planning-tree finding)' };
+        }
         // Two-step rename: Windows treats case-only renames inconsistently
         // across fs layers, so hop through a temp name.
         const dir = path.dirname(abs);
@@ -630,16 +660,14 @@ function applyFix(cwd, finding) {
         const dest = `${abs}.quarantined-${stamp}`;
         fs.renameSync(abs, dest);
 
-        // The cursor is a per-transcript high-water mark INTO the ledger we just
-        // moved aside. Left behind it points at rows that are no longer there,
-        // so the fresh ledger starts mid-stream and the next slice is undercounted.
-        // A "fresh ledger" that inherits the old ledger's read position is not fresh.
-        let cursorNote = '';
-        try {
-          const cursor = path.join(path.dirname(abs), COST_CURSOR_FILE);
-          fs.unlinkSync(cursor);
-          cursorNote = ', cursor reset';
-        } catch { /* no cursor to reset */ }
+        // The cost cursor (COST_CURSOR_FILE) STAYS. It is a per-TRANSCRIPT
+        // high-water mark — how many records of each session transcript the
+        // hooks have already attributed — not a position in the ledger, so it
+        // has nothing to do with the file being moved aside. This step used to
+        // delete it as "a fresh ledger must not inherit the old read position",
+        // and the next SubagentStop then re-summed every session transcript from
+        // line 0: a fresh oversum row the day after each quarantine (field,
+        // 2026-08-25 → 08-26). Quarantine and poison had become a loop.
 
         // Quarantine leaves a dated copy behind, and nothing else ever removes
         // one. Run hygiene a few times over a year and the metrics dir fills
@@ -649,7 +677,7 @@ function applyFix(cwd, finding) {
 
         return {
           applied: true,
-          detail: `renamed to ${path.basename(dest)}${cursorNote}${prunedNote} — fresh ledger starts clean`,
+          detail: `renamed to ${path.basename(dest)}${prunedNote} — fresh ledger starts clean; transcript cursor kept`,
         };
       }
       default:

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

@@ -10,6 +10,7 @@ const { planningPath, phasesPath, filterPlanFiles, filterSummaryFiles, classifyP
 const { classifyPlanTier } = require('./phase.cjs');
 const { extractFrontmatter } = require('./frontmatter.cjs');
 const { detectLanguages } = require('./codebase.cjs');
+const { detectForeignPlanningTreeAt } = require('./foreign-planning.cjs');
 const { planningRootRel, describePlanningRoot, planningRoots, withPlanningRoot } = require('./planning-root.cjs');
 
 // ---- Git helpers ----
@@ -282,6 +283,13 @@ function cmdInitPlanPhase(cwd, phase, raw) {
  * @returns {void}
  */
 function cmdInitNewProject(cwd, raw) {
+  // Never scaffold PAN's files into a .planning/ another tool owns (R15). The error
+  // key carries the exit code; the fix is a separate tree via --planning-dir.
+  const foreign = detectForeignPlanningTreeAt(cwd);
+  if (foreign) {
+    output({ error: `planning tree belongs to ${foreign.tool}`, evidence: foreign.evidence, fix: 'Run PAN with --planning-dir <dir> to use a separate tree (ADR-0043)' }, raw);
+    return;
+  }
   const config = loadConfig(cwd);
 
   // Detect Brave Search API key availability

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

@@ -301,11 +301,17 @@ function selectMemory(cwd, agent, opts = {}) {
 /**
  * Memory-load telemetry gate (ADR-0036 acceptance signal). Estimates the tokens
  * of memory that would be injected whole (every agent log) and compares to the
- * median per-agent input from the trustworthy cost ledger (suspect records
+ * median per-agent PROMPT from the trustworthy cost ledger (suspect records
  * quarantined). Read-only, non-blocking; degrades to an absolute-token check
  * when the ledger is thin.
  *
- * @returns {{memory_tokens, agents, median_input_tokens, fraction, status, advisory}}
+ * The prompt is `input + cache_read + cache_write`, not `input` alone: under prompt
+ * caching the uncached remainder is tens of tokens, so dividing by it reported 1.8k
+ * of memory as 8,940% of a "median agent input" and called it critical (field sweep
+ * 2026-09-17). Memory is injected into the whole prompt, so the whole prompt is what
+ * it must be measured against.
+ *
+ * @returns {{memory_tokens, agents, median_prompt_tokens, fraction, status, advisory}}
  */
 function memoryLoadBudget(cwd, opts = {}) {
   const { agents } = listMemoryAgents(cwd);
@@ -317,12 +323,12 @@ function memoryLoadBudget(cwd, opts = {}) {
   let median = null;
   try {
     const cost = require('./cost.cjs');
-    const inputs = (cost.readRecords(cwd) || [])
-      .filter(r => !cost.isSuspectRecord(r))
-      .map(r => Number(r.input_tokens) || 0)
+    const prompts = (cost.readRecords(cwd) || [])
+      .filter(r => !cost.isSuspectRecord(r) && !cost.isEmptyRecord(r))
+      .map(r => (Number(r.input_tokens) || 0) + (Number(r.cache_read_tokens) || 0) + (Number(r.cache_write_tokens) || 0))
       .filter(n => n > 0)
       .sort((a, b) => a - b);
-    if (inputs.length) median = inputs[Math.floor(inputs.length / 2)];
+    if (prompts.length) median = prompts[Math.floor(prompts.length / 2)];
   } catch { /* thin/absent ledger — absolute-token check only */ }
 
   const fraction = median ? memoryTokens / median : null;
@@ -335,9 +341,9 @@ function memoryLoadBudget(cwd, opts = {}) {
   const advisory = status === 'ok'
     ? 'Memory-load within budget.'
     : `Memory injection is ~${memoryTokens} tokens across ${agents.length} agent log(s)` +
-      (fraction != null ? ` (~${Math.round(fraction * 100)}% of median agent input)` : '') +
+      (fraction != null ? ` (~${Math.round(fraction * 100)}% of a median agent prompt)` : '') +
       `. Bound it with cue-scoped 'memory select' or trim with 'memory compact <agent>'.`;
-  return { memory_tokens: memoryTokens, agents: agents.length, median_input_tokens: median, fraction, status, advisory };
+  return { memory_tokens: memoryTokens, agents: agents.length, median_prompt_tokens: median, fraction, status, advisory };
 }
 
 // ─── CLI command wrappers ────────────────────────────────────────────────────