@cortexkit/pi-magic-context 0.49.35 → 0.49.36

package/dist/index.js

@@ -150,7 +150,7 @@ import {
   registerTodoStateLifecycle,
   syncCtxMemoryToolEnabled,
   registerMagicContextTools
-} from "./index-fzm8fm4z.js";
+} from "./index-dgqjq8sg.js";
 import"./index-4knyh1kt.js";
 import {
   canonicalModelIdentity,
@@ -353,7 +353,7 @@ import {
   getRawSessionTagKeysThrough2,
   getLegacyProtectedTailStartOrdinal2,
   readSessionChunk2
-} from "./index-svqk0701.js";
+} from "./index-mx757f3g.js";
 import {
   UNKNOWN_FIT_RATIO,
   hasMeasuredDecisionCalibration,
@@ -440,7 +440,7 @@ import {
   getToolTagNumberByOwner2,
   getNullOwnerToolTag2,
   adoptNullOwnerToolTag2
-} from "./index-yhsmjvqa.js";
+} from "./index-pwp6zyx3.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -490,7 +490,7 @@ import {
   openCurrentDatabase,
   openDatabaseAsync,
   closeDatabase
-} from "./index-11knwv2h.js";
+} from "./index-a7sj2bam.js";
 import {
   LkgRecoveryFenceError,
   clearLkgFenceProcessState,
@@ -607,7 +607,7 @@ import {
   getSourceContents,
   recordSubagentInvocation,
   getLatestHistorianInvocationId
-} from "./index-d21rhpbd.js";
+} from "./index-p9jfa33t.js";
 import {
   resolveOpenCodeDbPath,
   assertOpenCodeStoreGeneration,
@@ -616,18 +616,21 @@ import {
   clearOpenCodeDbReadFailure,
   claimOpenCodeDbDiagnosticOnce
 } from "./index-n0zjvs3h.js";
-import"./index-399p688g.js";
+import"./index-8sqebjzk.js";
+import {
+  reuseWorker
+} from "./index-wfqysrwq.js";
 import {
   createWorkerShutdown
-} from "./index-54wmg4rj.js";
+} from "./index-x2n261wp.js";
 import {
   RAW_SUMMARY_TEXT_MAX_CHARS2
-} from "./index-mkh1cm5k.js";
+} from "./index-c1dqxr10.js";
 import"./index-ea37qn4x.js";
 import {
   formatSynapseLaneDescriptor
 } from "./index-rzfr7wdv.js";
-import"./index-rgvqh5x7.js";
+import"./index-ck8wj35v.js";
 import {
   buildCanonicalChunkTextFromFts2,
   buildCompartmentSummaryFallbackText2,
@@ -637,7 +640,7 @@ import {
   replaceCompartmentChunkEmbeddings2,
   deleteChunkEmbedBackoffForSession2,
   chunkWindowSourceKey2
-} from "./index-2p691ayw.js";
+} from "./index-f9qet7y8.js";
 import {
   recordSessionProjectIdentity,
   GIT_SWEEP_LEASE_RENEWAL_MS,
@@ -662,7 +665,7 @@ import {
   clearCompressionDepthRange,
   cleanSearchText,
   matchedSearchSnippet
-} from "./index-8m82cez2.js";
+} from "./index-kj49vs41.js";
 import {
   rememberV1HiddenRun
 } from "./index-6x556c2q.js";
@@ -726,6 +729,7 @@ import {
   getMemoriesByProjects2,
   getMaxMemoryIdForProjects2,
   getMemoryById2,
+  updateMemoryVerification2,
   setMemoryClassification2,
   archiveMemory2,
   getMemoryCountsByStatus2
@@ -756,10 +760,10 @@ import {
   embedSessionCompartmentChunks2,
   getEmbeddingCoverageStatus2,
   getAutoEmbeddingSessionCoverage2
-} from "./index-a11nmw5t.js";
+} from "./index-z7dktknj.js";
 import {
   cosineSimilarity
-} from "./index-vgfk2xa5.js";
+} from "./index-jbkwszd5.js";
 import {
   USER_FACING_FAILURES,
   renderUserFacingFailure,
@@ -793,8 +797,8 @@ import {
   scheduleClearAndReindex,
   clearSessionTracking,
   createAutoSearchDiagnostics
-} from "./index-yg42q9bc.js";
-import"./index-d0w84hy5.js";
+} from "./index-f6y7mdq9.js";
+import"./index-y90fxz4t.js";
 import {
   DREAMER_PRIMER_INVESTIGATOR_ALLOWED_TOOLS,
   buildHiddenAgentRegistrations,
@@ -821,11 +825,11 @@ import {
   drainPiTagSnapshotSession,
   assertPiTagSnapshotReady,
   ensurePiTagSnapshotReady
-} from "./index-0rvn6vhq.js";
+} from "./index-wwsfevck.js";
 import"./index-cq71g4dk.js";
 import"./index-1cvyaw9a.js";
-import"./index-6y6v2wvn.js";
-import"./index-m68qfjte.js";
+import"./index-gxqmh9hq.js";
+import"./index-ry84c8dr.js";
 import {
   __toESM
 } from "./index-22jkk6wg.js";
@@ -3580,7 +3584,7 @@ function startHostStallProfilerSwitch() {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.49.35",
+  version: "0.49.36",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -3699,6 +3703,158 @@ var package_default = {
 
 // src/clone-inheritance.ts
 import { open, stat } from "node:fs/promises";
+
+// src/drop-branches-pi.ts
+var KEY = "piDropBranches";
+var installed = new WeakSet;
+function trackPiDropLeaf(db, sessionId, leaf) {
+  if (!installed.has(db)) {
+    db.exec(`
+			CREATE TEMP TABLE IF NOT EXISTS pi_drop_leaf (session_id TEXT PRIMARY KEY, leaf TEXT);
+			CREATE TEMP TRIGGER IF NOT EXISTS pi_drop_queued AFTER INSERT ON main.pending_ops
+			WHEN NEW.operation = 'drop' AND EXISTS (SELECT 1 FROM pi_drop_leaf WHERE session_id = NEW.session_id AND leaf IS NOT NULL)
+			BEGIN
+				UPDATE session_meta SET deferred_execute_state = json_set(
+					COALESCE(NULLIF(deferred_execute_state, ''), '{}'),
+					'$.${KEY}.pending."' || NEW.tag_id || '"',
+					(SELECT leaf FROM pi_drop_leaf WHERE session_id = NEW.session_id))
+				WHERE session_id = NEW.session_id;
+			END;
+			CREATE TEMP TRIGGER IF NOT EXISTS pi_drop_applied AFTER UPDATE OF status ON main.tags
+			WHEN NEW.status = 'dropped' AND OLD.status != 'dropped'
+				AND EXISTS (SELECT 1 FROM pi_drop_leaf WHERE session_id = NEW.session_id AND leaf IS NOT NULL)
+			BEGIN
+				UPDATE session_meta SET deferred_execute_state = json_remove(json_set(
+					COALESCE(NULLIF(deferred_execute_state, ''), '{}'),
+					'$.${KEY}.drops."' || NEW.tag_number || '"',
+					COALESCE(json_extract(deferred_execute_state, '$.${KEY}.pending."' || NEW.tag_number || '"'),
+						(SELECT leaf FROM pi_drop_leaf WHERE session_id = NEW.session_id))),
+					'$.${KEY}.pending."' || NEW.tag_number || '"')
+				WHERE session_id = NEW.session_id;
+			END;
+			CREATE TEMP TRIGGER IF NOT EXISTS pi_drop_retired AFTER UPDATE OF status ON main.tags
+			WHEN NEW.status = 'compacted'
+			BEGIN
+				UPDATE session_meta SET deferred_execute_state = json_remove(
+					COALESCE(NULLIF(deferred_execute_state, ''), '{}'),
+					'$.${KEY}.drops."' || NEW.tag_number || '"', '$.${KEY}.pending."' || NEW.tag_number || '"')
+				WHERE session_id = NEW.session_id AND json_type(deferred_execute_state, '$.${KEY}') = 'object';
+			END;
+		`);
+    installed.add(db);
+  }
+  ensureSessionMetaRow(db, sessionId);
+  db.prepare("INSERT INTO pi_drop_leaf VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET leaf = excluded.leaf").run(sessionId, leaf);
+}
+function state(db, sessionId) {
+  const row = db.prepare("SELECT deferred_execute_state AS state FROM session_meta WHERE session_id = ?").get(sessionId);
+  const value = row?.state ? JSON.parse(row.state) : {};
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Invalid session metadata JSON");
+  return value;
+}
+function journal(value) {
+  const result = { drops: {}, pending: {} };
+  if (!value || typeof value !== "object")
+    return result;
+  for (const kind of ["drops", "pending"]) {
+    const entries = value[kind];
+    if (!entries || typeof entries !== "object")
+      continue;
+    for (const [tag, leaf] of Object.entries(entries)) {
+      if (/^\d+$/.test(tag) && typeof leaf === "string" && leaf)
+        result[kind][tag] = leaf;
+    }
+  }
+  return result;
+}
+function save(db, sessionId, document, value) {
+  document[KEY] = value;
+  db.prepare("UPDATE session_meta SET deferred_execute_state = ? WHERE session_id = ?").run(JSON.stringify(document), sessionId);
+}
+function piDropBranchIds(entries) {
+  const ids = new Set;
+  let parent = null;
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object")
+      return null;
+    const row = entry;
+    if (typeof row.id !== "string" || !row.id || row.parentId !== parent || ids.has(row.id))
+      return null;
+    ids.add(row.id);
+    parent = row.id;
+  }
+  return ids;
+}
+function cancelPiAbandonedPendingDrops(db, sessionId, ids) {
+  if (!ids)
+    return 0;
+  const abandoned = (saved) => Object.entries(saved.pending).filter(([, leaf]) => !ids.has(leaf));
+  if (!abandoned(journal(state(db, sessionId)[KEY])).length)
+    return 0;
+  return db.transaction(() => {
+    const document = state(db, sessionId);
+    const saved = journal(document[KEY]);
+    const offPending = abandoned(saved);
+    if (!offPending.length)
+      return 0;
+    for (const [tag] of offPending) {
+      db.prepare("DELETE FROM pending_ops WHERE session_id = ? AND tag_id = ?").run(sessionId, Number(tag));
+      delete saved.pending[tag];
+    }
+    save(db, sessionId, document, saved);
+    return offPending.length;
+  }).immediate();
+}
+function reconcilePiDropBranches(db, sessionId, ids, canRebuild) {
+  if (!canRebuild || !ids)
+    return 0;
+  return db.transaction(() => {
+    const document = state(db, sessionId);
+    const saved = journal(document[KEY]);
+    const offBranch = Object.entries(saved.drops).filter(([, leaf]) => !ids.has(leaf));
+    if (!offBranch.length)
+      return 0;
+    const native = getNativeReplayState(db, sessionId);
+    let restored = 0;
+    for (const [tag] of offBranch) {
+      const row = db.prepare("UPDATE tags SET status = 'active', drop_mode = 'full' WHERE session_id = ? AND tag_number = ? AND status = 'dropped' RETURNING message_id, type").get(sessionId, Number(tag));
+      if (row) {
+        restored++;
+        if (row.type === "tool")
+          native.toolInputs.delete(row.message_id);
+      }
+      delete saved.drops[tag];
+    }
+    if (restored && !updateReplayDocument(db, sessionId, (doc) => {
+      if (doc.piNative === undefined)
+        return false;
+      if (!doc.piNative || typeof doc.piNative !== "object" || Array.isArray(doc.piNative))
+        throw new Error("Invalid Pi native replay state");
+      doc.piNative = {
+        ...doc.piNative,
+        toolInputs: Object.fromEntries(native.toolInputs)
+      };
+      return true;
+    }))
+      throw new Error("Cannot persist restored Pi tool inputs");
+    save(db, sessionId, document, saved);
+    return restored;
+  }).immediate();
+}
+function copyPiDropBranches(db, source, destination) {
+  const sourceJournal = journal(state(db, source)[KEY]);
+  const tags = new Set(db.prepare("SELECT tag_number FROM tags WHERE session_id = ?").all(destination).map((row) => String(row.tag_number)));
+  for (const kind of ["drops", "pending"]) {
+    for (const tag of Object.keys(sourceJournal[kind]))
+      if (!tags.has(tag))
+        delete sourceJournal[kind][tag];
+  }
+  ensureSessionMetaRow(db, destination);
+  save(db, destination, state(db, destination), sourceJournal);
+}
+
+// src/clone-inheritance.ts
 var CONTENT_ID_SUFFIX = /:(?:p|file)\d+$/;
 var BARE_SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var loggedCloneStartFailures = new Set;
@@ -3883,9 +4039,14 @@ async function inheritPiCloneSession(event, ctx, deps, isStartup) {
       throw new Error("Pi clone branch is unavailable");
     }
     stage = "copy-state";
+    const filter = createCloneFilter(branchEntries);
     const result = copySessionStateForClone(deps.db, sourceSessionId, destinationSessionId, {
-      ...createCloneFilter(branchEntries),
-      requireEmptyDestinationMeta: isStartup
+      ...filter,
+      requireEmptyDestinationMeta: isStartup,
+      selectPendingPiMarker: (raw, compartments) => {
+        copyPiDropBranches(deps.db, sourceSessionId, destinationSessionId);
+        return filter.selectPendingPiMarker(raw, compartments);
+      }
     });
     if (result.kind === "destination-not-empty") {
       writeLog(`[magic-context][pi] clone-inheritance: skipped source=${sourceSessionId} dest=${destinationSessionId} stage=destination-guard reason=destination-not-empty`);
@@ -4189,12 +4350,17 @@ function countCompartmentsSince(db, projectPath, since) {
   return row?.cnt ?? 0;
 }
 function countProjectSessionsSince(db, projectPath, since) {
-  const row = since === null ? db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ?").get(projectPath) : db.prepare(`SELECT COUNT(*) AS cnt FROM session_projects sp
-                        LEFT JOIN schema_migrations_meta activity
-                          ON activity.key = 'retrospective_activity:' || sp.session_id
-                        LEFT JOIN message_history_index history ON history.session_id = sp.session_id
-                       WHERE sp.project_path = ?
-                         AND COALESCE(CAST(activity.value AS INTEGER), history.updated_at) > ?`).get(projectPath, since);
+  const scope = `FROM session_projects sp
+        LEFT JOIN session_meta m ON m.session_id = sp.session_id
+       WHERE sp.project_path = ? AND sp.harness = ?
+         AND COALESCE(m.is_subagent, 0) = 0`;
+  const row = since === null ? db.prepare(`SELECT COUNT(*) AS cnt ${scope}`).get(projectPath, getHarness2()) : db.prepare(`SELECT COUNT(*) AS cnt ${scope}
+                          AND COALESCE(
+                              (SELECT CAST(value AS INTEGER) FROM schema_migrations_meta
+                               WHERE key = 'retrospective_activity:' || sp.session_id),
+                              (SELECT updated_at FROM message_history_index
+                               WHERE session_id = sp.session_id AND harness = sp.harness)
+                          ) > ?`).get(projectPath, getHarness2(), since);
   return row?.cnt ?? 0;
 }
 function countMappedMemories(db, projectPath) {
@@ -4207,6 +4373,10 @@ function countMappedMemories(db, projectPath) {
                 AND v.file_path <> ''`).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
+var CURRENT_VERIFY_SKIP_SQL = `COALESCE(CASE WHEN json_valid(m.metadata_json) THEN
+    json_extract(m.metadata_json, '$.dreamerVerifySkip.contentHash') = m.normalized_hash
+    AND json_type(m.metadata_json, '$.dreamerVerifySkip.fingerprint') = 'text'
+    ELSE 0 END, 0)`;
 function countUnverifiedMappedMemories(db, projectPath) {
   const row = db.prepare(`SELECT COUNT(DISTINCT m.id) AS cnt
                FROM memories m
@@ -4215,7 +4385,8 @@ function countUnverifiedMappedMemories(db, projectPath) {
                 AND m.status IN ('active','permanent')
                 AND (m.expires_at IS NULL OR m.expires_at > ?)
                 AND v.file_path <> ''
-                AND v.verified_at = 0`).get(projectPath, Date.now());
+                AND v.verified_at = 0
+                AND NOT (${CURRENT_VERIFY_SKIP_SQL})`).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
 function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
@@ -4224,6 +4395,7 @@ function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
               WHERE m.project_path = ?
                 AND m.status IN ('active','permanent')
                 AND (m.expires_at IS NULL OR m.expires_at > ?)
+                AND NOT (${CURRENT_VERIFY_SKIP_SQL})
                 AND (
                     SELECT MAX(v.verified_at)
                       FROM memory_verifications v
@@ -4332,7 +4504,7 @@ function getDreamTaskBacklog(db, projectPath, task, options = {}) {
     case "verify-broad": {
       const total = countMappedMemories(db, projectPath);
       const cycleStartAt = getTaskScheduleState(db, projectPath, "verify-broad")?.lastBroadRunAt;
-      const pending = cycleStartAt == null ? total : countBroadCycleCandidates(db, projectPath, cycleStartAt);
+      const pending = countBroadCycleCandidates(db, projectPath, cycleStartAt ?? Number.MAX_SAFE_INTEGER);
       return { pending, total };
     }
     case "curate": {
@@ -4459,6 +4631,7 @@ function getDreamTaskBacklogs(db, projectPath, tasks = CANONICAL_DREAM_TASKS, op
   }
   const optionKey = (value) => value === undefined ? "omitted" : value === null ? "null" : `number:${value}`;
   const key = JSON.stringify([
+    getHarness2(),
     projectPath,
     tasks,
     optionKey(options.lastRunAt),
@@ -4548,7 +4721,7 @@ function openOpenCodeDb() {
 }
 
 // ../plugin/src/features/magic-context/dreamer/task-executor.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
 
 // ../plugin/src/agents/dreamer.ts
@@ -4571,7 +4744,7 @@ var DREAMER_REVIEWER_AGENT = "dreamer-reviewer";
 // ../plugin/src/features/magic-context/schema-fence-probe.ts
 var STALE_CHILD_SPAWN_FAILURE = "stale_schema_fence";
 var STALE_CHILD_SPAWN_LATCH_THRESHOLD = 2;
-var state = {
+var state2 = {
   consecutiveFailures: 0,
   totalFailures: 0,
   latched: false,
@@ -4579,23 +4752,23 @@ var state = {
   failure: null
 };
 function recordStaleFence(persistedVersion, supportedVersion, reason = "newer_schema") {
-  state.consecutiveFailures += 1;
-  state.totalFailures += 1;
-  const latched = state.consecutiveFailures >= STALE_CHILD_SPAWN_LATCH_THRESHOLD;
-  state.latched ||= latched;
+  state2.consecutiveFailures += 1;
+  state2.totalFailures += 1;
+  const latched = state2.consecutiveFailures >= STALE_CHILD_SPAWN_LATCH_THRESHOLD;
+  state2.latched ||= latched;
   const failure = {
     failureClass: STALE_CHILD_SPAWN_FAILURE,
     reason,
     persistedVersion,
     supportedVersion,
-    consecutiveFailures: state.consecutiveFailures,
-    totalFailures: state.totalFailures,
-    latched: state.latched
+    consecutiveFailures: state2.consecutiveFailures,
+    totalFailures: state2.totalFailures,
+    latched: state2.latched
   };
-  state.failure = failure;
-  const shouldSurface = state.latched && !state.noticeEmitted;
+  state2.failure = failure;
+  const shouldSurface = state2.latched && !state2.noticeEmitted;
   if (shouldSurface)
-    state.noticeEmitted = true;
+    state2.noticeEmitted = true;
   return { allowSpawn: false, failure, shouldSurface };
 }
 function probeChildSpawnFence(db) {
@@ -4614,9 +4787,9 @@ function probeChildSpawnFence(db) {
   } catch {
     return recordStaleFence(LATEST_SUPPORTED_VERSION, LATEST_SUPPORTED_VERSION, "read_error");
   }
-  state.consecutiveFailures = 0;
-  state.latched = false;
-  state.noticeEmitted = false;
+  state2.consecutiveFailures = 0;
+  state2.latched = false;
+  state2.noticeEmitted = false;
   return { allowSpawn: true };
 }
 
@@ -5811,6 +5984,18 @@ function messageId(message) {
   const id = infoOf(message).id;
   return typeof id === "string" ? id : null;
 }
+function recordedAssistantError(message) {
+  const info = infoOf(message);
+  if (info.error != null)
+    return info.error;
+  if (isSettledAssistant(message))
+    return;
+  const parts = message?.parts;
+  if (!Array.isArray(parts))
+    return;
+  const retry = parts.slice().reverse().find((part) => part !== null && typeof part === "object" && part.type === "retry");
+  return retry?.error ?? undefined;
+}
 function isSettledAssistant(message) {
   const info = infoOf(message);
   if (info.role !== "assistant")
@@ -5926,6 +6111,22 @@ async function promptAsyncAndWaitForIdle(client, request, options = {}) {
   let completionBaseline = new Set((await readMessages(session, sessionId, dir, signal)).map(messageId).filter((id) => id !== null));
   const initialBaseline = new Set(completionBaseline);
   activeSessionErrors.set(sessionId, undefined);
+  const failForHostError = async (hostError) => {
+    await abortChildRun(client, sessionId);
+    const error = new Error(`Host recorded session error: ${describeAssistantError(hostError)}`);
+    Object.assign(error, {
+      name: "DreamerProviderOutputFailureError",
+      transient: true,
+      [HOST_SESSION_ERROR]: true,
+      hostError
+    });
+    annotateSubagentInvocationError(error, {
+      attemptedModel: requestModelRef(request),
+      modelConfigKey: options.modelConfigKey,
+      hostError
+    });
+    throw error;
+  };
   try {
     let sent;
     try {
@@ -5960,22 +6161,17 @@ async function promptAsyncAndWaitForIdle(client, request, options = {}) {
       await sleep(pollIntervalMs, signal);
       const hostError = activeSessionErrors.get(sessionId);
       if (hostError !== undefined) {
-        const error = new Error(`Host recorded session error: ${describeAssistantError(hostError)}`);
-        Object.assign(error, {
-          name: "DreamerProviderOutputFailureError",
-          transient: true,
-          [HOST_SESSION_ERROR]: true,
-          hostError
-        });
-        annotateSubagentInvocationError(error, {
-          attemptedModel: requestModelRef(request),
-          modelConfigKey: options.modelConfigKey,
-          hostError
-        });
-        throw error;
+        await failForHostError(hostError);
       }
       const status = await readStatus(session, sessionId, dir, signal);
       const messages = await readMessages(session, sessionId, dir, signal);
+      const latestAssistant = messages.slice().reverse().find((message) => {
+        const id = messageId(message);
+        return id !== null && !completionBaseline.has(id) && infoOf(message).role === "assistant";
+      });
+      const assistantError = recordedAssistantError(latestAssistant);
+      if (assistantError !== undefined)
+        await failForHostError(assistantError);
       if (!sawOutput && messages.some((message) => {
         const id = messageId(message);
         return id !== null && !initialBaseline.has(id) && showsModelOutput(message);
@@ -9580,6 +9776,7 @@ function createV1HiddenCompletionExecutor(client, db, directory) {
     async attempt(handle, request) {
       if (!client)
         throw new Error("Hidden completion client is unavailable");
+      hostErrors.delete(handle.id);
       const identity = runIdentities.get(handle.id);
       const requestedModel = request.body?.model;
       const requestedRef = requestedModel && typeof requestedModel.providerID === "string" && typeof requestedModel.modelID === "string" ? `${requestedModel.providerID}/${requestedModel.modelID}` : undefined;
@@ -9622,9 +9819,9 @@ function createV1HiddenCompletionExecutor(client, db, directory) {
       });
       const assistantFailure = extractLatestAssistantFailure(messages);
       const hostError = hostErrors.get(handle.id);
-      if (assistantFailure) {
-        const finish = assistantFailure.finish ? ` (finish=${assistantFailure.finish})` : "";
-        const error = new Error(`Historian host recorded an assistant error${finish}: ${describeAssistantFailure(assistantFailure.error)}`, hostError === undefined ? undefined : { cause: hostError });
+      if (assistantFailure || hostError !== undefined) {
+        const finish = assistantFailure?.finish ? ` (finish=${assistantFailure.finish})` : "";
+        const error = new Error(`Historian host recorded an assistant error${finish}: ${describeAssistantFailure(assistantFailure?.error ?? hostError)}`, hostError === undefined ? undefined : { cause: hostError });
         annotateSubagentInvocationError(error, {
           attemptedModel: handle.attemptedModel,
           modelConfigKey: handle.modelConfigKey,
@@ -16603,7 +16800,7 @@ function insertDreamRun(db, run) {
 }
 
 // ../plugin/src/features/magic-context/dreamer/verify.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 
 // ../plugin/src/features/magic-context/dreamer/verify-diff.ts
 import { execFile as execFile3 } from "node:child_process";
@@ -16724,7 +16921,56 @@ Read only these changed line ranges if they may affect the claim.`
 }
 
 // ../plugin/src/features/magic-context/dreamer/verify-gate.ts
+import path12 from "node:path";
+
+// ../plugin/src/features/magic-context/dreamer/verify-state.ts
+import { createHash as createHash9 } from "node:crypto";
+import { readFile, realpath as realpath2 } from "node:fs/promises";
 import path11 from "node:path";
+function verificationMetadata(memory) {
+  try {
+    const parsed = JSON.parse(memory.metadataJson ?? "{}");
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+      return parsed;
+  } catch {}
+  return {};
+}
+async function verificationFilesFingerprint(directory, files) {
+  const root = await resolveGitTopLevel(directory) ?? path11.resolve(directory);
+  const hash = createHash9("sha256");
+  for (const file of [...new Set(files)].sort()) {
+    const absolute = path11.resolve(root, file);
+    const withinRoot = (candidate) => {
+      const relative = path11.relative(root, candidate);
+      return relative !== ".." && !relative.startsWith(`..${path11.sep}`) && !path11.isAbsolute(relative);
+    };
+    if (!withinRoot(absolute))
+      return null;
+    hash.update(JSON.stringify(file));
+    try {
+      if (!withinRoot(await realpath2(absolute)))
+        return null;
+      hash.update(createHash9("sha256").update(await readFile(absolute)).digest("hex"));
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        return null;
+      hash.update("missing");
+    }
+  }
+  return hash.digest("hex");
+}
+function recordVerificationVerdict(db, memory, verdict, at, fingerprint = null) {
+  const metadata = verificationMetadata(memory);
+  delete metadata.dreamerVerifySkip;
+  if (verdict === "skip" && fingerprint) {
+    metadata.dreamerVerifySkip = { contentHash: memory.normalizedHash, fingerprint, at };
+  }
+  metadata.dreamerVerifyVerdict = verdict;
+  metadata.dreamerVerifyAttemptedAt = at;
+  db.prepare("UPDATE memories SET metadata_json = ? WHERE id = ?").run(JSON.stringify(metadata), memory.id);
+}
+
+// ../plugin/src/features/magic-context/dreamer/verify-gate.ts
 function minOf(values) {
   return values.reduce((acc, v) => v < acc ? v : acc, Number.POSITIVE_INFINITY);
 }
@@ -16756,7 +17002,22 @@ async function partitionVerifyScope(args) {
   const runStartedAt = args.now ?? Date.now();
   const active = getMemoriesByProject2(args.db, args.projectIdentity);
   const verById = getMemoryVerifications(args.db, active.map((m) => m.id));
-  const candidates = active.filter((m) => (verById.get(m.id)?.files.length ?? 0) > 0);
+  const candidates = [];
+  const unchangedSkippedIds = [];
+  const changedSkippedIds = new Set;
+  for (const memory of active) {
+    const files = verById.get(memory.id)?.files ?? [];
+    if (!files.length)
+      continue;
+    const skip = verificationMetadata(memory).dreamerVerifySkip;
+    if (skip && skip.contentHash === memory.normalizedHash && typeof skip.fingerprint === "string" && skip.fingerprint === await verificationFilesFingerprint(args.projectDirectory, files)) {
+      unchangedSkippedIds.push(memory.id);
+    } else {
+      candidates.push(memory);
+      if (skip)
+        changedSkippedIds.add(memory.id);
+    }
+  }
   const toPrompt = (m) => {
     const verifiedAt = verById.get(m.id)?.verifiedAt ?? 0;
     let verifiedCommit = null;
@@ -16783,7 +17044,7 @@ async function partitionVerifyScope(args) {
       leaseKey: args.leaseKey,
       runStartedAt
     });
-    const broadCandidates = candidates.filter((m) => (verById.get(m.id)?.verifiedAt ?? 0) < broadCycleStartAt).sort((a, b) => {
+    const broadCandidates = candidates.filter((m) => changedSkippedIds.has(m.id) || (verById.get(m.id)?.verifiedAt ?? 0) < broadCycleStartAt).sort((a, b) => {
       const verifiedAtA = verById.get(a.id)?.verifiedAt ?? 0;
       const verifiedAtB = verById.get(b.id)?.verifiedAt ?? 0;
       return verifiedAtA - verifiedAtB || a.id - b.id;
@@ -16794,7 +17055,10 @@ async function partitionVerifyScope(args) {
       mode: "broad",
       inScope: broadCandidates.map(toPrompt),
       inScopeIds: broadCandidates.map((m) => m.id),
-      skippedIds: candidates.filter((m) => !broadIds.has(m.id)).map((m) => m.id),
+      skippedIds: [
+        ...unchangedSkippedIds,
+        ...candidates.filter((m) => !broadIds.has(m.id)).map((m) => m.id)
+      ],
       broadCycleStartAt,
       reason: `broad cycle (${broadCandidates.length} remain; started ${broadCycleStartAt})`
     };
@@ -16805,7 +17069,7 @@ async function partitionVerifyScope(args) {
       mode: "incremental",
       inScope: [],
       inScopeIds: [],
-      skippedIds: [],
+      skippedIds: unchangedSkippedIds,
       reason: "no file-mapped memories in scope"
     };
   }
@@ -16814,11 +17078,11 @@ async function partitionVerifyScope(args) {
     mode,
     inScope: candidates.map(toPrompt),
     inScopeIds: candidates.map((m) => m.id),
-    skippedIds: [],
+    skippedIds: unchangedSkippedIds,
     reason
   });
   const resolvedGitRoot = await resolveGitTopLevel(args.projectDirectory);
-  const gitRoot = resolvedGitRoot ?? path11.resolve(args.projectDirectory);
+  const gitRoot = resolvedGitRoot ?? path12.resolve(args.projectDirectory);
   const verifiedTimes = candidates.map((m) => verById.get(m.id)?.verifiedAt ?? 0).filter((t) => t > 0);
   const sinceMs = verifiedTimes.length > 0 ? minOf(verifiedTimes) : runStartedAt;
   const changeTimes = await readGitFileChangeTimesSince(args.projectDirectory, sinceMs, resolvedGitRoot ?? undefined);
@@ -16828,11 +17092,11 @@ async function partitionVerifyScope(args) {
   const head = await readGitHead(args.projectDirectory);
   const uncommitted = head ? await readGitChangedFilesSince(args.projectDirectory, head, resolvedGitRoot ?? undefined) ?? new Set : new Set;
   const inScope = [];
-  const skippedIds = [];
+  const skippedIds = [...unchangedSkippedIds];
   for (const m of candidates) {
     const v = verById.get(m.id);
     const verifiedAt = v?.verifiedAt ?? 0;
-    if (verifiedAt === 0) {
+    if (verifiedAt === 0 || changedSkippedIds.has(m.id)) {
       inScope.push(toPrompt(m));
       continue;
     }
@@ -17202,6 +17466,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
   let budgetFinalized = false;
   let failedCompletion;
   let headAtPrompt = null;
+  const skipSnapshots = new Map;
   const onBudgetUpdate = (state) => {
     budgetFinalized ||= state.finalizeFired;
     args.onBudgetUpdate?.({
@@ -17218,6 +17483,11 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     });
   };
   try {
+    if (!args.moduleRoute) {
+      for (const memory of batch) {
+        skipSnapshots.set(memory.id, await raceWithSignal(verificationFilesFingerprint(args.sessionDirectory, memory.mappedFiles), batchSignal));
+      }
+    }
     headAtPrompt = await raceWithSignal(readGitHead(args.sessionDirectory), batchSignal);
     const evidence = !args.forceBroad && batch.every((m) => m.verifiedAt) ? await raceWithSignal(buildVerifyDiffEvidence(args.sessionDirectory, batch), batchSignal) : null;
     const prompt = buildVerifyPrompt(args.projectIdentity, await raceWithSignal(seedVerifyCandidates(batch, args.sessionDirectory), batchSignal), evidence);
@@ -17259,7 +17529,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         tokens: run.completion.usage
       });
       reportUsage(run.completion.messages ?? [], run.childSessionId, run.completion.usage.input + (run.completion.usage.cacheRead ?? 0) + (run.completion.usage.cacheWrite ?? 0));
-      return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized);
+      return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized, skipSnapshots);
     }
     const client = args.client;
     if (!client)
@@ -17319,7 +17589,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     promptSettled = true;
     recordInvocation4(args, startedAt, { status: "completed", messages: run.output });
     reportUsage(run.output, agentSessionId);
-    return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized);
+    return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized, skipSnapshots);
   } catch (error) {
     const desc = describeError(error);
     const providerFailure = error instanceof DreamerProviderOutputFailureError ? error : undefined;
@@ -17339,7 +17609,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     if (interrupted) {
       const text = verifyAssistantText(messages) ?? failedCompletion?.text ?? "";
       const recovered = parsePartialVerifyManifest(text, new Set(batch.map((m) => m.id)));
-      const counts = await applyParsedVerifyManifest(args, batch, recovered, headAtPrompt, true);
+      const counts = await applyParsedVerifyManifest(args, batch, recovered, headAtPrompt, true, skipSnapshots);
       return {
         ...counts,
         timedOut: !(error instanceof DreamTokenBudgetExceeded),
@@ -17371,7 +17641,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     signal.removeEventListener("abort", abort);
   }
 }
-async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budgetFinalized = false) {
+async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budgetFinalized = false, skipSnapshots) {
   const batchIds = new Set(batch.map((m) => m.id));
   const batchById = new Map(batch.map((memory) => [memory.id, memory]));
   const valid = {
@@ -17450,6 +17720,15 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
     }
     writes.push({ kind: "archive", id: a.id, reason: a.reason });
   }
+  if (!args.moduleRoute) {
+    for (const entry of valid.skipped) {
+      const original = batchById.get(entry.id);
+      if (!original)
+        continue;
+      const fingerprint = skipSnapshots ? skipSnapshots.get(entry.id) ?? null : await verificationFilesFingerprint(args.sessionDirectory, original.mappedFiles);
+      writes.push({ kind: "skip", id: entry.id, fingerprint });
+    }
+  }
   let verified = 0;
   let updated = 0;
   let archived = 0;
@@ -17479,7 +17758,7 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
           name: "memory.set_verification",
           arguments: {
             memory_project: args.projectIdentity,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash9("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash10("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -17511,9 +17790,17 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
         continue;
       if (w.kind === "verify") {
         recordMemoryVerifications(args.db, w.id, w.files, now);
-        if (verifiedHead)
-          recordVerifiedCommit(args.db, memory, now, verifiedHead);
+        updateMemoryVerification2(args.db, w.id, "verified");
+        recordVerificationVerdict(args.db, memory, "verified", now);
+        const verifiedMemory = getMemoryById2(args.db, w.id);
+        if (verifiedHead && verifiedMemory)
+          recordVerifiedCommit(args.db, verifiedMemory, now, verifiedHead);
         verified += 1;
+      } else if (w.kind === "skip") {
+        if (memory.content !== batchById.get(w.id)?.content)
+          continue;
+        updateMemoryVerification2(args.db, w.id, "unverified");
+        recordVerificationVerdict(args.db, memory, "skip", now, w.fingerprint);
       } else if (w.kind === "update") {
         const duplicate = getMemoryByHash2(args.db, memory.projectPath, memory.category, w.hash);
         if (duplicate && duplicate.id !== memory.id) {
@@ -17522,6 +17809,8 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
           continue;
         }
         rewriteMemoryContent(args.db, memory, w.content, w.hash);
+        updateMemoryVerification2(args.db, w.id, "unverified");
+        recordVerificationVerdict(args.db, memory, "update", now);
         queueMemoryMutation(args.db, {
           projectPath: args.projectIdentity,
           mutationType: "update",
@@ -17532,6 +17821,8 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
         updated += 1;
       } else {
         archiveMemory2(args.db, w.id, w.reason);
+        updateMemoryVerification2(args.db, w.id, "stale");
+        recordVerificationVerdict(args.db, memory, "archive", now);
         queueMemoryMutation(args.db, {
           projectPath: args.projectIdentity,
           mutationType: "archive",
@@ -18325,7 +18616,7 @@ function parseFrictionGateVerdict(verdict) {
 }
 function computeRetrospectiveWindowKey(flagged) {
   const anchors = flagged.map((message) => `${message.sessionId}:${message.ts}`).sort().join("|");
-  return createHash10("sha256").update(anchors).digest("hex").slice(0, 32);
+  return createHash11("sha256").update(anchors).digest("hex").slice(0, 32);
 }
 function renderFrictionWindow(messages, flaggedOrdinals, radius = 2) {
   const flagged = new Set(flaggedOrdinals);
@@ -20425,16 +20716,17 @@ function resolvePiInvocation(options = {}) {
   const platform = options.platform ?? process.platform;
   const env = options.env ?? process.env;
   const resolvePackageJson = options.resolvePackageJson ?? defaultResolvePiPackageJson;
+  const scriptRuntime = isGenericRuntimeExecutable(execPath) ? execPath : "node";
   const running = resolvePiCliFromRunningEntry(currentScript, fs);
   const checkedPaths = [...running.checkedPaths];
   if (running.cliPath) {
     return {
-      command: execPath,
+      command: scriptRuntime,
       prefixArgs: [running.cliPath],
       targetHarness: running.targetHarness ?? piHarnessKindFromExecutable(running.cliPath) ?? resolvePiHarnessKind()
     };
   }
-  if (!isGenericRuntimeExecutable(execPath)) {
+  if (piHarnessKindFromExecutable(execPath) !== undefined || !isGenericRuntimeExecutable(execPath) && currentScript?.startsWith(BUN_VIRTUAL_SCRIPT_PREFIX)) {
     return {
       command: execPath,
       prefixArgs: [],
@@ -20444,7 +20736,7 @@ function resolvePiInvocation(options = {}) {
   const bundled = resolveBundledPiCli(currentScript, fs, resolvePackageJson, checkedPaths);
   if (bundled.cliPath) {
     return {
-      command: execPath,
+      command: scriptRuntime,
       prefixArgs: [bundled.cliPath],
       targetHarness: bundled.targetHarness ?? piHarnessKindFromExecutable(bundled.cliPath) ?? resolvePiHarnessKind()
     };
@@ -25696,7 +25988,9 @@ function resolveProtectedTailBoundary(ctx) {
   const offset = Math.max(1, ctx.lastCompartmentEndOrdinal + 1);
   const absoluteMessageCount = getCachedAbsoluteMessageCount2(ctx.sessionId) ?? getRawSessionMessageOrdinalCount2(ctx.sessionId);
   const messages = readRawSessionMessageRange2(ctx.sessionId, Math.max(1, offset - 1), absoluteMessageCount);
-  const storedTotals = ctx.storedTokenTotalsForMessages?.(messages.map((m) => m.id), messages) ?? ctx.storedTokenTotals;
+  const storedWeights = ctx.storedTokenTotalsForMessages?.(messages.map((m) => m.id), messages);
+  const storedTotals = storedWeights?.totals ?? ctx.storedTokenTotals;
+  const storedRemovedTotals = storedWeights?.summaryRemovedTotals ?? ctx.storedSummaryRemovedTokenTotals;
   const index = buildTrueRawTokenIndex(ctx.sessionId, messages, {
     providerShapeVersion: ctx.providerShapeVersion,
     cacheNamespace: ctx.cacheNamespace,
@@ -25707,6 +26001,14 @@ function resolveProtectedTailBoundary(ctx) {
       return v === undefined ? null : v;
     } : undefined
   });
+  const summaryRemovedIndex = buildTrueRawTokenIndex(ctx.sessionId, messages, {
+    providerShapeVersion: ctx.providerShapeVersion,
+    cacheNamespace: ctx.cacheNamespace,
+    calibration: ctx.calibration,
+    absoluteMessageCount,
+    measure: "summary-removed",
+    storedTotalForMessage: storedRemovedTotals ? (m) => storedRemovedTotals.get(m.id) ?? null : undefined
+  });
   const rawMessageCount = index.rawMessageCount;
   const usagePercentage = clampPercentage(ctx.usage?.percentage ?? 0);
   const usageInputTokens = Math.max(0, Math.round(ctx.usage?.inputTokens ?? 0));
@@ -25738,6 +26040,7 @@ function resolveProtectedTailBoundary(ctx) {
       createdAt,
       rawRangeFingerprint: "",
       trueRawEligibleTokens: 0,
+      summaryRemovedEligibleTokens: 0,
       oversizeAtomicUnit: false,
       boundaryReason: "empty-session"
     };
@@ -25781,6 +26084,7 @@ function resolveProtectedTailBoundary(ctx) {
       createdAt,
       rawRangeFingerprint,
       trueRawEligibleTokens: index.rangeTokens(offset, protectedTailStart),
+      summaryRemovedEligibleTokens: summaryRemovedIndex.rangeTokens(offset, protectedTailStart),
       oversizeAtomicUnit: false,
       boundaryReason: firstOpenArc ? "open-tool-arc" : "manual-full-recomp"
     };
@@ -25857,7 +26161,7 @@ function resolveProtectedTailBoundary(ctx) {
     observeDiagnostics: (value) => {
       headDiagnostics = value;
     },
-    index,
+    index: summaryRemovedIndex,
     protectedTailStart,
     offset,
     arcs,
@@ -25896,6 +26200,7 @@ function resolveProtectedTailBoundary(ctx) {
     createdAt,
     rawRangeFingerprint,
     trueRawEligibleTokens: index.rangeTokens(offset, eligibleEndOrdinal),
+    summaryRemovedEligibleTokens: summaryRemovedIndex.rangeTokens(offset, eligibleEndOrdinal),
     oversizeAtomicUnit: head.oversizeAtomicUnit,
     boundaryReason,
     diagnostics: boundaryDiagnostics({
@@ -25943,8 +26248,11 @@ function resolveBoundaryContext(args) {
   const calibration = sessionDecisionCalibration(args.db, args.sessionId);
   const storedTokenTotalsForMessages = (messageIds, messages = []) => {
     try {
-      const totals = getAllStatusTagTokenTotalsFlat2(args.db, args.sessionId, args.taggerFloor ?? 0, calibration, messageIds).totals;
-      return omitIncompleteFileTokenTotals(args.db, args.sessionId, messages, totals);
+      const weights = getAllStatusTagTokenTotalsFlat2(args.db, args.sessionId, args.taggerFloor ?? 0, calibration, messageIds);
+      return {
+        totals: omitIncompleteFileTokenTotals(args.db, args.sessionId, messages, weights.totals),
+        summaryRemovedTotals: weights.summaryRemovedTotals
+      };
     } catch (error) {
       sessionLog2(args.sessionId, "protected-tail stored-token map unavailable (live fallback):", error);
       return;
@@ -25980,7 +26288,9 @@ function resolveWrapupProtectedTailBoundary(args) {
   const offset = Math.max(1, ctx.lastCompartmentEndOrdinal + 1);
   const absoluteMessageCount = getCachedAbsoluteMessageCount2(ctx.sessionId) ?? getRawSessionMessageOrdinalCount2(ctx.sessionId);
   const messages = readRawSessionMessageRange2(ctx.sessionId, Math.max(1, offset - 1), absoluteMessageCount);
-  const storedTotals = ctx.storedTokenTotalsForMessages?.(messages.map((m) => m.id), messages) ?? ctx.storedTokenTotals;
+  const storedWeights = ctx.storedTokenTotalsForMessages?.(messages.map((m) => m.id), messages);
+  const storedTotals = storedWeights?.totals ?? ctx.storedTokenTotals;
+  const storedRemovedTotals = storedWeights?.summaryRemovedTotals ?? ctx.storedSummaryRemovedTokenTotals;
   const index = buildTrueRawTokenIndex(ctx.sessionId, messages, {
     providerShapeVersion: ctx.providerShapeVersion,
     cacheNamespace: ctx.cacheNamespace,
@@ -25991,6 +26301,14 @@ function resolveWrapupProtectedTailBoundary(args) {
       return value === undefined ? null : value;
     } : undefined
   });
+  const summaryRemovedIndex = buildTrueRawTokenIndex(ctx.sessionId, messages, {
+    providerShapeVersion: ctx.providerShapeVersion,
+    cacheNamespace: ctx.cacheNamespace,
+    calibration: ctx.calibration,
+    absoluteMessageCount,
+    measure: "summary-removed",
+    storedTotalForMessage: storedRemovedTotals ? (m) => storedRemovedTotals.get(m.id) ?? null : undefined
+  });
   const rawMessageCount = index.rawMessageCount;
   const anchorRawMessageCount = Math.max(0, Math.min(rawMessageCount, Math.floor(args.anchorRawMessageCount ?? rawMessageCount)));
   const usagePercentage = clampPercentage(ctx.usage?.percentage ?? 0);
@@ -26052,7 +26370,7 @@ function resolveWrapupProtectedTailBoundary(args) {
     observeDiagnostics: (value) => {
       headDiagnostics = value;
     },
-    index,
+    index: summaryRemovedIndex,
     protectedTailStart: targetProtectedTailStart,
     offset,
     arcs: buildToolArcs(messages),
@@ -26089,6 +26407,7 @@ function resolveWrapupProtectedTailBoundary(args) {
     createdAt,
     rawRangeFingerprint,
     trueRawEligibleTokens: index.rangeTokens(offset, targetProtectedTailStart),
+    summaryRemovedEligibleTokens: summaryRemovedIndex.rangeTokens(offset, eligibleEndOrdinal),
     oversizeAtomicUnit: head.oversizeAtomicUnit,
     boundaryReason,
     diagnostics: boundaryDiagnostics({
@@ -27513,6 +27832,52 @@ ${typeof state?.output === "string" ? state.output : JSON.stringify(state?.outpu
   };
 }
 
+// ../plugin/src/hooks/magic-context/transform-context-state.ts
+var usageRefusals = new WeakMap;
+function recordUsageRefusal(db, sessionId, refusedAt = Date.now()) {
+  let sessions = usageRefusals.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    usageRefusals.set(db, sessions);
+  }
+  if (!sessions.has(sessionId))
+    sessions.set(sessionId, refusedAt);
+}
+function shouldResetRefusedUsage(db, sessionId, meta, liveReading) {
+  const refusals = usageRefusals.get(db);
+  const refusedAt = refusals?.get(sessionId);
+  if (refusedAt === undefined)
+    return false;
+  const readingAt = liveReading?.hasUsageTokens ? liveReading.updatedAt : meta.lastResponseTime;
+  if (readingAt > refusedAt) {
+    refusals?.delete(sessionId);
+    return false;
+  }
+  const now = Date.now();
+  const foldedAt = meta.cachedM0MaterializedAt ?? 0;
+  if (foldedAt > refusedAt && foldedAt <= now)
+    return true;
+  return !!db.prepare("SELECT 1 FROM compartments WHERE session_id = ? AND harness = ? AND created_at > ? AND created_at <= ? LIMIT 1").get(sessionId, getHarness2(), refusedAt, now);
+}
+function resolveUnknownUsageFromWireEstimate(input) {
+  if (input.usage.inputTokens > 0 || !input.pricedPass)
+    return input.usage;
+  const wireTokens = input.wireEstimateTokens;
+  if (typeof wireTokens !== "number" || !Number.isFinite(wireTokens) || wireTokens <= 0) {
+    return input.usage;
+  }
+  const providerTokens = input.providerProvenInputTokens;
+  const providerLimit = input.providerProvenLimitTokens;
+  const canUseProviderMass = input.wireEstimateTrusted === false && typeof providerTokens === "number" && Number.isFinite(providerTokens) && providerTokens > 0 && typeof providerLimit === "number" && Number.isFinite(providerLimit) && providerLimit > 0;
+  const tokens = canUseProviderMass ? Math.max(wireTokens, providerTokens) : wireTokens;
+  const limit = input.usableHardLimit;
+  const estimatedPercentage = typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? tokens / limit * 100 : input.usage.percentage;
+  return {
+    inputTokens: tokens,
+    percentage: Math.max(input.usage.percentage, estimatedPercentage)
+  };
+}
+
 // ../plugin/src/hooks/magic-context/transform-stage-logger.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var SLOW_STAGE_MS = 100;
@@ -27570,7 +27935,7 @@ function recoveryReasoningPrefixes(messages, partsKey) {
 }
 
 // ../plugin/src/shared/tag-transcript.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function buildPersistedDropTargets(transcript, tags, options = {}) {
   const targets = new Map;
   const tools = new Map(tags.filter((tag) => tag.type === "tool").map((tag) => [makeToolCompositeKey(tag.toolOwnerMessageId ?? "", tag.messageId), tag]));
@@ -27653,7 +28018,7 @@ function buildPersistedDropTargets(transcript, tags, options = {}) {
   return targets;
 }
 function textIdentityDigest(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 function buildContentDerivedTextIds(messageId, parts) {
   const sources = parts.filter((part) => part.kind === "text").map((part) => stripTagPrefix(part.getText() ?? ""));
@@ -28781,7 +29146,7 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
     }
     const fresh = !slot;
     if (!slot) {
-      const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { ...input, persistent: true } }));
+      const worker = inRootAsyncContext2(() => input.job === "backfill" && entry.href === defaultAutoSearchWorkerEntry().href ? reuseWorker(entry, { workerData: input }) : new Worker(entry, { workerData: { ...input, persistent: true } }));
       const shutdown = createWorkerShutdown(worker, "auto-search", AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS);
       slot = {
         worker,
@@ -28859,6 +29224,7 @@ function queueAutoSearchBackfill(db, sessionId, projectPath, query) {
   pending.set(key, work);
   return work;
 }
+var nextSearchJobId = 0;
 async function executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, job) {
   if (options.signal?.aborted)
     return [];
@@ -28879,6 +29245,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
   const signal = deadlineSignal ? AbortSignal.any([deadlineSignal, lifecycle.signal]) : lifecycle.signal;
   const snapshot = getProjectEmbeddingSnapshot2(projectPath);
   const input = {
+    jobId: ++nextSearchJobId,
     job,
     path,
     harness: getHarness2(),
@@ -28998,6 +29365,8 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     const onMessage = async (reply) => {
       if (released)
         return;
+      if (entry.href === defaultAutoSearchWorkerEntry().href && reply.jobId !== input.jobId)
+        return;
       if (reply.kind === "diagnostics") {
         if (!settled && options.autoSearchDiagnostics) {
           const workerStarted = options.autoSearchDiagnostics.workerStarted;
@@ -29025,7 +29394,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       }
       if (reply.kind === "messages" || reply.kind === "accepted")
         return;
-      const response = { id: reply.id };
+      const response = { id: reply.id, jobId: input.jobId };
       if (!signal.aborted) {
         const requestedAt = performance.now();
         try {
@@ -29534,7 +29903,7 @@ function persistFilteredNoise(db, sessionId, chunk, eligibleEnd) {
 }
 
 // src/pi-history-retirement.ts
-var KEY = "piHistorianRetirement";
+var KEY2 = "piHistorianRetirement";
 function readState(db, sessionId) {
   const row = db.prepare("SELECT deferred_execute_state AS state FROM session_meta WHERE session_id = ?").get(sessionId);
   const state = row?.state ? JSON.parse(row.state) : {};
@@ -29543,24 +29912,24 @@ function readState(db, sessionId) {
   return state;
 }
 function readPiHistoryRetirement(db, sessionId) {
-  const target = readState(db, sessionId)[KEY];
+  const target = readState(db, sessionId)[KEY2];
   return typeof target === "string" && target.length > 0 ? target : null;
 }
 function queuePiHistoryRetirement(db, sessionId, throughMessageId) {
   ensureSessionMetaRow(db, sessionId);
   const state = readState(db, sessionId);
-  state[KEY] = throughMessageId;
+  state[KEY2] = throughMessageId;
   db.prepare("UPDATE session_meta SET deferred_execute_state = ? WHERE session_id = ?").run(JSON.stringify(state), sessionId);
 }
 function acknowledgePiHistoryRetirement(db, sessionId, publishedEnd, ordinalOf) {
   const state = readState(db, sessionId);
-  const target = state[KEY];
+  const target = state[KEY2];
   if (typeof target !== "string")
     return;
   const ordinal = ordinalOf(target);
   if (ordinal === undefined || ordinal > publishedEnd)
     return;
-  delete state[KEY];
+  delete state[KEY2];
   db.prepare("UPDATE session_meta SET deferred_execute_state = ? WHERE session_id = ?").run(JSON.stringify(state), sessionId);
 }
 
@@ -30089,7 +30458,7 @@ async function runPiHistorian(deps) {
         db,
         sessionId,
         runId: crypto2.randomUUID(),
-        trueRawTokens: boundarySnapshot.trueRawEligibleTokens,
+        trueRawTokens: boundarySnapshot.summaryRemovedEligibleTokens,
         usagePercentage: boundarySnapshot.usagePercentage,
         usable,
         perRunCap,
@@ -32134,12 +32503,28 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
     const priorInputSample = getEmergencyInputSample(db, sessionId);
     const candidateTags = tags.filter((t) => t.status === "active" && t.type === "tool" && targets.get(t.tagNumber)?.canDrop?.());
     const recentTags = new Set(candidateTags.slice().sort((a, b) => b.tagNumber - a.tagNumber).slice(0, 20).map((tag) => tag.tagNumber));
-    const calibration = sessionDecisionCalibration(db, sessionId);
+    const calibration = emergency.fitCalibration ?? sessionDecisionCalibration(db, sessionId);
     const tPrepare = performance.now();
     config.prepareToolRemovalMeasurements?.(tags.flatMap((tag) => tag.status === "active" && tag.type === "tool" && tag.messageId && targets.get(tag.tagNumber)?.measureReclaim ? [tag.messageId] : []));
     logStep("prepareNativeRemovals", tPrepare);
     const tMeasure = performance.now();
-    const activeTags = tags.filter((t) => t.status === "active").map((tag) => measureEmergencyTag(tag, targets.get(tag.tagNumber), calibration, targets.get(tag.tagNumber)?.requiresToolArcSkeleton === true || (emergency.usagePercentage ?? 0) < 95 && recentTags.has(tag.tagNumber) && hasSmallToolInput(targets.get(tag.tagNumber))));
+    const activeTags = tags.filter((t) => t.status === "active").map((tag) => {
+      const target = targets.get(tag.tagNumber);
+      const imageTokens = emergency.serializedImageTokens?.get(tag.messageId) ?? 0;
+      const observation = target?.measureReclaim;
+      const measuredTarget = imageTokens && observation ? {
+        ...target,
+        measureReclaim(skeleton) {
+          const measured = observation(skeleton);
+          return measured ? {
+            ...measured,
+            beforeTools: measured.beforeTools + imageTokens,
+            afterTools: measured.afterTools + (target.canDrop?.() ? 0 : imageTokens)
+          } : measured;
+        }
+      } : target;
+      return measureEmergencyTag(tag, measuredTarget, calibration, targets.get(tag.tagNumber)?.requiresToolArcSkeleton === true || (emergency.usagePercentage ?? 0) < 95 && recentTags.has(tag.tagNumber) && hasSmallToolInput(targets.get(tag.tagNumber)));
+    });
     const byTag = new Map(activeTags.map((tag) => [tag.tagNumber, tag]));
     const droppableTags = candidateTags.flatMap((tag) => {
       const measured = byTag.get(tag.tagNumber);
@@ -35441,10 +35826,10 @@ function authorizePiToolRemoval(args) {
 }
 
 // src/native-replay-tag-provenance-pi.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 var PI_NATIVE_TAG_STRIP_PROVENANCE = "magicContextNativeTagStrips";
 function nativeResponseTagStripKey(id, phase, text) {
-  return createHash12("sha256").update(JSON.stringify([id, phase, text])).digest("hex");
+  return createHash13("sha256").update(JSON.stringify([id, phase, text])).digest("hex");
 }
 function ownsNativeResponseTagStrip(decisions, id, phase, text) {
   if (!isRecord(decisions) || phase !== undefined && phase !== "commentary" && phase !== "final_answer")
@@ -36869,7 +37254,7 @@ function piWithoutDateReminders(payload, api, cwd, developerRole, includesPrepar
     const text = google ? singleText(row.parts) : api === "bedrock-converse-stream" ? singleText(row.content) : api.endsWith("responses") ? singleText(row.content, "input_text") ?? (api === "openai-codex-responses" ? row.content : undefined) : row.content;
     if (piDateReminderText(text, cwd)) {
       const keys = google ? ["role", "parts"] : api.endsWith("responses") ? ["role", "content", "type"] : ["role", "content"];
-      const role = api === "ollama-chat" ? "system" : api === "openai-completions" && developerRole ? "developer" : "user";
+      const role = api === "ollama-chat" ? "system" : api === "openai-codex-responses" || api === "openai-completions" && developerRole ? "developer" : "user";
       if (!firstUser || row.role !== role || Object.keys(row).some((key) => !keys.includes(key)) || row.type !== undefined && row.type !== "message")
         return;
       if (!removed) {
@@ -37126,6 +37511,14 @@ function piResponsesAssistantTexts(value, model, host, alternatives, frozenTagSt
   const payload = object10(message.providerPayload);
   if (message.api !== model?.api || typeof model?.id !== "string" || typeof model?.provider !== "string" || message.model !== model?.id || (payload?.provider ?? message.provider) !== model?.provider || payload?.type !== "openaiResponsesHistory" || payload.dt !== true || !Array.isArray(payload.items))
     return texts;
+  if (host === "omp" && model.api === "openai-codex-responses" && texts.every((text) => !/\S/u.test(JSON.parse(text)[0])) && payload.items.every((value) => {
+    const item = object10(value);
+    return item?.type === "reasoning" || item?.type === "message" && item.role === "assistant" && Array.isArray(item.content) && item.content.every((value) => {
+      const part = object10(value);
+      return part?.type === "output_text" && typeof part.text === "string" && !/\S/u.test(part.text);
+    });
+  }))
+    return [];
   const replay = [];
   let bound = 0;
   let output = false;
@@ -38224,13 +38617,16 @@ function countAnthropicOptionalAlignments(plan, base, wire, compare, reminders,
 function piPreparedStructureMismatch(payload, prepared, onImageTrim) {
   const plan = prepared && dateReminderPlans.get(prepared);
   try {
-    const messages = plan ? object11(payload)?.messages : undefined;
+    const body = plan ? object11(payload) : undefined;
+    const messages = body?.messages ?? body?.input;
     if (Array.isArray(messages)) {
       for (const value of messages) {
         const message = object11(value);
         if (message?.role !== "system" && message?.role !== "developer")
           break;
-        if (piDateReminderWireText(message.content, plan?.cwd) !== undefined)
+        const content = message.content;
+        const inputText = Array.isArray(content) && content.length === 1 && object11(content[0])?.type === "input_text" ? object11(content[0])?.text : undefined;
+        if (piDateReminderWireText(content, plan?.cwd) !== undefined || piDateReminderText(inputText, plan?.cwd))
           return "comparison=role";
       }
     }
@@ -40297,9 +40693,9 @@ function createPiFallbackIndex() {
 }
 
 // src/pi-fit-reclaim.ts
-import { createHash as createHash13, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash14, randomUUID as randomUUID4 } from "node:crypto";
 var pendingInput = new Set;
-var KEY2 = "piUpperEstimateReclaim";
+var KEY3 = "piUpperEstimateReclaim";
 function piFitOverflowPossible(args) {
   if (!args.hasUI && args.inputTokens <= 0 || args.recoveryArmed || args.forceMaterialization || args.imported || args.coldInjection || args.cacheBusting || pendingInput.has(args.sessionId))
     return true;
@@ -40333,7 +40729,7 @@ function piUpperReclaimCursor(args) {
     sessionId: args.sessionId,
     modelKey: args.modelKey,
     contextWindow: args.contextWindow ?? null,
-    head: head ? createHash13("sha256").update(JSON.stringify([
+    head: head ? createHash14("sha256").update(JSON.stringify([
       Buffer.from(head.cachedM0Bytes ?? []).toString("base64"),
       Buffer.from(head.cachedM1Bytes ?? []).toString("base64"),
       head.cachedM0MuralDataUrl ?? null
@@ -40351,18 +40747,18 @@ function canReclaim(previous, cursor) {
 function shouldReclaimPiUpperEstimate(db, cursor) {
   if (!cursor)
     return false;
-  return canReclaim(claimFrom(readReplayEnvelope(db, cursor.sessionId)[KEY2], cursor.sessionId), cursor);
+  return canReclaim(claimFrom(readReplayEnvelope(db, cursor.sessionId)[KEY3], cursor.sessionId), cursor);
 }
 function reservePiUpperEstimateReclaim(db, cursor) {
   const reservation = randomUUID4();
   return db.transaction(() => {
     let claimed = false;
     if (!updateReplayDocument(db, cursor.sessionId, (doc) => {
-      claimed = canReclaim(claimFrom(doc[KEY2], cursor.sessionId), cursor);
+      claimed = canReclaim(claimFrom(doc[KEY3], cursor.sessionId), cursor);
       if (!claimed)
         return false;
       doc.version = 2;
-      doc[KEY2] = { ...cursor, reservation };
+      doc[KEY3] = { ...cursor, reservation };
       return true;
     }))
       throw new Error("Could not reserve upper-estimate reclaim");
@@ -40374,10 +40770,10 @@ function recordPiUpperEstimateReclaim(db, cursor, reservation) {
   if (!owner)
     return;
   if (!updateReplayDocument(db, cursor.sessionId, (doc) => {
-    if (claimFrom(doc[KEY2], cursor.sessionId)?.reservation !== owner)
+    if (claimFrom(doc[KEY3], cursor.sessionId)?.reservation !== owner)
       return false;
     doc.version = 2;
-    doc[KEY2] = cursor;
+    doc[KEY3] = cursor;
     return true;
   }))
     throw new Error("Could not persist upper-estimate reclaim cursor");
@@ -40386,19 +40782,19 @@ function recordPiUpperEstimateReclaim(db, cursor, reservation) {
 function releasePiUpperEstimateReclaim(db, cursor, reservation) {
   withoutSqliteTransformPass2(() => withSqliteTurnDeadline2(() => 0, () => {
     if (!updateReplayDocument(db, cursor.sessionId, (doc) => {
-      if (claimFrom(doc[KEY2], cursor.sessionId)?.reservation !== reservation)
+      if (claimFrom(doc[KEY3], cursor.sessionId)?.reservation !== reservation)
         return false;
-      delete doc[KEY2];
+      delete doc[KEY3];
       return true;
     }))
       throw new Error("Could not release upper-estimate reclaim");
   }));
 }
 function resetPiUpperEstimateReclaim(db, sessionId) {
-  if (!claimFrom(readReplayEnvelope(db, sessionId)[KEY2], sessionId))
+  if (!claimFrom(readReplayEnvelope(db, sessionId)[KEY3], sessionId))
     return;
   if (!updateReplayDocument(db, sessionId, (doc) => {
-    delete doc[KEY2];
+    delete doc[KEY3];
     return true;
   }))
     throw new Error("Could not clear upper-estimate reclaim cursor");
@@ -40420,7 +40816,7 @@ async function waitForPiHistorianInTurn(sessionId, remainingMs, wait) {
 }
 
 // src/pi-lkg-fit-envelope.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen, wireSchema) {
   try {
     if (!modelKey || typeof pi.getAllTools !== "function")
@@ -40482,7 +40878,7 @@ function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen, wireSchema) {
       refusalToolDefinitionTokens,
       toolDefinitionsMeasured: refusalToolDefinitionTokens !== undefined,
       envelopeBytes: Buffer.byteLength(envelopeJson),
-      envelopeSignature: activeNames ? createHash14("sha256").update(envelopeJson).update(JSON.stringify(activeNames)).digest("hex") : undefined,
+      envelopeSignature: activeNames ? createHash15("sha256").update(envelopeJson).update(JSON.stringify(activeNames)).digest("hex") : undefined,
       calibration
     };
   } catch {
@@ -40491,13 +40887,13 @@ function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen, wireSchema) {
 }
 
 // src/pi-message-identity.ts
-import { createHash as createHash17 } from "node:crypto";
+import { createHash as createHash18 } from "node:crypto";
 
 // src/pi-tool-identity.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 
 // src/served-array-ledger.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import {
   closeSync as closeSync2,
   fstatSync,
@@ -40507,7 +40903,7 @@ import {
   readSync as readSync2,
   statSync as statSync6
 } from "node:fs";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 
 // src/pi-served-identities.ts
 class PiServedEnvelopeUnavailable extends Error {
@@ -40775,20 +41171,20 @@ function getPiLastServedArray(sessionId) {
   return previous ? `[${previous.serializedMessages.join(",")}]` : undefined;
 }
 function sha256(value) {
-  return createHash15("sha256").update(value).digest("hex");
+  return createHash16("sha256").update(value).digest("hex");
 }
 function safeSessionFileStem(sessionId) {
   const readable = sessionId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 96);
   return `${readable || "session"}-${sha256(sessionId).slice(0, 12)}`;
 }
 function getPiServedArrayLedgerPath(sessionId, storageDir = getMagicContextStorageDir()) {
-  return path12.join(storageDir, LEDGER_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
+  return path13.join(storageDir, LEDGER_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
 }
 function getPiServedArrayBodyPath(sessionId, storageDir = getMagicContextStorageDir()) {
-  return path12.join(storageDir, BODY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
+  return path13.join(storageDir, BODY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
 }
 function getPiServedTagNumbersPath(sessionId, storageDir = getMagicContextStorageDir()) {
-  return path12.join(storageDir, IDENTITY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
+  return path13.join(storageDir, IDENTITY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
 }
 function fullBodyCaptureEnabled() {
   const value = process.env[PI_SERVED_ARRAY_BODY_CAPTURE_ENV]?.trim().toLowerCase();
@@ -40837,7 +41233,7 @@ function recordWriteFailure(error) {
 }
 function appendPendingLines(filePath, lines) {
   try {
-    ensureStorageDirectorySync(path12.dirname(filePath));
+    ensureStorageDirectorySync(path13.dirname(filePath));
     repairZeroTail(filePath);
     writeStorageFileSync(filePath, lines.join(""), {
       encoding: "utf8",
@@ -40944,7 +41340,7 @@ function capturePiServedArray(sessionId, messages, options = {}) {
     const identityPath = getPiServedTagNumbersPath(sessionId, storageDir);
     if (newNumbers.length) {
       identityPersistenceFailed = true;
-      ensureStorageDirectorySync(path12.dirname(identityPath));
+      ensureStorageDirectorySync(path13.dirname(identityPath));
       options.assertCurrentPass?.();
       repairZeroTail(identityPath, !!options.db);
       writeStorageFileSync(identityPath, `${JSON.stringify({ version: 1, session_id: sessionId, tag_numbers: newNumbers })}
@@ -41060,7 +41456,7 @@ function readPiServedCachedArray(sessionId) {
   const memory = getPiLastServedArray(sessionId);
   const slot = memory === undefined ? getSlot(sessionId) : undefined;
   const jsonPrefix = memory ?? slot?.jsonPrefix;
-  if (jsonPrefix === undefined || createHash16("sha256").update(jsonPrefix).digest("hex") !== getPiLastServedDigest(sessionId))
+  if (jsonPrefix === undefined || createHash17("sha256").update(jsonPrefix).digest("hex") !== getPiLastServedDigest(sessionId))
     return;
   let parsed;
   try {
@@ -41084,7 +41480,7 @@ function piMessageEntryFingerprint(message) {
   const m = message;
   if (typeof m.role !== "string")
     return null;
-  const contentHash = createHash17("sha256").update(stableStringify(m.content)).digest("hex");
+  const contentHash = createHash18("sha256").update(stableStringify(m.content)).digest("hex");
   return JSON.stringify([
     typeof m.responseId === "string" ? m.responseId : null,
     typeof m.timestamp === "number" || typeof m.timestamp === "string" ? m.timestamp : null,
@@ -41136,6 +41532,83 @@ function piCachedMessageSurvivor(sessionId, fingerprint, ordinal, rows) {
   return carriers.length === 1 ? winner.tagNumber : undefined;
 }
 
+// src/pi-overflow-recovery.ts
+function piRecoveryFitCalibration(calibration) {
+  return calibration.seeded ? calibration : { toolsRatio: UNKNOWN_FIT_RATIO, proseRatio: UNKNOWN_FIT_RATIO };
+}
+function piRecoveryToolImageTokens(messages) {
+  const counts = new Map;
+  const seen = new Set;
+  for (const value of messages) {
+    const message = value;
+    if (message?.role !== "toolResult" || !message.toolCallId || !Array.isArray(message.content))
+      continue;
+    if (seen.has(message.toolCallId)) {
+      counts.delete(message.toolCallId);
+      continue;
+    }
+    seen.add(message.toolCallId);
+    for (const part of message.content) {
+      if (part?.type === "image")
+        counts.set(message.toolCallId, (counts.get(message.toolCallId) ?? 0) + estimateTokens(JSON.stringify(part)));
+    }
+  }
+  return counts;
+}
+function estimatePiOverflowRecoveryInputTokens(messages, envelope) {
+  if (!envelope || !estimatePiOutgoingInputTokens([], envelope).trusted)
+    return;
+  const raw = tokenizePiMessages([...messages]);
+  for (const value of messages) {
+    if (!value || typeof value !== "object")
+      return;
+    const message = value;
+    if (message.role === "system") {
+      if (typeof message.content === "string")
+        continue;
+      if (!Array.isArray(message.content) || !message.content.every((part) => part?.type === "text" && typeof part.text === "string"))
+        return;
+      continue;
+    }
+    if (!["user", "assistant", "toolResult", "custom"].includes(message.role ?? ""))
+      return;
+    if (typeof message.content === "string")
+      continue;
+    if (!Array.isArray(message.content))
+      return;
+    for (const value of message.content) {
+      if (!value || typeof value !== "object")
+        return;
+      const part = value;
+      if (part.type === "image") {
+        if (typeof part.data !== "string")
+          return;
+        const delta = estimateTokens(JSON.stringify(part)) - PI_IMAGE_TOKENS;
+        if (message.role === "toolResult")
+          raw.toolCall += delta;
+        else
+          raw.conversation += delta;
+      } else if (!["text", "thinking", "redacted_thinking", "toolCall"].includes(part.type ?? ""))
+        return;
+    }
+  }
+  return providerMass({
+    system: envelope.systemTokens,
+    tools: envelope.toolDefinitionTokens + raw.toolCall,
+    prose: raw.conversation
+  }, envelope.calibration ?? calibrationForModelKey(envelope.modelKey), true);
+}
+function resolvePiOverflowRecoveryUsage(args) {
+  if (!args.pricedPass || !args.providerOverflow || args.usage.inputTokens > 0)
+    return args.usage;
+  return resolveUnknownUsageFromWireEstimate({
+    usage: args.usage,
+    pricedPass: args.pricedPass,
+    wireEstimateTokens: estimatePiOverflowRecoveryInputTokens(args.messages, args.envelope),
+    usableHardLimit: args.usableHardLimit
+  });
+}
+
 // src/pi-pressure.ts
 var MAX_UNKNOWN_PI_INPUT_TOKENS = 3000000;
 function piPressureEvidenceLimit(geometry) {
@@ -43764,7 +44237,8 @@ function convertLocatedPiUserEntry(branchEntries, messageId, ordinalOffset = 0)
       const converted = convertEntriesToRawMessages(branchEntries.slice(start, index + 1)).find((message) => message.id === messageId);
       return converted ? { ...converted, ordinal: rawOrdinal } : null;
     }
-    pendingToolStart = -1;
+    if (role === "user" || role === "assistant")
+      pendingToolStart = -1;
   }
   return null;
 }
@@ -45132,16 +45606,18 @@ function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {
 var EMPTY_PI_HISTORIAN_STATE_SNAPSHOT = {
   detectedContextLimit: 0,
   needsEmergencyRecovery: false,
+  emergencyRecoveryOrigin: null,
   historianFailureCount: 0
 };
 function loadPiHistorianStateSnapshot(db, sessionId) {
-  const row = db.prepare(`SELECT detected_context_limit, needs_emergency_recovery,
+  const row = db.prepare(`SELECT detected_context_limit, needs_emergency_recovery, emergency_recovery_origin,
 			        historian_failure_count
 			   FROM session_meta
 			  WHERE session_id = ?`).get(sessionId);
   return {
     detectedContextLimit: typeof row?.detected_context_limit === "number" && row.detected_context_limit > 0 ? row.detected_context_limit : 0,
     needsEmergencyRecovery: typeof row?.needs_emergency_recovery === "number" && row.needs_emergency_recovery > 0,
+    emergencyRecoveryOrigin: row?.emergency_recovery_origin === "provider_overflow" || row?.emergency_recovery_origin === "proactive_model_shrink" ? row.emergency_recovery_origin : null,
     historianFailureCount: typeof row?.historian_failure_count === "number" && row.historian_failure_count >= 0 ? row.historian_failure_count : 0
   };
 }
@@ -45164,6 +45640,13 @@ function registerPiContextHandler(pi, baseOptions) {
     }
     return s;
   };
+  pi.on("tool_call", (event, ctx) => {
+    if (event.toolName !== "ctx_reduce")
+      return;
+    const sessionId = resolveSessionId2(ctx);
+    if (sessionId)
+      trackPiDropLeaf(baseOptions.db, sessionId, ctx.sessionManager.getLeafId());
+  });
   pi.on("session_tree", (event, ctx) => {
     if (event.oldLeafId === event.newLeafId)
       return;
@@ -45512,6 +45995,7 @@ function registerPiContextHandler(pi, baseOptions) {
           commitPiCompactionModeRecord(options.db, sessionId, compactionTransition.recordToWrite);
         }
       }
+      const usageResetAfterRefusal = shouldResetRefusedUsage(options.db, sessionId, sessionMetaForUsage);
       const usageReset = {
         lastContextPercentage: 0,
         lastInputTokens: 0,
@@ -45534,8 +46018,8 @@ function registerPiContextHandler(pi, baseOptions) {
         sessionMetaForUsage.lastInputTokens = 0;
         sessionMetaForUsage.observedSafeInputTokens = 0;
         sessionMetaForUsage.cacheAlertSent = false;
-      } else if (isFirstContextPassForSession && sessionMetaForUsage.lastContextPercentage > 0) {
-        sessionLog2(sessionId, `transform: first pass reset — percentage=${sessionMetaForUsage.lastContextPercentage.toFixed(1)}% tokens=${sessionMetaForUsage.lastInputTokens} — clearing stale usage state`);
+      } else if ((isFirstContextPassForSession || usageResetAfterRefusal) && sessionMetaForUsage.lastContextPercentage > 0) {
+        sessionLog2(sessionId, `transform: ${isFirstContextPassForSession ? "first pass" : "refused turn recovery"} reset — percentage=${sessionMetaForUsage.lastContextPercentage.toFixed(1)}% tokens=${sessionMetaForUsage.lastInputTokens} — clearing stale usage state`);
         updateSessionMeta(options.db, sessionId, {
           lastContextPercentage: 0,
           lastInputTokens: 0
@@ -45550,7 +46034,7 @@ function registerPiContextHandler(pi, baseOptions) {
         usagePercentage = sessionMetaForUsage.lastContextPercentage;
         usageInputTokens = sessionMetaForUsage.lastInputTokens;
         usedPersistedUsage = true;
-      } else {
+      } else if (!usageResetAfterRefusal) {
         usagePercentage = typeof piUsage?.percent === "number" ? piUsage.percent : 0;
         usageInputTokens = typeof piUsage?.tokens === "number" ? piUsage.tokens : 0;
       }
@@ -45618,7 +46102,7 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       let fallbackInputTokens;
       const suspectReading = Math.max(usageInputTokens, piUsage?.tokens ?? 0);
-      if (suspectReading > providerInputLimit || piProviderUsageWasRejected(sessionId)) {
+      if (usageResetAfterRefusal || suspectReading > providerInputLimit || piProviderUsageWasRejected(sessionId)) {
         if (suspectReading > providerInputLimit)
           noteRejectedPiUsage(sessionId, suspectReading, providerInputLimit, "transform");
         const replay = !lkgCompactionOff && lkgPassSnapshot ? lkgCoordinator.replay(lkgPassSnapshot, (id) => ctx.sessionManager.getEntry?.(id)?.parentId) : undefined;
@@ -45635,7 +46119,7 @@ function registerPiContextHandler(pi, baseOptions) {
         persistedFromLive: !usedPersistedUsage,
         persistedPercentage: usagePercentage,
         persistedInputTokens: usageInputTokens,
-        liveInputTokens: piUsage?.tokens,
+        liveInputTokens: usageResetAfterRefusal ? undefined : piUsage?.tokens,
         usableContextLimit: usageContextLimit
       }));
       const realUsagePercentageBeforeEmergencyBump = usagePercentage;
@@ -45765,6 +46249,8 @@ function registerPiContextHandler(pi, baseOptions) {
         maintainExecuteFloorMark(options.db, sessionId, promptId, usagePercentage < effectiveExecuteThresholdPercentage);
       }
       const pipelineArgs = {
+        providerOverflowRecovery: emergencyRecoveryArmed && historianStateForPass.emergencyRecoveryOrigin === "provider_overflow",
+        dropBranchEntries: branchEntries ?? undefined,
         recoveryPrefix: recovery.prefix,
         recoveryRebuildReason: recovery.rebuildReason,
         assertCurrentPass,
@@ -46140,100 +46626,102 @@ function registerPiContextHandler(pi, baseOptions) {
         if (result.syntheticLeadingCount < 0)
           result.syntheticLeadingCount = prefix.length;
       }
-      const tChannelAccounting = performance.now();
-      try {
-        const sessionMetaForCh1 = sessionMeta;
-        if (!options.compactionOff && !sessionMetaForCh1.isSubagent) {
-          const { tags, protectedTagNumbers, pendingDropTagNumbers } = result.channelBaselineSnapshot;
-          const stableId = (message) => message && typeof message === "object" ? result.postCommitEntryIdByRef.get(message) : undefined;
-          const hygieneCalibration = sessionDecisionCalibration(options.db, sessionId);
-          const hygieneUnitsVersion = transitionSessionHygieneUnits(options.db, sessionId, result.bustedThisPass, hygieneCalibration);
-          const previousBaseline = getPiChannel1Baseline(sessionId);
-          const baseline = refreshPiTailHygieneBaseline({
-            messages: outputMessages,
-            providerApi: ctx.model?.api,
-            tags,
-            tagCacheKey: result.channelBaselineSnapshot.tagCacheKey,
-            protectedTagNumbers,
-            protectedTools: options.protectedTools,
-            pendingDropTagNumbers,
-            stableId,
-            protectedToolTags: protectedToolTagNumbers(result.channelBaselineSnapshot.activeTags, options.protectedTools),
-            syntheticLeadingCount: result.syntheticLeadingCount,
-            cacheBusting: result.bustedThisPass,
-            previous: previousBaseline,
-            calibration: hygieneUnitsVersion >= HYGIENE_PROVIDER_UNITS_VERSION ? hygieneCalibration : undefined,
-            hygieneUnitsVersion
-          });
-          const effective = effectivePiTailHygiene(baseline);
-          if (baseline.lastPrefixMismatch) {
-            sessionLog2(sessionId, formatTailHygienePrefixMismatch(baseline.lastPrefixMismatch, baseline.baselineGeneration));
-          }
-          const durableGrace = baseline.evaluable && !baseline.generationInvalidated ? captureChannel1PostReduceGraceBaseline(options.db, sessionId, effective.u) : getChannel1NudgeState(options.db, sessionId);
-          baseline.channel1PostReduceGrace = durableGrace.postReduceGracePending || durableGrace.postReduceGraceBaselineU !== undefined ? {
-            pending: durableGrace.postReduceGracePending === true,
-            baselineU: durableGrace.postReduceGraceBaselineU,
-            preReduceLevel: durableGrace.postReduceGracePreLevel ?? durableGrace.level
-          } : undefined;
-          const oldestReclaimableToolTags = getOldestActiveUnprotectedToolTags2(options.db, sessionId, protectedTagNumbers);
-          const channelState = {
-            ...baseline,
-            usableWindow: usageContextLimit ?? 0,
-            realUserTurnCount: baseline.realUserTurnCount,
-            reducedSinceRefresh: false,
-            agentDropsAppliedThisPass: result.agentDropsAppliedThisPass,
-            oldestReclaimableToolTags
-          };
-          setPiChannel1Baseline(sessionId, channelState);
-          const channel2Evaluation = evaluateChannel2(channelState);
-          if (channel2Evaluation.evaluable) {
-            try {
-              rearmChannel2AfterMeasuredCollapse({
-                db: options.db,
-                sessionId,
-                baseline: channelState,
-                rebuilding: result.bustedThisPass,
-                previous: previousBaseline
-              });
-            } catch (error) {
-              sessionLog2(sessionId, `pi channel2 U-collapse reset failed: ${error instanceof Error ? error.message : String(error)}`);
+      const publishFinalRequestAccounting = () => {
+        const tChannelAccounting = performance.now();
+        try {
+          const sessionMetaForCh1 = sessionMeta;
+          if (!options.compactionOff && !sessionMetaForCh1.isSubagent) {
+            const { tags, protectedTagNumbers, pendingDropTagNumbers } = result.channelBaselineSnapshot;
+            const stableId = (message) => message && typeof message === "object" ? result.postCommitEntryIdByRef.get(message) : undefined;
+            const hygieneCalibration = sessionDecisionCalibration(options.db, sessionId);
+            const hygieneUnitsVersion = transitionSessionHygieneUnits(options.db, sessionId, result.bustedThisPass, hygieneCalibration);
+            const previousBaseline = getPiChannel1Baseline(sessionId);
+            const baseline = refreshPiTailHygieneBaseline({
+              messages: outputMessages,
+              providerApi: ctx.model?.api,
+              tags,
+              tagCacheKey: result.channelBaselineSnapshot.tagCacheKey,
+              protectedTagNumbers,
+              protectedTools: options.protectedTools,
+              pendingDropTagNumbers,
+              stableId,
+              protectedToolTags: protectedToolTagNumbers(result.channelBaselineSnapshot.activeTags, options.protectedTools),
+              syntheticLeadingCount: result.syntheticLeadingCount,
+              cacheBusting: result.bustedThisPass,
+              previous: previousBaseline,
+              calibration: hygieneUnitsVersion >= HYGIENE_PROVIDER_UNITS_VERSION ? hygieneCalibration : undefined,
+              hygieneUnitsVersion
+            });
+            const effective = effectivePiTailHygiene(baseline);
+            if (baseline.lastPrefixMismatch) {
+              sessionLog2(sessionId, formatTailHygienePrefixMismatch(baseline.lastPrefixMismatch, baseline.baselineGeneration));
             }
-            if (channel2Evaluation.shouldTrigger) {
-              casChannel2NudgeState(options.db, sessionId, "", "pending");
-            } else {
-              casChannel2NudgeState(options.db, sessionId, "pending", "");
+            const durableGrace = baseline.evaluable && !baseline.generationInvalidated ? captureChannel1PostReduceGraceBaseline(options.db, sessionId, effective.u) : getChannel1NudgeState(options.db, sessionId);
+            baseline.channel1PostReduceGrace = durableGrace.postReduceGracePending || durableGrace.postReduceGraceBaselineU !== undefined ? {
+              pending: durableGrace.postReduceGracePending === true,
+              baselineU: durableGrace.postReduceGraceBaselineU,
+              preReduceLevel: durableGrace.postReduceGracePreLevel ?? durableGrace.level
+            } : undefined;
+            const oldestReclaimableToolTags = getOldestActiveUnprotectedToolTags2(options.db, sessionId, protectedTagNumbers);
+            const channelState = {
+              ...baseline,
+              usableWindow: usageContextLimit ?? 0,
+              realUserTurnCount: baseline.realUserTurnCount,
+              reducedSinceRefresh: false,
+              agentDropsAppliedThisPass: result.agentDropsAppliedThisPass,
+              oldestReclaimableToolTags
+            };
+            setPiChannel1Baseline(sessionId, channelState);
+            const channel2Evaluation = evaluateChannel2(channelState);
+            if (channel2Evaluation.evaluable) {
+              try {
+                rearmChannel2AfterMeasuredCollapse({
+                  db: options.db,
+                  sessionId,
+                  baseline: channelState,
+                  rebuilding: result.bustedThisPass,
+                  previous: previousBaseline
+                });
+              } catch (error) {
+                sessionLog2(sessionId, `pi channel2 U-collapse reset failed: ${error instanceof Error ? error.message : String(error)}`);
+              }
+              if (channel2Evaluation.shouldTrigger) {
+                casChannel2NudgeState(options.db, sessionId, "", "pending");
+              } else {
+                casChannel2NudgeState(options.db, sessionId, "pending", "");
+              }
             }
+            assertTailHygieneLastWriter = () => assertPiTailHygieneContentUnchanged({
+              messages: outputMessages,
+              tags,
+              protectedTagNumbers,
+              pendingDropTagNumbers,
+              stableId,
+              syntheticLeadingCount: result.syntheticLeadingCount,
+              expectedSignature: baseline.contentSignature
+            });
+          } else {
+            clearPiChannel1State(sessionId);
           }
-          assertTailHygieneLastWriter = () => assertPiTailHygieneContentUnchanged({
-            messages: outputMessages,
-            tags,
-            protectedTagNumbers,
-            pendingDropTagNumbers,
-            stableId,
-            syntheticLeadingCount: result.syntheticLeadingCount,
-            expectedSignature: baseline.contentSignature
-          });
-        } else {
-          clearPiChannel1State(sessionId);
+        } catch (err) {
+          const stale = getPiChannel1Baseline(sessionId);
+          if (stale) {
+            stale.evaluable = false;
+            stale.generationInvalidated = true;
+          }
+          sessionLog2(sessionId, `channel1 baseline / channel2 trigger failed: ${err instanceof Error ? err.message : String(err)}`);
         }
-      } catch (err) {
-        const stale = getPiChannel1Baseline(sessionId);
-        if (stale) {
-          stale.evaluable = false;
-          stale.generationInvalidated = true;
+        logTransformTiming(sessionId, "channelNudgeAccounting", tChannelAccounting);
+        const tWorkMetrics = performance.now();
+        budget.stage = "bookkeeping";
+        try {
+          const metrics = computePiWorkMetrics(outputMessages);
+          setSessionWorkMetrics(options.db, sessionId, metrics.newWorkTokens, metrics.totalInputTokens);
+        } catch (err) {
+          sessionLog2(sessionId, `work-metrics update failed: ${err instanceof Error ? err.message : String(err)}`);
         }
-        sessionLog2(sessionId, `channel1 baseline / channel2 trigger failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      logTransformTiming(sessionId, "channelNudgeAccounting", tChannelAccounting);
-      const tWorkMetrics = performance.now();
-      budget.stage = "bookkeeping";
-      try {
-        const metrics = computePiWorkMetrics(outputMessages);
-        setSessionWorkMetrics(options.db, sessionId, metrics.newWorkTokens, metrics.totalInputTokens);
-      } catch (err) {
-        sessionLog2(sessionId, `work-metrics update failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      logTransformTiming(sessionId, "workMetrics", tWorkMetrics);
+        logTransformTiming(sessionId, "workMetrics", tWorkMetrics);
+      };
       const tStableIdSchemePersist = performance.now();
       if (stableIdSchemeCutover && !options.compactionOff) {
         persistStableIdSchemeForRun(options.db, sessionId, {
@@ -46317,6 +46805,18 @@ function registerPiContextHandler(pi, baseOptions) {
           throw contextRefusalError("The request remains over the model window after stripping signed thinking and reclaiming context");
         if (getHarness2() === "pi") {
           const fitCase = classifyPiOutgoingFit(estimate, outgoingFitLimit);
+          const recoverUnknownUsage = usageInputTokens <= 0 && result.prefixBustPermitted && emergencyRecoveryArmed && historianStateForPass.emergencyRecoveryOrigin === "provider_overflow";
+          let unknownUsageRecovered = false;
+          const recoveryUsage = resolvePiOverflowRecoveryUsage({
+            usage: pipelineArgs.contextUsage,
+            pricedPass: result.prefixBustPermitted,
+            providerOverflow: recoverUnknownUsage,
+            messages: outputMessages,
+            envelope,
+            usableHardLimit: outgoingFitLimit
+          });
+          if (recoverUnknownUsage && (!(recoveryUsage.inputTokens > 0) || !((emergencyCeilingTokens ?? 0) > 0) || !Number.isFinite(outgoingFitLimit) || !((outgoingFitLimit ?? 0) > 0)))
+            throw contextRefusalError("Provider overflow recovery has unknown-usage: a complete outgoing request estimate and context limit are required before retrying");
           const currentUpperCursor = () => piUpperReclaimCursor({
             sessionId,
             modelKey: resolvePiContextModelKey(ctx) ?? null,
@@ -46326,24 +46826,25 @@ function registerPiContextHandler(pi, baseOptions) {
             snapshot: lkgPassSnapshot,
             input: inputForFitReclaim ?? event.messages
           });
-          const upperCursor = fitCase === "upper-estimate-pressure" ? currentUpperCursor() : undefined;
+          const upperCursor = fitCase === "upper-estimate-pressure" && !recoverUnknownUsage ? currentUpperCursor() : undefined;
           if (fitCase === "over-window-proof") {
             requestPiFitReclaimInput(sessionId);
           }
           if (fitCase === "fits-or-unknown")
             clearPiFitReclaimInput(sessionId);
           const upperPassEligible = schedulerDecision === "execute" || result.bustedThisPass || result.prefixRebuildAlreadyPriced || isCacheBusting || forceMaterialization || isEmergency;
-          const reclaimHeld = fitCase === "upper-estimate-pressure" && (result.strictThinkingKept || !upperPassEligible || !shouldReclaimPiUpperEstimate(options.db, upperCursor));
+          const reclaimHeld = !recoverUnknownUsage && fitCase === "upper-estimate-pressure" && (result.strictThinkingKept || !upperPassEligible || !shouldReclaimPiUpperEstimate(options.db, upperCursor));
           if (reclaimHeld)
             sessionLog2(sessionId, "outgoing fit: upper-estimate-pressure; reclaim held by signed prefix, deferred pass or used session latch");
           if (fitCase === "upper-estimate-pressure" && !reclaimHeld && !inputForFitReclaim)
             requestPiFitReclaimInput(sessionId);
-          if (fitCase !== "fits-or-unknown" && !reclaimHeld && !fitReclaimedThisPass && !inputForFitReclaim)
+          if ((fitCase !== "fits-or-unknown" || recoverUnknownUsage) && !reclaimHeld && !fitReclaimedThisPass && !inputForFitReclaim)
             inputForFitReclaim = restorePiLkgInputForFit(lkgPassSnapshot, branchEntries);
-          if (fitCase !== "fits-or-unknown" && !reclaimHeld && !fitReclaimedThisPass && inputForFitReclaim) {
+          if ((fitCase !== "fits-or-unknown" || recoverUnknownUsage) && !reclaimHeld && !fitReclaimedThisPass && inputForFitReclaim) {
             const reservation = upperCursor ? reservePiUpperEstimateReclaim(options.db, upperCursor) : undefined;
             if (!upperCursor || reservation) {
               let reclaimCompleted = false;
+              const recoveryRetryStart = performance.now();
               try {
                 sessionLog2(sessionId, `outgoing fit: ${fitCase}; attempting emergency reclaim`);
                 if (fitCase === "over-window-proof" && !ctx.hasUI && historian) {
@@ -46386,7 +46887,7 @@ function registerPiContextHandler(pi, baseOptions) {
                   schedulerDecision: "execute",
                   schedulerDeferReason: null,
                   forceMaterialization: true,
-                  upperEstimateOnly: fitCase === "upper-estimate-pressure",
+                  upperEstimateOnly: !recoverUnknownUsage && fitCase === "upper-estimate-pressure",
                   forceSignedRebuildForFit: fitCase === "over-window-proof",
                   isCacheBusting: historyRefreshSessions.has(sessionId) || deferredHistoryRefreshSessions.has(sessionId),
                   injectionPassSnapshot: options.injection ? createPiM0M1PassSnapshot({
@@ -46395,13 +46896,13 @@ function registerPiContextHandler(pi, baseOptions) {
                     compactionOff: false,
                     sessionMeta: freshMeta
                   }) : undefined,
-                  contextUsage: {
-                    percentage: usagePercentage,
-                    inputTokens: usageInputTokens
-                  }
+                  contextUsage: recoverUnknownUsage ? recoveryUsage : pipelineArgs.contextUsage
                 }));
                 outputMessages = result.messages;
                 observePipelineResultForTests(sessionId, result);
+                unknownUsageRecovered = recoverUnknownUsage;
+                if (recoverUnknownUsage)
+                  sessionLog2(sessionId, `overflow unknown-usage recovery: inputTokens=${recoveryUsage.inputTokens} retryMs=${(performance.now() - recoveryRetryStart).toFixed(1)}`);
                 injectTodo();
                 if (upperCursor)
                   recordPiUpperEstimateReclaim(options.db, currentUpperCursor() ?? upperCursor, reservation);
@@ -46423,6 +46924,8 @@ function registerPiContextHandler(pi, baseOptions) {
               }
             }
           }
+          if (recoverUnknownUsage && !unknownUsageRecovered)
+            throw contextRefusalError("Provider overflow recovery has unknown-usage: a pristine request is required for emergency reclaim");
         }
         const refusal = outgoingContextRefusal(estimate, rawFallbackLimit, protectedToolTokenCount(getActiveTagsBySession2(options.db, sessionId), options.protectedTools, envelope ? calibrationForModelKey(envelope.modelKey) : undefined));
         if (refusal)
@@ -46430,6 +46933,7 @@ function registerPiContextHandler(pi, baseOptions) {
         if (getHarness2() === "pi" && classifyPiOutgoingFit(estimate, outgoingFitLimit) === "over-window-proof")
           throw new PiDegradedPassError("outgoing-over-window");
       }
+      publishFinalRequestAccounting();
       let serializedOutput;
       let numbersCommitted = false;
       budget.stage = "LKG/served publication";
@@ -46653,6 +47157,8 @@ function registerPiContextHandler(pi, baseOptions) {
       const sessionId = resolveSessionId2(ctx);
       if (!sessionId)
         return;
+      if (!budget.sideTurn)
+        recordUsageRefusal(baseOptions.db, sessionId);
       withoutSqliteTransformPass2(() => setImmediate(() => {
         if (!isCurrent())
           return;
@@ -46739,6 +47245,7 @@ function ensureRunnablePiBoundaryForTests(snapshot) {
     protectedTailStart: endOrdinal,
     eligibleEndOrdinal: endOrdinal,
     trueRawEligibleTokens: Math.max(1, snapshot.trueRawEligibleTokens),
+    summaryRemovedEligibleTokens: Math.max(1, snapshot.summaryRemovedEligibleTokens),
     rawRangeFingerprint: ""
   };
 }
@@ -47344,6 +47851,10 @@ async function runPipeline(args) {
   args.assertCurrentPass?.();
   if (args.compactionOff)
     return runCompactionOffPipeline(args);
+  const dropBranchEntries = args.dropBranchEntries;
+  const dropBranchIds = dropBranchEntries ? piDropBranchIds(dropBranchEntries) : null;
+  trackPiDropLeaf(args.db, args.sessionId, dropBranchIds ? [...dropBranchIds].at(-1) ?? null : null);
+  cancelPiAbandonedPendingDrops(args.db, args.sessionId, dropBranchIds);
   const thinkingRecovery = prepareLatestThinkingRecovery({
     db: args.db,
     sessionId: args.sessionId,
@@ -47880,65 +48391,67 @@ async function runPipeline(args) {
       message.content = content;
     });
   }
-  const tLegacyToolConversion = performance.now();
-  if (foldBustsServedPrefixThisPass) {
-    const savedRemovalInputs = nativeRemovalInputs;
-    try {
-      nativeRemovalInputs = savedRemovalInputs && new Map(savedRemovalInputs);
-      let converted = 0;
-      args.db.transaction(() => removalBatch((flush) => {
-        converted = convertLegacyToolSkeletons(args.db, args.sessionId, targets, {
-          prepareRemovals: (rows) => preparePiToolRemovalChecks({
-            db: args.db,
-            rows,
-            targets,
-            messages: args.messages,
-            prepare: transcript.prepareToolRemovalMeasurements
-          }),
-          keepFullDrop: (callId) => nativeRemovalInputs === undefined || callId !== null && authorizePiToolRemoval({
-            db: args.db,
-            sessionId: args.sessionId,
-            callId,
-            saved: nativeRemovalInputs,
-            canApply: false
-          }) === true
-        }).size;
-        flush();
-      })).immediate();
-      if (converted > 0) {
-        sessionLog2(args.sessionId, `pi HARD fold converted ${converted} legacy dropped-tool skeleton(s) to real-or-absent`);
+  const applyExistingToolConversions = () => {
+    const tLegacyToolConversion = performance.now();
+    if (foldBustsServedPrefixThisPass) {
+      const savedRemovalInputs = nativeRemovalInputs;
+      try {
+        nativeRemovalInputs = savedRemovalInputs && new Map(savedRemovalInputs);
+        let converted = 0;
+        args.db.transaction(() => removalBatch((flush) => {
+          converted = convertLegacyToolSkeletons(args.db, args.sessionId, targets, {
+            prepareRemovals: (rows) => preparePiToolRemovalChecks({
+              db: args.db,
+              rows,
+              targets,
+              messages: args.messages,
+              prepare: transcript.prepareToolRemovalMeasurements
+            }),
+            keepFullDrop: (callId) => nativeRemovalInputs === undefined || callId !== null && authorizePiToolRemoval({
+              db: args.db,
+              sessionId: args.sessionId,
+              callId,
+              saved: nativeRemovalInputs,
+              canApply: false
+            }) === true
+          }).size;
+          flush();
+        })).immediate();
+        if (converted > 0) {
+          sessionLog2(args.sessionId, `pi HARD fold converted ${converted} legacy dropped-tool skeleton(s) to real-or-absent`);
+        }
+      } catch (error) {
+        nativeRemovalInputs = savedRemovalInputs;
+        sessionLog2(args.sessionId, `pi legacy dropped-tool skeleton conversion failed (kept legacy bytes): ${error instanceof Error ? error.message : String(error)}`);
       }
-    } catch (error) {
-      nativeRemovalInputs = savedRemovalInputs;
-      sessionLog2(args.sessionId, `pi legacy dropped-tool skeleton conversion failed (kept legacy bytes): ${error instanceof Error ? error.message : String(error)}`);
     }
-  }
-  logTransformTiming(args.sessionId, "convertLegacyToolSkeletons", tLegacyToolConversion);
-  if (args.sessionMeta.isSubagent && isCacheBustingPass && !protectedSignedPrefix && !args.compactionOff) {
-    const savedRemovalInputs = nativeRemovalInputs;
-    try {
-      nativeRemovalInputs = savedRemovalInputs && new Map(savedRemovalInputs);
-      const converted = args.db.transaction(() => removalBatch((flush) => {
-        const conversions = prepareAgedToolSkeletonConversions(args.db, args.sessionId, newTargets, {
-          prepareRemovals: (rows) => preparePiToolRemovalChecks({
-            db: args.db,
-            rows,
-            targets: newTargets,
-            messages: args.messages,
-            prepare: transcript.prepareToolRemovalMeasurements
-          })
-        });
-        conversions.persist(args.db);
-        flush();
-        return conversions.converted.size;
-      })).immediate();
-      if (converted > 0)
-        recordFirstApplicationWireEdit(true);
-    } catch (error) {
-      nativeRemovalInputs = savedRemovalInputs;
-      throw error;
+    logTransformTiming(args.sessionId, "convertLegacyToolSkeletons", tLegacyToolConversion);
+    if (args.sessionMeta.isSubagent && isCacheBustingPass && !protectedSignedPrefix && !args.compactionOff) {
+      const savedRemovalInputs = nativeRemovalInputs;
+      try {
+        nativeRemovalInputs = savedRemovalInputs && new Map(savedRemovalInputs);
+        const converted = args.db.transaction(() => removalBatch((flush) => {
+          const conversions = prepareAgedToolSkeletonConversions(args.db, args.sessionId, newTargets, {
+            prepareRemovals: (rows) => preparePiToolRemovalChecks({
+              db: args.db,
+              rows,
+              targets: newTargets,
+              messages: args.messages,
+              prepare: transcript.prepareToolRemovalMeasurements
+            })
+          });
+          conversions.persist(args.db);
+          flush();
+          return conversions.converted.size;
+        })).immediate();
+        if (converted > 0)
+          recordFirstApplicationWireEdit(true);
+      } catch (error) {
+        nativeRemovalInputs = savedRemovalInputs;
+        throw error;
+      }
     }
-  }
+  };
   try {
     if (!args.sessionMeta.isSubagent) {
       const hasRecentCommit = detectRecentCommit(args.messages);
@@ -47955,16 +48468,23 @@ async function runPipeline(args) {
   const deferredMaterializationWasPending = deferredMaterializationSessions.has(args.sessionId);
   const deferredHistoryRefreshWasPending = deferredHistoryWasPendingAtPassStart;
   const shouldReadPendingOps = !args.compactionOff && (publishedWorkDrainAllowed || args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal || foldExecutedThisPass || firstRenderBust);
-  const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
-  const tReclaimDistance = performance.now();
-  const reclaimDistance = isCacheBustingPass ? toolReclaimDistanceEntries(mutationView, targets) : [];
-  logTransformTiming(args.sessionId, "toolReclaimDistanceEntries", tReclaimDistance);
-  const protectedToolTags = protectedToolTagNumbers(getActiveTagsBySession2(args.db, args.sessionId), args.protectedTools);
-  for (const number of identityAdoption.protectedTagNumbers)
-    protectedToolTags.add(number);
-  const protectionWindowForPass = getProtectionWindowForSession(args.db, args.sessionId, protectionFloorResolution.floor);
-  const protectedTagNumbersForPass = usesTokenProtection ? protectionWindowForPass.protectedTagNumbers : newestActiveTagNumbersByCount(getActiveTagsBySession2(args.db, args.sessionId), args.protectedTags);
-  const pendingOperationTags = pendingOps.length > 0 ? getTagsForPendingOperations2(args.db, args.sessionId, pendingOps.map((operation) => operation.tagId), usesTokenProtection ? 0 : args.protectedTags, RECENT_TOOL_SKELETON_WINDOW) : [];
+  const readPendingDropState = () => {
+    const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
+    const protectedToolTags = protectedToolTagNumbers(getActiveTagsBySession2(args.db, args.sessionId), args.protectedTools);
+    for (const number of identityAdoption.protectedTagNumbers)
+      protectedToolTags.add(number);
+    const protectionWindowForPass = getProtectionWindowForSession(args.db, args.sessionId, protectionFloorResolution.floor);
+    const protectedTagNumbersForPass = usesTokenProtection ? protectionWindowForPass.protectedTagNumbers : newestActiveTagNumbersByCount(getActiveTagsBySession2(args.db, args.sessionId), args.protectedTags);
+    const pendingOperationTags = pendingOps.length > 0 ? getTagsForPendingOperations2(args.db, args.sessionId, pendingOps.map((operation) => operation.tagId), usesTokenProtection ? 0 : args.protectedTags, RECENT_TOOL_SKELETON_WINDOW) : [];
+    return {
+      pendingOps,
+      protectedToolTags,
+      protectionWindowForPass,
+      protectedTagNumbersForPass,
+      pendingOperationTags
+    };
+  };
+  const executeReclaimSnapshot = readPendingDropState();
   if (!args.sessionMeta.isSubagent && args.schedulerDecision === "execute") {
     args.evaluateHistorianBeforeReclaim?.({
       activeTags: getActiveTagsBySession2(args.db, args.sessionId),
@@ -47981,12 +48501,12 @@ async function runPipeline(args) {
     reclaimableTokens: estimateExecuteReclaimTokens({
       db: args.db,
       sessionId: args.sessionId,
-      pendingOps,
-      tags: pendingOperationTags,
+      pendingOps: executeReclaimSnapshot.pendingOps,
+      tags: executeReclaimSnapshot.pendingOperationTags,
       targets: newTargets,
       protectedTagIds: new Set([
-        ...protectedTagNumbersForPass,
-        ...protectedToolTags
+        ...executeReclaimSnapshot.protectedTagNumbersForPass,
+        ...executeReclaimSnapshot.protectedToolTags
       ]),
       probePreparation: (targets) => {
         const saved = nativeRemovalInputs;
@@ -48022,6 +48542,23 @@ async function runPipeline(args) {
     stripUnheldSignedTurnOnBust();
     applyTemporalOnRide();
   }
+  if (reconcilePiDropBranches(args.db, args.sessionId, dropBranchIds, isCacheBustingPass && !protectedSignedPrefix)) {
+    args.tagger.cleanup(args.sessionId);
+    args.tagger.initFromDb(args.sessionId, args.db);
+    nativeRemovalInputs = getNativeReplayState(args.db, args.sessionId).toolInputs;
+    recordFirstApplicationWireEdit(true);
+  }
+  applyExistingToolConversions();
+  const {
+    pendingOps,
+    protectedToolTags,
+    protectionWindowForPass,
+    protectedTagNumbersForPass,
+    pendingOperationTags
+  } = readPendingDropState();
+  const tReclaimDistance = performance.now();
+  const reclaimDistance = isCacheBustingPass ? toolReclaimDistanceEntries(mutationView, targets) : [];
+  logTransformTiming(args.sessionId, "toolReclaimDistanceEntries", tReclaimDistance);
   const deferredMaterialize = canConsumeDeferredLate && deferredMaterializationWasPending;
   const deferredHistoryRefresh = canConsumeDeferredLate && deferredHistoryRefreshWasPending;
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
@@ -48162,6 +48699,8 @@ async function runPipeline(args) {
   if (shouldRunHeuristics && args.heuristics) {
     try {
       const tHeuristic = performance.now();
+      const providerOverflow = args.providerOverflowRecovery === true;
+      const recoveryCalibration = sessionDecisionCalibration(args.db, args.sessionId);
       const independentMutationBeforeHeuristics = pendingOpsDidMutate || systemPrefixChangedThisPass || foldBustsServedPrefixThisPass || identityRebuild || firstRenderBust || heldIdleExpiryRebuild;
       if (args.forceMaterialization === true && independentMutationBeforeHeuristics && getEmergencyInputSample(args.db, args.sessionId) > 0) {
         clearEmergencyDropSample(args.db, args.sessionId);
@@ -48179,7 +48718,9 @@ async function runPipeline(args) {
           currentTotalInputTokens: args.contextUsage.inputTokens,
           ceilingTokens: args.emergencyCeilingTokens,
           usagePercentage: args.contextUsage.percentage,
-          passAlreadyPriced: independentMutationBeforeHeuristics
+          passAlreadyPriced: independentMutationBeforeHeuristics,
+          serializedImageTokens: providerOverflow ? piRecoveryToolImageTokens(workingMessages) : undefined,
+          fitCalibration: providerOverflow ? piRecoveryFitCalibration(recoveryCalibration) : undefined
         } : undefined,
         caveman: args.isSubagent ? undefined : args.heuristics?.caveman
       }, activeTags, stableIdResolver));