pan-wizard 3.33.0 → 3.34.0

package/hooks/dist/pan-context-monitor.js

@@ -1,18 +1,43 @@
 #!/usr/bin/env node
 // Context Monitor - PostToolUse hook
-// Reads context metrics from the statusline bridge file and injects
-// warnings when context usage is high. This makes the AGENT aware of
-// context limits (the statusline only shows the user).
+// Works out how full the agent's context is and injects a note when the host
+// will compact it soon. This makes the AGENT aware of context limits (the
+// statusline only shows the user).
 //
 // How it works:
 // 1. The statusline hook writes metrics to <os tmpdir>/pan-hooks-<uid>/claude-ctx-{session_id}.json
 // 2. This hook reads those metrics after each tool use
-// 3. When remaining context drops below thresholds, it injects a warning
-//    as additionalContext, which the agent sees in its conversation
+// 3. When the room left before the host compacts drops below thresholds, it
+//    injects a note as additionalContext, which the agent sees in its conversation
 //
-// Thresholds:
-//   WARNING  (remaining <= 35%): Agent should wrap up current task
-//   CRITICAL (remaining <= 25%): Agent should stop immediately and save state
+// Without the status line. `claude -p` never runs the status line (checked
+// 2026-10-04), and a user may run their own, so the bridge is often missing. Then
+// the hook reads the session transcript the payload names: the newest assistant
+// record carries the usage of the API call that issued this tool call, and its
+// input + cache-read + cache-write tokens are what the status line reports as
+// `total_input_tokens` (code.claude.com/docs/en/statusline). The model id on that
+// record gives the window. A tool call inside a subagent is measured against the
+// subagent's own transcript, never the main session's: the payload carries
+// `agent_id` and still names the MAIN transcript (Claude Code 2.1.288, captured
+// 2026-10-04). Only a bounded tail of the file is read.
+//
+// What it measures (O7). Claude Code's percentages are against the full model
+// window, but the host compacts earlier: about 33K short of the auto-compact window
+// (CLAUDE_CODE_AUTO_COMPACT_WINDOW, then `autoCompactWindow` in settings, per model
+// or for all, else the model window) — about 967K on a 1M model by default — or at
+// CLAUDE_AUTOCOMPACT_PCT_OVERRIDE's share of the window when that is lower. With
+// token counts, the room left is measured against that point; without them,
+// against the model window.
+//
+// What it says (O7). No countdown: vendor guidance is that a visible remaining-
+// context figure makes a model wrap up early and cut corners, and a note after a
+// tool result that orders it to STOP reads like an injection. The note asks for a
+// checkpoint in state.md at the next natural stopping point, says compaction is
+// safe because PAN restores the state, and asks for no shortcuts.
+//
+// Thresholds (of the room before compaction):
+//   WARNING  (left <= 35%): checkpoint at the next natural stopping point
+//   CRITICAL (left <= 25%): checkpoint before the next step
 //
 // Debounce: 5 tool uses between warnings to avoid spam
 // Severity escalation bypasses debounce (WARNING -> CRITICAL fires immediately)
@@ -92,23 +117,267 @@ function bridgeDir() {
   } catch { return null; }
 }
 
-const WARNING_THRESHOLD = 35;  // remaining_percentage <= 35%
-const CRITICAL_THRESHOLD = 25; // remaining_percentage <= 25%
+const WARNING_THRESHOLD = 35;  // room left before compaction <= 35%
+const CRITICAL_THRESHOLD = 25; // room left before compaction <= 25%
 const STALE_SECONDS = 60;      // ignore metrics older than 60s
 const DEBOUNCE_CALLS = 5;      // min tool uses between warnings
+const MIN_COMPACT_WINDOW = 100000;
+const MAX_COMPACT_WINDOW = 1000000;
+// The host compacts this far short of its window, whatever the window: about 967K on
+// a native 1M window (code.claude.com/docs/en/model-config), and on 2026-10-04 a 100K
+// autoCompactWindow compacted after a call that measured 67,032 tokens and not after
+// one that measured 54,371 (harness context-note-headless). A margin proportional to
+// the window would have put that compaction at ~96.7K.
+const COMPACT_MARGIN = 33000;
+const STANDARD_WINDOW = 200000;
+const TRANSCRIPT_TAIL_BYTES = 256 * 1024;      // the first read from the end of the transcript
+const TRANSCRIPT_MAX_BYTES = 4 * 1024 * 1024;  // never read more than this of it
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/; // session and agent ids name files
+
+/**
+ * The token count at which the host compacts this session, or null when it does
+ * not compact: the compaction window less COMPACT_MARGIN, or the percentage
+ * override's share of the window when that is lower. Pure over its inputs.
+ *   modelWindow — context_window_size from the statusline
+ *   modelId     — the model id, for `modelSettings.<id>.autoCompactWindow`
+ *   env         — the environment (CLAUDE_CODE_AUTO_COMPACT_WINDOW,
+ *                 CLAUDE_AUTOCOMPACT_PCT_OVERRIDE, DISABLE_AUTO_COMPACT)
+ *   settings    — settings objects, highest precedence first (local, project, user)
+ */
+function compactTrigger({ modelWindow, modelId, env = {}, settings = [] }) {
+  if (!Number.isFinite(modelWindow) || modelWindow <= 0) return null;
+  if (env.DISABLE_AUTO_COMPACT === '1') return null;
+  for (const s of settings) if (s && s.autoCompactEnabled === false) return null;
+  const clamp = (n) => Math.min(modelWindow, Math.max(MIN_COMPACT_WINDOW, Math.min(MAX_COMPACT_WINDOW, n)));
+  let window = null;
+  if (/^\d+$/.test(String(env.CLAUDE_CODE_AUTO_COMPACT_WINDOW || ''))) {
+    window = clamp(Number(env.CLAUDE_CODE_AUTO_COMPACT_WINDOW));
+  } else {
+    for (const s of settings) {
+      if (!s || typeof s !== 'object') continue;
+      const perModel = modelId && s.modelSettings && s.modelSettings[modelId] ? s.modelSettings[modelId].autoCompactWindow : undefined;
+      const v = perModel !== undefined ? perModel : s.autoCompactWindow;
+      if (v === 'auto') break; // the tuned default, below
+      if (Number.isFinite(v)) { window = clamp(v); break; }
+    }
+  }
+  if (window == null) window = Math.min(modelWindow, MAX_COMPACT_WINDOW);
+  let trigger = window - COMPACT_MARGIN;
+  const pct = Number(env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE);
+  if (Number.isInteger(pct) && pct >= 1 && pct < 100) trigger = Math.min(trigger, Math.floor(window * pct / 100));
+  return trigger;
+}
+
+/**
+ * The room left before compaction, as a percentage, and what it was measured
+ * against. Falls back to the model window's remaining_percentage when the bridge
+ * carries no token counts or the host does not compact.
+ */
+function roomLeft(metrics, opts = {}) {
+  const used = Number(metrics.total_input_tokens);
+  const trigger = Number.isFinite(used)
+    ? compactTrigger({ modelWindow: Number(metrics.context_window_size), modelId: metrics.model_id, env: opts.env || {}, settings: opts.settings || [] })
+    : null;
+  if (trigger) return { remaining: Math.max(0, Math.min(100, ((trigger - used) / trigger) * 100)), basis: 'compact-window' };
+  const r = Number(metrics.remaining_percentage);
+  return { remaining: r, basis: 'model-window' };
+}
+
+// ─── Without the status line: the transcript ─────────────────────────────────
+
+/**
+ * Pure: the context of the newest API call in a transcript's lines, scanning back
+ * from the end. Returns `{ found: true, used, model }`, `{ found: false, compacted:
+ * true }` when a compaction boundary comes first (the context was just rebuilt and
+ * no call has measured it yet), or `{ found: false }` when these lines hold no
+ * assistant record, so the caller can read further back.
+ *
+ * `used` is input + cache-read + cache-write tokens, the status line's
+ * `total_input_tokens`. Output tokens are left out, as its `used_percentage` leaves
+ * them out. A record with no usage (a synthetic or error record) is skipped. In the
+ * main transcript a sidechain record (an older host's subagent turn) is skipped; in
+ * a subagent's own transcript every record is a sidechain one.
+ */
+function lastContextFromLines(lines, { skipSidechain = true } = {}) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line || (!line.includes('"assistant"') && !line.includes('"compact_boundary"'))) continue;
+    let e;
+    try { e = JSON.parse(line); } catch { continue; }
+    if (!e || typeof e !== 'object') continue;
+    if (e.type === 'system' && e.subtype === 'compact_boundary') return { found: false, compacted: true };
+    if (e.type !== 'assistant' || (skipSidechain && e.isSidechain === true)) continue;
+    const u = e.message && e.message.usage;
+    if (!u || typeof u !== 'object') continue;
+    const n = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : 0);
+    const used = n(u.input_tokens) + n(u.cache_read_input_tokens) + n(u.cache_creation_input_tokens);
+    if (used <= 0) continue;
+    return { found: true, used, model: typeof e.message.model === 'string' ? e.message.model : null };
+  }
+  return { found: false };
+}
+
+/**
+ * The last `bytes` of a file as text, without the partial line the cut starts in.
+ * Defensive only: in well-formed JSONL a line's tail never parses as an object (a
+ * nested object is always followed by its parent's closing brace), so keeping the
+ * fragment would change nothing; dropping it keeps a fragment from ever being read.
+ */
+function readTail(file, bytes) {
+  // Read-only; the owner-only mode never applies to an open for reading, but keeps the
+  // call in the form PAN's temp-dir rule requires (the path may be under the temp dir).
+  const fd = fs.openSync(file, 'r', 0o600);
+  try {
+    const size = fs.fstatSync(fd).size;
+    const start = Math.max(0, size - bytes);
+    const buf = Buffer.alloc(size - start);
+    fs.readSync(fd, buf, 0, buf.length, start);
+    let text = buf.toString('utf8');
+    if (start > 0) {
+      const nl = text.indexOf('\n');
+      text = nl === -1 ? '' : text.slice(nl + 1);
+    }
+    return { text, whole: start === 0 };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/**
+ * The context of the newest API call in a transcript file, or null. Reads the
+ * tail, and further back (up to TRANSCRIPT_MAX_BYTES) only while a large tool
+ * result hides the last assistant record. Fails open: any error is null.
+ */
+function contextFromTranscript(file, { skipSidechain = true, tailBytes = TRANSCRIPT_TAIL_BYTES, maxBytes = TRANSCRIPT_MAX_BYTES } = {}) {
+  if (typeof file !== 'string' || !file) return null;
+  let bytes = tailBytes;
+  for (;;) {
+    let tail;
+    try { tail = readTail(file, bytes); } catch { return null; }
+    const r = lastContextFromLines(tail.text.split('\n'), { skipSidechain });
+    if (r.found) return { used: r.used, model: r.model };
+    if (r.compacted || tail.whole || bytes >= maxBytes) return null;
+    bytes = Math.min(bytes * 4, maxBytes);
+  }
+}
+
+/**
+ * Pure: a Claude model id's family and version, or null. Accepts the API ids
+ * (`claude-opus-5-5`, `claude-haiku-4-5-20251001`, `claude-3-5-sonnet-20241022`)
+ * and marks the forms a third-party provider gives them (`us.anthropic.claude-…-v1:0`
+ * on Bedrock, `claude-…@date` on Google Cloud).
+ */
+function parseModelId(id) {
+  if (typeof id !== 'string' || !id) return null;
+  const s = id.toLowerCase().trim().replace(/\[1m\]$/, '');
+  const thirdParty = /(^|\.)anthropic\.|@|-v\d+(:\d+)?$|^arn:/.test(s);
+  let m = s.match(/claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d{1,2}))?(?!\d)/);
+  if (m) return { family: m[1], major: Number(m[2]), minor: m[3] === undefined ? 0 : Number(m[3]), thirdParty };
+  m = s.match(/claude-(\d+)(?:-(\d{1,2}))?-(opus|sonnet|haiku)/);
+  if (m) return { family: m[3], major: Number(m[1]), minor: m[2] === undefined ? 0 : Number(m[2]), thirdParty };
+  return null;
+}
+
+/**
+ * Pure: the context window of the model that wrote a transcript record, or null
+ * when it cannot be known — then the hook says nothing rather than guess. From
+ * code.claude.com/docs/en/model-config (read 2026-10-04):
+ *   - On the Anthropic API, Fable 5.x, Sonnet 5 and later and Opus 4.7 and later
+ *     run a native 1M window. On Bedrock, Google Cloud and Foundry some of them run
+ *     200K, so there the window is unknown.
+ *   - Opus 4.6 and Sonnet 4.6 (and older) run 200K unless their `[1m]` variant is
+ *     configured; Haiku runs 200K.
+ *   - CLAUDE_CODE_DISABLE_1M_CONTEXT=1 holds every model to 200K.
+ *   - A context already past 200K can only be in a 1M window.
+ */
+function modelWindowFor(modelId, { env = {}, settings = [], used = 0 } = {}) {
+  if (used > STANDARD_WINDOW) return MAX_COMPACT_WINDOW;
+  if (env.CLAUDE_CODE_DISABLE_1M_CONTEXT === '1') return STANDARD_WINDOW;
+  const m = parseModelId(modelId);
+  if (!m) return null;
+  const native1m = m.family === 'fable'
+    || (m.family === 'sonnet' && m.major >= 5)
+    || (m.family === 'opus' && (m.major > 4 || (m.major === 4 && m.minor >= 7)));
+  if (native1m) {
+    const thirdParty = m.thirdParty || ['CLAUDE_CODE_USE_BEDROCK', 'CLAUDE_CODE_USE_VERTEX', 'CLAUDE_CODE_USE_FOUNDRY']
+      .some((k) => env[k] === '1' || env[k] === 'true');
+    return thirdParty ? null : MAX_COMPACT_WINDOW;
+  }
+  if (m.family === 'haiku') return STANDARD_WINDOW;
+  const extended = [env.ANTHROPIC_MODEL, ...settings.map((s) => (s && typeof s === 'object' ? s.model : undefined))]
+    .some((v) => typeof v === 'string' && /\[1m\]\s*$/i.test(v));
+  return extended ? MAX_COMPACT_WINDOW : STANDARD_WINDOW;
+}
+
+/**
+ * Metrics shaped like the bridge's, from a transcript: the tokens in context, the
+ * model window and the model id. Null when the transcript, its usage or the window
+ * cannot be known.
+ */
+function metricsFromTranscript(file, { env = {}, settings = [], skipSidechain = true, tailBytes, maxBytes } = {}) {
+  const ctx = contextFromTranscript(file, { skipSidechain, tailBytes, maxBytes });
+  if (!ctx) return null;
+  const window = modelWindowFor(ctx.model, { env, settings, used: ctx.used });
+  if (!window) return null;
+  return {
+    total_input_tokens: ctx.used,
+    context_window_size: window,
+    ...(ctx.model ? { model_id: ctx.model } : {}),
+    remaining_percentage: Math.max(0, 100 - (ctx.used / window) * 100),
+    source: 'transcript',
+  };
+}
+
+/**
+ * Which transcript measures this tool call. A call inside a subagent carries
+ * `agent_id`; the payload's `transcript_path` is still the main session's, and the
+ * subagent's own file is `<dir>/<session>/subagents/agent-<id>.jsonl` (an
+ * `agent_transcript_path`, where a host sends one, wins). A subagent the Workflow
+ * tool spawned (PAN's native `/pan-*` workflow scripts) is written one level down,
+ * under the run that spawned it: `subagents/workflows/<run>/agent-<id>.jsonl`, found
+ * the way pan-cost-logger.js resolveAgentTranscript finds it. The directory is read
+ * only for that search. Null when the ids are not safe to put in a path.
+ */
+function transcriptForPayload(data) {
+  if (!data || typeof data !== 'object') return null;
+  const agentId = data.agent_id;
+  if (agentId === undefined || agentId === null || agentId === '') {
+    return typeof data.transcript_path === 'string' && data.transcript_path ? { file: data.transcript_path, subagent: false } : null;
+  }
+  if (typeof agentId !== 'string' || !SAFE_ID.test(agentId)) return null;
+  if (typeof data.agent_transcript_path === 'string' && data.agent_transcript_path) return { file: data.agent_transcript_path, subagent: true };
+  if (typeof data.transcript_path !== 'string' || !data.transcript_path) return null;
+  if (typeof data.session_id !== 'string' || !SAFE_ID.test(data.session_id)) return null;
+  const base = path.dirname(data.transcript_path);
+  const subagentsDir = path.join(base, data.session_id, 'subagents');
+  const direct = path.join(subagentsDir, `agent-${agentId}.jsonl`);
+  if (!fs.existsSync(direct)) {
+    const resolvedBase = path.resolve(base);
+    let runs = [];
+    try { runs = fs.readdirSync(path.join(subagentsDir, 'workflows')); } catch { /* no workflow runs */ }
+    for (const run of runs) {
+      const nested = path.join(subagentsDir, 'workflows', run, `agent-${agentId}.jsonl`);
+      if (path.resolve(nested).startsWith(resolvedBase + path.sep) && fs.existsSync(nested)) return { file: nested, subagent: true };
+    }
+  }
+  return { file: direct, subagent: true };
+}
 
 // Pure decision function (exported for tests).
 //
-//   metrics    — { remaining_percentage, used_pct?, timestamp? } from the bridge
+//   metrics    — { remaining_percentage, total_input_tokens?, context_window_size?,
+//                  model_id?, timestamp? } from the bridge, or the same shape from
+//                  metricsFromTranscript (no timestamp: measured now)
 //   warnState  — { callsSinceWarn, lastLevel } from the prior warn file, or null
 //                on the first warning (no file yet / corrupt file)
 //   nowSeconds — current unix time in seconds
+//   opts       — { env, settings } for the compaction point (see compactTrigger)
 //
 // Returns one of:
 //   { action: 'exit' }                                   — nothing to do
 //   { action: 'debounce', warnState }                    — persist counter, no warn
-//   { action: 'emit', level, warnState, message }        — persist + emit warning
-function buildContextWarning(metrics, warnState, nowSeconds) {
+//   { action: 'emit', level, warnState, message, basis } — persist + emit the note
+function buildContextWarning(metrics, warnState, nowSeconds, opts = {}) {
   if (!metrics || typeof metrics !== 'object') return { action: 'exit' };
 
   // Ignore stale metrics (statusline stopped updating — e.g. session ended).
@@ -116,7 +385,7 @@ function buildContextWarning(metrics, warnState, nowSeconds) {
     return { action: 'exit' };
   }
 
-  const remaining = Number(metrics.remaining_percentage);
+  const { remaining, basis } = roomLeft(metrics, opts);
   if (!Number.isFinite(remaining)) return { action: 'exit' };
 
   // No warning needed
@@ -140,33 +409,41 @@ function buildContextWarning(metrics, warnState, nowSeconds) {
     };
   }
 
-  // L39: report Usage and Remaining on the SAME scale so they are internally
-  // consistent (sum to 100). The bridge's used_pct is the statusline's
-  // 80%-rescaled figure (80% real usage displays as 100%); pairing it with the
-  // raw remaining produced self-contradictory numbers like
-  // "Usage at 94%. Remaining: 25%". Derive used from remaining instead.
-  const rem = Math.round(remaining);
-  const used = 100 - rem;
-
-  let message;
-  if (isCritical) {
-    message = `CONTEXT MONITOR CRITICAL: Usage at ${used}%. Remaining: ${rem}%. ` +
-      'STOP new work immediately. Save state NOW and inform the user that context is nearly exhausted. ' +
-      'If using PAN, run /pan:pause to save execution state.';
-  } else {
-    message = `CONTEXT MONITOR WARNING: Usage at ${used}%. Remaining: ${rem}%. ` +
-      'Begin wrapping up current task. Do not start new complex work. ' +
-      'If using PAN, consider /pan:pause to save state.';
-  }
+  // No figures (O7): a countdown makes a model wrap up early, and a percentage is
+  // the thing it would count down. The note names the checkpoint, says compaction
+  // is safe, and asks for no shortcuts.
+  const message = isCritical
+    ? 'PAN context note (from the context-monitor hook, not the user): the host will compact this session soon. ' +
+      'Before your next step, make sure .planning/state.md records where you are — the phase, the plan and task, and what comes next; /pan:pause writes it. ' +
+      'Then carry on with the current task as normal. After compaction PAN restores the planning state, so finish the task properly rather than quickly.'
+    : 'PAN context note (from the context-monitor hook, not the user): this session\'s context is filling up. ' +
+      'At your next natural stopping point, such as a finished task or a commit, make sure .planning/state.md records where you are; /pan:pause writes it. ' +
+      'Nothing needs to stop: the host compacts on its own and PAN restores the planning state afterwards, so keep working at full quality, with no shortcuts and no skipped verification.';
 
   return {
     action: 'emit',
     level: currentLevel,
     warnState: { callsSinceWarn: 0, lastLevel: currentLevel },
     message,
+    basis,
   };
 }
 
+/** Claude Code's settings for a project, highest precedence first: local, project, user. */
+function readClaudeSettings(projectDir, homeDir = os.homedir()) {
+  // Assembled, not a literal: the installer rewrites quoted .claude literals in hook
+  // copies, and these are Claude Code's own settings (only it writes the bridge).
+  const dir = ['.', 'claude'].join('');
+  const files = [];
+  if (typeof projectDir === 'string' && projectDir) files.push(path.join(projectDir, dir, 'settings.local.json'), path.join(projectDir, dir, 'settings.json'));
+  if (homeDir) files.push(path.join(homeDir, dir, 'settings.json'));
+  const out = [];
+  for (const f of files) {
+    try { out.push(JSON.parse(fs.readFileSync(f, 'utf8'))); } catch { /* absent or unreadable */ }
+  }
+  return out;
+}
+
 function main() {
   let input = '';
   process.stdin.setEncoding('utf8');
@@ -177,27 +454,37 @@ function main() {
       if (deferToClaudeRegistration(data.cwd || process.cwd())) process.exit(0);
       const sessionId = data.session_id;
 
-      if (!sessionId) {
+      if (typeof sessionId !== 'string' || !SAFE_ID.test(sessionId)) {
         process.exit(0);
       }
 
       const tmpDir = bridgeDir();
       if (!tmpDir) process.exit(0); // insecure/unavailable bridge dir — fail closed (M60)
-      const metricsPath = path.join(tmpDir, `claude-ctx-${sessionId}.json`);
+      const now = Math.floor(Date.now() / 1000);
+      const settings = readClaudeSettings(data.cwd || process.cwd());
+      const source = transcriptForPayload(data);
+      const subagent = !!(source && source.subagent) || (data.agent_id !== undefined && data.agent_id !== null && data.agent_id !== '');
 
-      // Read metrics directly; absence (subagent/fresh session) or a corrupt
-      // file just means "nothing to warn about" — exit silently. No
+      // The bridge is the main session's context (the status line renders the main
+      // thread), so only a main-thread call reads it, and only while it is fresh.
+      // Absence or a corrupt file falls through to the transcript. No
       // existsSync-then-read gap.
-      let metrics;
-      try {
-        metrics = JSON.parse(fs.readFileSync(metricsPath, 'utf8'));
-      } catch {
-        process.exit(0);
+      let metrics = null;
+      if (!subagent) {
+        try {
+          const bridge = JSON.parse(fs.readFileSync(path.join(tmpDir, `claude-ctx-${sessionId}.json`), 'utf8'));
+          if (bridge && typeof bridge === 'object' && !(bridge.timestamp != null && (now - bridge.timestamp) > STALE_SECONDS)) metrics = bridge;
+        } catch { /* no bridge: no status line, or not PAN's */ }
       }
-      const now = Math.floor(Date.now() / 1000);
+      if (!metrics && source) {
+        metrics = metricsFromTranscript(source.file, { env: process.env, settings, skipSidechain: !source.subagent });
+      }
+      if (!metrics) process.exit(0);
 
       // Load prior warn state (null when no file / corrupt → treated as first warn).
-      const warnPath = path.join(tmpDir, `claude-ctx-${sessionId}-warned.json`);
+      // A subagent debounces on its own: its context is not the main session's.
+      const warnKey = source && source.subagent ? `${sessionId}-${data.agent_id}` : sessionId;
+      const warnPath = path.join(tmpDir, `claude-ctx-${warnKey}-warned.json`);
       let warnData = null;
       try {
         warnData = JSON.parse(fs.readFileSync(warnPath, 'utf8'));
@@ -205,7 +492,10 @@ function main() {
         warnData = null;
       }
 
-      const decision = buildContextWarning(metrics, warnData, now);
+      const decision = buildContextWarning(metrics, warnData, now, {
+        env: process.env,
+        settings: Number.isFinite(Number(metrics.total_input_tokens)) ? settings : [],
+      });
 
       if (decision.action === 'exit') {
         process.exit(0);
@@ -241,7 +531,16 @@ if (require.main === module) {
 module.exports = {
   deferToClaudeRegistration,
   buildContextWarning,
+  compactTrigger,
+  roomLeft,
+  readClaudeSettings,
   bridgeDir,
+  lastContextFromLines,
+  contextFromTranscript,
+  parseModelId,
+  modelWindowFor,
+  metricsFromTranscript,
+  transcriptForPayload,
   WARNING_THRESHOLD,
   CRITICAL_THRESHOLD,
   STALE_SECONDS,

package/hooks/dist/pan-cost-logger.js

@@ -655,6 +655,7 @@ function buildCostRecord(data, cwd) {
   let cacheWrite = 0;
   // { h1, m5 } when the source carried the cache-write lifetime split (M13).
   let ttlSplit = null;
+  let longPrompt = null;
   let durationMs = null;
   // token_source records WHICH path produced the counts: `agent-transcript` (the
   // subagent's own conversation file — see resolveAgentTranscript), `transcript`
@@ -717,6 +718,9 @@ function buildCostRecord(data, cwd) {
     if (typeof fromTranscript.cache_write_1h_tokens === 'number' && rawCw <= SLICE_MAX.cache_write) {
       ttlSplit = { h1: fromTranscript.cache_write_1h_tokens, m5: fromTranscript.cache_write_5m_tokens || 0 };
     }
+    // The long-prompt part of the slice, kept only when nothing was clamped (a clamped
+    // total no longer contains it).
+    if (fromTranscript.long_prompt && !clamped) longPrompt = fromTranscript.long_prompt;
     durationMs = durationFromSpan(fromTranscript.first_ts, fromTranscript.last_ts); // as measured — see SLICE_MAX
     if (!model) model = fromTranscript.model;
     if (fromTranscript.lineCount > since) {
@@ -809,6 +813,8 @@ function buildCostRecord(data, cwd) {
     cache_write_tokens: cacheWrite,
     // The lifetime split of cache_write_tokens, present only when measured (M13).
     ...(ttlSplit ? { cache_write_1h_tokens: ttlSplit.h1, cache_write_5m_tokens: ttlSplit.m5 } : {}),
+    // Tokens of the requests whose prompt was over LONG_PROMPT_THRESHOLD, when any were.
+    ...(longPrompt ? { long_prompt: longPrompt } : {}),
     cost_usd: null,
     duration_ms: durationMs,
     phase,
@@ -938,6 +944,7 @@ function readUsageFromTranscript(transcriptPath, sessionId, sinceLine = 0) {
     totals.cache_read_input_tokens += extractNumber(usage, 'cache_read_input_tokens');
     totals.cache_creation_input_tokens += extractNumber(usage, 'cache_creation_input_tokens');
     addCacheTtlSplit(totals, usage);
+    addLongPrompt(totals, usage);
   }
   totals.lineCount = seen;
   return totals;
@@ -958,6 +965,29 @@ function addCacheTtlSplit(totals, usage) {
   totals.cache_write_5m_tokens = (totals.cache_write_5m_tokens || 0) + extractNumber(cc, 'ephemeral_5m_input_tokens');
 }
 
+// Haiku 5.5 bills a request whose prompt (input plus cache reads and writes) is over
+// this many tokens at higher rates, request by request. A row sums many requests, so
+// the tokens of those over it are kept apart as `long_prompt`, and the read side
+// (lib/cost.cjs computeCost) prices them at the model's long rate. A copy of
+// LONG_PROMPT_THRESHOLD in lib/cost.cjs: hooks require nothing from lib, and
+// tests/cost-long-prompt.test.cjs pins the two equal.
+const LONG_PROMPT_THRESHOLD = 100000;
+
+/** Add one request's usage to `totals.long_prompt` when its prompt is over the threshold. */
+function addLongPrompt(totals, usage) {
+  const inp = extractNumber(usage, 'input_tokens');
+  const cr = extractNumber(usage, 'cache_read_input_tokens');
+  const cw = extractNumber(usage, 'cache_creation_input_tokens');
+  if (inp + cr + cw <= LONG_PROMPT_THRESHOLD) return;
+  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 += inp;
+  lp.output_tokens += extractNumber(usage, 'output_tokens');
+  lp.cache_read_tokens += cr;
+  lp.cache_write_tokens += cw;
+  const cc = usage && usage.cache_creation;
+  if (cc && typeof cc === 'object') lp.cache_write_1h_tokens += extractNumber(cc, 'ephemeral_1h_input_tokens');
+}
+
 /**
  * Append record to .planning/metrics/tokens.jsonl. Silently succeeds
  * even if the file or directory can't be written — hook must not block.

package/hooks/dist/pan-statusline.js

@@ -30,6 +30,54 @@ function buildStatuslineOutput(data, deps) {
   const session = data.session_id || '';
   const remaining = data.context_window?.remaining_percentage;
 
+  // The per-user 0700 bridge directory, or null when it is not safe to write into.
+  // Mirrors bridgeDir() in pan-context-monitor.js (the reader).
+  let bridgeSubdirMemo;
+  const secureBridgeDir = () => {
+    if (bridgeSubdirMemo !== undefined) return bridgeSubdirMemo;
+    bridgeSubdirMemo = null;
+    const uid = (typeof process.getuid === 'function' ? process.getuid() : process.env.USERNAME || 'win');
+    const sub = pathMod.join(tmpDir, `pan-hooks-${uid}`);
+    // Fail CLOSED if the per-user dir is pre-planted/symlinked/owned by someone
+    // else: mkdirSync{recursive} silently no-ops on an existing dir, so verify
+    // ownership+mode before writing (M60).
+    try {
+      fsMod.mkdirSync(sub, { recursive: true, mode: 0o700 });
+      const st = fsMod.lstatSync(sub);
+      // Symlink check is cross-platform; POSIX ownership/mode checks apply only
+      // where getuid exists (Windows fakes mode bits; gating on them there
+      // disabled the bridge entirely, N15).
+      let secure = !st.isSymbolicLink();
+      if (secure && typeof process.getuid === 'function') {
+        secure = st.uid === process.getuid() && (st.mode & 0o077) === 0;
+      }
+      if (secure) bridgeSubdirMemo = sub;
+    } catch { /* not safe */ }
+    return bridgeSubdirMemo;
+  };
+
+  // Usage limits (Claude Code subscriptions: `rate_limits.five_hour` / `seven_day`).
+  // Account-wide, so one file for every session; `pan-tools cost limits` and the
+  // focus-auto weekly stop read it. Written only when the host sent the block.
+  const limits = data.rate_limits && typeof data.rate_limits === 'object' ? data.rate_limits : null;
+  const limitWin = (w) => (w && Number.isFinite(Number(w.used_percentage))
+    ? { used_percentage: Number(w.used_percentage), ...(Number.isFinite(Number(w.resets_at)) ? { resets_at: Number(w.resets_at) } : {}) }
+    : null);
+  const fiveHour = limits ? limitWin(limits.five_hour) : null;
+  const sevenDay = limits ? limitWin(limits.seven_day) : null;
+  if ((fiveHour || sevenDay) && d.skipBridge !== true) {
+    try {
+      const sub = secureBridgeDir();
+      if (sub) {
+        fsMod.writeFileSync(pathMod.join(sub, 'claude-limits.json'), JSON.stringify({
+          ...(fiveHour ? { five_hour: fiveHour } : {}),
+          ...(sevenDay ? { seven_day: sevenDay } : {}),
+          timestamp: Math.floor(Date.now() / 1000),
+        }), { mode: 0o600 });
+      }
+    } catch { /* best-effort */ }
+  }
+
   // Context window bar — shows USED percentage scaled so 80% real = 100% shown.
   let ctx = '';
   if (remaining != null) {
@@ -39,34 +87,23 @@ function buildStatuslineOutput(data, deps) {
 
     if (session && d.skipBridge !== true) {
       try {
-        // Write the bridge file into a per-user 0700 subdir so another user on
+        // The session bridge goes into the per-user 0700 subdir so another user on
         // a shared host can't symlink-attack the predictable session path.
-        // Mirrors bridgeDir() in pan-context-monitor.js (the reader).
-        const uid = (typeof process.getuid === 'function' ? process.getuid() : process.env.USERNAME || 'win');
-        const bridgeSubdir = pathMod.join(tmpDir, `pan-hooks-${uid}`);
-        // Fail CLOSED if the per-user dir is pre-planted/symlinked/owned by
-        // someone else — mkdirSync{recursive} silently no-ops on an existing dir,
-        // so verify ownership+mode before writing the session bridge (M60).
-        let secure = false;
-        try {
-          fsMod.mkdirSync(bridgeSubdir, { recursive: true, mode: 0o700 });
-          const st = fsMod.lstatSync(bridgeSubdir);
-          // Symlink check is cross-platform; POSIX ownership/mode checks apply
-          // only where getuid exists (Windows fakes mode bits — gating on them
-          // there disabled the bridge entirely, N15).
-          secure = !st.isSymbolicLink();
-          if (secure && typeof process.getuid === 'function') {
-            secure = st.uid === process.getuid() && (st.mode & 0o077) === 0;
-          }
-        } catch { secure = false; }
-        if (secure) {
+        const bridgeSubdir = secureBridgeDir();
+        if (bridgeSubdir) {
           const bridgePath = pathMod.join(bridgeSubdir, `claude-ctx-${session}.json`);
+          // Token counts and the model id let the context monitor measure against
+          // the window the host compacts at, not the model window (O7).
+          const cw = data.context_window || {};
           fsMod.writeFileSync(bridgePath, JSON.stringify({
             session_id: session,
             remaining_percentage: remaining,
             used_pct: used,
+            ...(Number.isFinite(cw.total_input_tokens) ? { total_input_tokens: cw.total_input_tokens } : {}),
+            ...(Number.isFinite(cw.context_window_size) ? { context_window_size: cw.context_window_size } : {}),
+            ...(data.model && data.model.id ? { model_id: data.model.id } : {}),
             timestamp: Math.floor(Date.now() / 1000),
-          }));
+          }), { mode: 0o600 });
         }
       } catch { /* bridge is best-effort */ }
     }
@@ -154,7 +191,16 @@ function buildStatuslineOutput(data, deps) {
   const head = `${panUpdate}\x1b[2m${model}\x1b[0m`;
   const taskSegment = task ? ` │ \x1b[1m${task}\x1b[0m` : '';
   const dirSegment = ` │ \x1b[2m${dirname}\x1b[0m`;
-  return `${head}${taskSegment}${dirSegment}${ctx}${cacheBadge}${thinkingBadge}`;
+  // Usage-limit badge: the window closer to its cap, green below 70%, yellow below
+  // 90%, red from 90% (focus-auto's default weekly stop).
+  let limitBadge = '';
+  const shown = [fiveHour && ['5h', fiveHour.used_percentage], sevenDay && ['7d', sevenDay.used_percentage]].filter(Boolean);
+  if (shown.length) {
+    const worst = Math.max(...shown.map(([, v]) => v));
+    const color = worst >= 90 ? '' : worst >= 70 ? '' : '';
+    limitBadge = ` ${color}${shown.map(([k, v]) => `${k} ${Math.round(v)}%`).join(' · ')}`;
+  }
+  return `${head}${taskSegment}${dirSegment}${ctx}${cacheBadge}${thinkingBadge}${limitBadge}`;
 }
 
 // ─── Stdin driver ───────────────────────────────────────────────────────────