@cortexkit/pi-magic-context 0.49.12 → 0.49.13

package/dist/index.js

@@ -55,12 +55,6 @@ import {
   advanceToolReclaimWatermark,
   retryPendingSessionCleanups,
   retryPendingRustSessionCleanupsForProject,
-  embedPauseBySession,
-  embedRunStateBySession,
-  autoEmbedAttemptedBySession,
-  autoEmbedIdentityBySession,
-  invalidateAutoEmbedSession,
-  getEmbedDrainUiStatus,
   COMPARTMENT_LEASE_RENEWAL_MS,
   acquireCompartmentLease,
   renewCompartmentLease,
@@ -253,7 +247,7 @@ import {
   registerTodoStateLifecycle,
   syncCtxMemoryToolEnabled,
   registerMagicContextTools
-} from "./index-zapgkmp7.js";
+} from "./index-aypx5h57.js";
 import {
   canonicalModelIdentity,
   piModelRefToCanonical,
@@ -293,7 +287,7 @@ import {
   openCurrentDatabase,
   openDatabaseAsync,
   closeDatabase
-} from "./index-z5ftst3e.js";
+} from "./index-t27xk4r7.js";
 import {
   setHomeProjectPermission,
   ProjectIdentityError,
@@ -626,7 +620,7 @@ import {
   indexSingleMessage2,
   indexMessagesAfterOrdinal2,
   sweepOrphanedOpenCodeMessageIndexes2
-} from "./index-6hex51s9.js";
+} from "./index-vv1j5cak.js";
 import {
   formatSynapseLaneDescriptor
 } from "./index-6dz2ed1v.js";
@@ -642,7 +636,7 @@ import {
   replaceCompartmentChunkEmbeddings,
   deleteChunkEmbedBackoffForSession,
   chunkWindowSourceKey
-} from "./index-af9nb5db.js";
+} from "./index-7qc73yk5.js";
 import {
   recordSessionProjectIdentity,
   GIT_SWEEP_LEASE_RENEWAL_MS,
@@ -650,7 +644,17 @@ import {
   renewGitSweepLease,
   markGitSweepSuccessAndRelease,
   parkGitSweepNonIndexable,
-  releaseGitSweepLease,
+  releaseGitSweepLease
+} from "./index-1mrvw9en.js";
+import {
+  embedPauseBySession,
+  embedRunStateBySession,
+  activeEmbeddingSessions,
+  autoEmbedAttemptedBySession,
+  autoEmbedIdentityBySession,
+  autoEmbedRetryAfterBySession,
+  invalidateAutoEmbedSession,
+  getEmbedDrainUiStatus,
   describeShadowBackfillWriteRefusal2,
   contentSha2562,
   drainProjectEmbeddingIdentityMaintenance2,
@@ -667,7 +671,7 @@ import {
   embedSessionCompartmentChunks2,
   getEmbeddingCoverageStatus2,
   getAutoEmbeddingSessionCoverage2
-} from "./index-f6e8jsrh.js";
+} from "./index-nwbhe6qv.js";
 import {
   rememberV1HiddenRun
 } from "./index-6x556c2q.js";
@@ -732,7 +736,7 @@ import {
   normalizeVerificationFiles,
   indexCommitsForProject,
   embedUnembeddedCommits
-} from "./index-gykw2zhn.js";
+} from "./index-wp9q91kn.js";
 import {
   setEmbeddingSessionBusy2,
   isEmbeddingHostBusy2
@@ -763,18 +767,19 @@ import {
 import {
   pushNotification2
 } from "./index-q1yc6bs0.js";
-import"./index-j24916mq.js";
+import"./index-9jvktm7k.js";
 import {
   cosineSimilarity
-} from "./index-xpsht877.js";
+} from "./index-7wagp5jp.js";
 import"./index-46q4e104.js";
 import {
+  DREAMER_PRIMER_INVESTIGATOR_ALLOWED_TOOLS,
   buildHiddenAgentRegistrations,
   logTemperatureDecision,
   subagentStepCap,
   SubagentTelemetry,
   readHostSystemPrompt
-} from "./index-xmdkde4v.js";
+} from "./index-y29y2j2w.js";
 import"./index-f18ec69t.js";
 import {
   __toESM
@@ -3494,7 +3499,7 @@ function startHostStallProfilerSwitch() {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.49.12",
+  version: "0.49.13",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -3523,7 +3528,7 @@ var package_default = {
   ],
   "//": "The build intentionally bundles typebox (no --external typebox) and keeps it a regular dependency. OMP's extension loader rewrites every bare `typebox` import to its own omptype-based shim, whose schemas are callable objects rather than JSON Schema; they fail structuredClone during tool registration, so an external typebox import stops Magic Context loading on OMP. src/typebox-bundling.test.ts guards this.",
   scripts: {
-    build: "bun ../../scripts/check-bun.mjs && tsc -p ../retina-local-fs/tsconfig.build.json && bun ../../scripts/clean-dist-chunks.mjs dist index.js subagent-entry.js historian-calibration-extension.js embedding-worker-process.js raw-ordinal-warmup-worker.js transformers-web.js transformers-node-wasm.js && bun build ../plugin/src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun ../plugin/scripts/build-transformers-node-wasm.ts dist && bun build src/index.ts src/subagent-entry.ts src/historian-calibration-extension.ts ../plugin/src/features/magic-context/memory/embedding-worker.ts ../plugin/src/features/magic-context/memory/embedding-worker-process.ts ../plugin/src/features/magic-context/migration-worker.ts ../plugin/src/hooks/magic-context/auto-search-worker.ts ../plugin/src/hooks/magic-context/raw-ordinal-warmup-worker.ts ../plugin/src/features/magic-context/compaction-marker-candidates-worker.ts --outdir dist --entry-naming '[name].[ext]' --target node --format esm --splitting --external @earendil-works/pi-coding-agent --external @oh-my-pi/pi-coding-agent --external @earendil-works/pi-tui --external onnxruntime-node --external onnxruntime-web --external sharp --external bun:ffi --external node:sqlite",
+    build: "bun ../../scripts/check-bun.mjs && tsc -p ../retina-local-fs/tsconfig.build.json && bun ../../scripts/clean-dist-chunks.mjs dist index.js subagent-entry.js historian-calibration-extension.js embedding-worker-process.js raw-ordinal-warmup-worker.js transformers-web.js transformers-node-wasm.js && bun build ../plugin/src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun ../plugin/scripts/build-transformers-node-wasm.ts dist && bun build src/index.ts src/subagent-entry.ts src/historian-calibration-extension.ts ../plugin/src/features/magic-context/memory/embedding-worker.ts ../plugin/src/features/magic-context/memory/embedding-worker-process.ts ../plugin/src/features/magic-context/migration-worker.ts ../plugin/src/hooks/magic-context/auto-search-worker.ts ../plugin/src/hooks/magic-context/raw-ordinal-warmup-worker.ts ../plugin/src/features/magic-context/compaction-marker-candidates-worker.ts ../plugin/src/features/magic-context/chunk-embedding-write-worker.ts --outdir dist --entry-naming '[name].[ext]' --target node --format esm --splitting --external @earendil-works/pi-coding-agent --external @oh-my-pi/pi-coding-agent --external @earendil-works/pi-tui --external onnxruntime-node --external onnxruntime-web --external sharp --external bun:ffi --external node:sqlite",
     "build:e2e-argv": `bun ../../scripts/clean-dist-chunks.mjs ../../tests/docker/.generated subagent-runner-e2e.mjs && bun build src/subagent-runner.ts --outdir ../../tests/docker/.generated --entry-naming 'subagent-runner-e2e.mjs' --splitting --target node --format esm --external node:sqlite && node --input-type=module -e 'const { __test } = await import("../../tests/docker/.generated/subagent-runner-e2e.mjs"); if (typeof __test.buildArgs !== "function" || typeof __test.resolvePiInvocation !== "function") throw new Error("argv renderer exports missing"); console.log("Node argv renderer: 2 exports loaded")'`,
     typecheck: "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit",
     test: "bun ../../scripts/check-bun.mjs && bun install --frozen-lockfile && BUN_JSC_useOMGJIT=0 bun test --parallel=4 --timeout 30000",
@@ -4425,6 +4430,14 @@ var DREAMER_AGENT = "dreamer";
 var DREAMER_RETROSPECTIVE_AGENT = "dreamer-retrospective";
 var DREAMER_PRIMER_INVESTIGATOR_AGENT = "dreamer-primer-investigator";
 var DREAMER_MEMORY_MAPPER_AGENT = "dreamer-memory-mapper";
+var DREAMER_MEMORY_MAPPER_ALLOWED_TOOLS = [
+  "read",
+  "grep",
+  "glob",
+  "aft_outline",
+  "aft_zoom",
+  "aft_search"
+];
 var DREAMER_CLASSIFIER_AGENT = "dreamer-classifier";
 var DREAMER_DOCS_AGENT = "dreamer-docs";
 var DREAMER_REVIEWER_AGENT = "dreamer-reviewer";
@@ -4654,13 +4667,12 @@ function providerOutputFailureFromInvalidManifest(messages, responseText, now =
 var HIDDEN_HISTORIAN_AGENT = "historian";
 var HIDDEN_DREAMER_AGENT = "dreamer-classifier";
 var HIDDEN_CURATE_AGENT = DREAMER_AGENT;
-var READ_TOOLS = ["read", "grep", "glob"];
 var AGENT_TOOLS = {
   [HIDDEN_HISTORIAN_AGENT]: [],
   [HIDDEN_DREAMER_AGENT]: [],
   [HIDDEN_CURATE_AGENT]: ["ctx_memory"],
-  [DREAMER_MEMORY_MAPPER_AGENT]: READ_TOOLS,
-  [DREAMER_PRIMER_INVESTIGATOR_AGENT]: [...READ_TOOLS, "ctx_search"],
+  [DREAMER_MEMORY_MAPPER_AGENT]: DREAMER_MEMORY_MAPPER_ALLOWED_TOOLS,
+  [DREAMER_PRIMER_INVESTIGATOR_AGENT]: DREAMER_PRIMER_INVESTIGATOR_ALLOWED_TOOLS,
   [DREAMER_RETROSPECTIVE_AGENT]: ["ctx_search"]
 };
 var AGENT_STEPS = {
@@ -4867,6 +4879,21 @@ function externalAbortMessage(signal) {
   const reason = signal.reason;
   return `prompt aborted by external signal${reason instanceof Error && /^lease_(?:lost|expired):/.test(reason.message) ? `: ${reason.message}` : ""}`;
 }
+function raceWithSignal(work, signal) {
+  work = Promise.resolve(work);
+  if (!signal)
+    return work;
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(new Error(externalAbortMessage(signal)));
+    if (signal.aborted) {
+      work.catch(() => {});
+      abort();
+      return;
+    }
+    signal.addEventListener("abort", abort, { once: true });
+    work.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
 async function promptWithTimeout(client, args, timeoutMs, signal, transport) {
   if (signal?.aborted) {
     throw new Error(externalAbortMessage(signal));
@@ -4878,11 +4905,11 @@ async function promptWithTimeout(client, args, timeoutMs, signal, transport) {
   try {
     const request = { ...args, signal: controller.signal };
     if (transport)
-      await transport(request);
+      await raceWithSignal(transport(request), controller.signal);
     else {
       if (!client)
         throw new Error("Hidden completion transport is unavailable");
-      await client.session.prompt(request);
+      await raceWithSignal(client.session.prompt(request), controller.signal);
     }
   } catch (error) {
     if (signal?.aborted) {
@@ -5084,7 +5111,7 @@ async function attemptAndValidate(client, args, timeoutMs, signal, callContext,
   }
   let output;
   try {
-    output = await options.fetchOutput(args, attempt);
+    output = await raceWithSignal(options.fetchOutput(args, attempt), options.signal);
   } catch (error) {
     throw {
       error,
@@ -5382,10 +5409,20 @@ function createPromptAsyncTransport(client, childSessionId, options = {}) {
     if (!readChildTokenBudget || !session?.prompt)
       return;
     return Object.assign(async (request) => {
-      await session.prompt?.(request);
-      const state = readChildTokenBudget(childSessionId);
-      if (state)
-        options.onBudgetUpdate?.({ ...state, sessionId: childSessionId });
+      const previous = readChildTokenBudget(childSessionId);
+      const remaining = options.tokenBudget === undefined ? undefined : options.tokenBudget - (previous?.spent ?? 0);
+      if (remaining !== undefined && remaining <= 0 || previous?.finalizeFired)
+        throw new DreamTokenBudgetExceeded(childSessionId, previous?.spent ?? 0);
+      try {
+        await session.prompt?.({
+          ...request,
+          ...remaining === undefined ? {} : { tokenBudget: remaining }
+        });
+      } finally {
+        const state = readChildTokenBudget(childSessionId);
+        if (state)
+          options.onBudgetUpdate?.({ ...state, sessionId: childSessionId });
+      }
     }, { childSessionId });
   }
   const budgetGuard = options.tokenBudget ? createDreamTokenBudget(options.tokenBudget) : undefined;
@@ -10117,9 +10154,12 @@ async function runCompressCues(args) {
     let timeoutStreakElapsedMs = [];
     for (let i = 0;i < chunks.length; i += 1) {
       const remainingMs = Math.max(0, args.deadline - Date.now());
-      if (remainingMs <= 0)
+      if (remainingMs <= 0) {
+        result.stopReason = "deadline";
         break;
+      }
       if (remainingMs < CHUNK_TIMEOUT_FLOOR_MS) {
+        result.stopReason = "deadline";
         log2(`[dreamer] compress-cues: stopping before chunk ${i + 1}/${chunks.length} — remaining budget ${remainingMs}ms is below the ${CHUNK_TIMEOUT_FLOOR_MS}ms chunk floor; banking ${result.compressed} compressed cue(s)`);
         break;
       }
@@ -10128,6 +10168,10 @@ async function runCompressCues(args) {
       if (!chunk)
         break;
       const outcome = await compressOneChunk(args, chunk, sliceMs, abortController.signal);
+      if (outcome.failure) {
+        result.failure = outcome.failure.error;
+        result.failureStage = outcome.failure.stage;
+      }
       result.compressed += outcome.compressed;
       result.skipped += outcome.skipped;
       result.remaining -= outcome.compressed;
@@ -10137,6 +10181,7 @@ async function runCompressCues(args) {
         consecutiveTimeouts += 1;
         timeoutStreakElapsedMs.push(outcome.failure.elapsedMs);
         if (consecutiveTimeouts >= CONSECUTIVE_TIMEOUT_LIMIT) {
+          result.stopReason = "timeout-circuit-breaker";
           log2(`[dreamer] compress-cues: circuit breaker tripped — ${consecutiveTimeouts} consecutive chunk timeouts (model too slow for its time slice); per-chunk elapsed [${timeoutStreakElapsedMs.join("ms, ")}ms] vs ${sliceMs}ms slice; stopping run incomplete with ${chunks.length - i - 1} chunk(s) unattempted`);
           break;
         }
@@ -10153,7 +10198,7 @@ async function runCompressCues(args) {
   }
 }
 function isTimeoutClassError(error) {
-  return error instanceof Error && /^prompt timed out after \d+ms$/.test(error.message);
+  return isPromptTimeoutError(error) || getPromptFailureDetail(error)?.failureClass === "provider_timeout";
 }
 async function compressOneChunk(args, chunk, sliceMs, signal) {
   let agentSessionId = null;
@@ -10161,6 +10206,7 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
   const executor = resolveHiddenCompletionExecutor(args.hiddenCompletionExecutor, args.client, args.db, args.sessionDirectory, "compress-cues");
   let promptSettled = false;
   const startedAt = Date.now();
+  let stage = "child-start";
   try {
     const prompt = buildCompressCuesPrompt({
       projectPath: args.projectIdentity,
@@ -10181,6 +10227,7 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
     agentSessionId = handle.id || null;
     if (!agentSessionId)
       throw new Error("Could not create compress-cues session.");
+    stage = "prompt";
     const opened = handle;
     const run = await promptSyncWithValidatedOutputRetry(args.client, {
       path: { id: agentSessionId },
@@ -10232,16 +10279,19 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
         modelId: run.output.modelId
       });
     }
+    stage = "apply";
     return args.moduleRoute ? await applyCuesThroughModule(args, chunk, run.validated, signal) : applyCues(args, chunk, run.validated);
   } catch (error) {
     const desc = describeError(error);
     log2(`[dreamer] compress-cues chunk failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
-    if (signal.aborted || error instanceof HiddenCompletionRefusal || error instanceof DreamerProviderOutputFailureError)
+    if (signal.aborted || error instanceof DreamerModuleFailureError || error instanceof HiddenCompletionRefusal || error instanceof DreamerProviderOutputFailureError)
       throw error;
     return {
       compressed: 0,
       skipped: 0,
       failure: {
+        error,
+        stage,
         class: isTimeoutClassError(error) ? "timeout" : "other",
         brief: desc.brief,
         elapsedMs: Date.now() - startedAt
@@ -10395,7 +10445,7 @@ async function applyCuesThroughModule(args, chunk, manifestText, signal) {
 // ../plugin/src/features/magic-context/dreamer/hidden-single-shot.ts
 async function runHiddenSingleShotPrompt(args) {
   const system = withContentLanguageDirective(args.system, args.language);
-  const handle = await args.executor.open({
+  const opening = args.executor.open({
     parentSessionId: args.parentSessionId,
     agent: args.agent,
     kind: "dreamer-task",
@@ -10407,6 +10457,17 @@ async function runHiddenSingleShotPrompt(args) {
     directory: args.sessionDirectory,
     ...args.metadata ? { metadata: args.metadata } : {}
   });
+  opening.then((handle) => {
+    if (args.signal?.aborted)
+      return args.executor.close(handle, {
+        promptSettled: false,
+        privacySensitive: args.privacySensitive ?? true,
+        context: `[dreamer] ${args.callContext}`,
+        log: log2
+      });
+  }).catch(() => {});
+  const handle = await raceWithSignal(opening, args.signal);
+  args.onOpened?.(handle.id);
   let promptSettled = false;
   try {
     if (!handle.id)
@@ -10461,12 +10522,16 @@ async function runHiddenSingleShotPrompt(args) {
     }
     throw error;
   } finally {
-    await args.executor.close(handle, {
+    const close = args.executor.close(handle, {
       promptSettled,
       privacySensitive: args.privacySensitive ?? true,
       context: `[dreamer] ${args.callContext}`,
       log: log2
     });
+    if (args.signal?.aborted)
+      close.catch(() => {});
+    else
+      await raceWithSignal(close, args.signal);
   }
 }
 
@@ -12628,7 +12693,7 @@ function getAsyncModule() {
       await beforeModuleLoad();
     const [{ default: singlefileAsyncifyVariant }, { newQuickJSAsyncWASMModuleFromVariant }] = await importPluginModule(() => Promise.all([
       import("./index-e7vx3byk.js").then((m)=>__toESM(m.default,1)),
-      import("./index-69vas84q.js")
+      import("./index-e6xnpach.js")
     ]));
     const module = await newQuickJSAsyncWASMModuleFromVariant(singlefileAsyncifyVariant);
     return module;
@@ -14294,14 +14359,28 @@ function isDeferred(memory, retries) {
   return !!retry && retry.content === contentKey(memory) && retry.deferUntil > Date.now();
 }
 function assistantText(messages) {
-  return messages.filter((message) => isRecord(message) && (message.role === "assistant" || isRecord(message.info) && message.info.role === "assistant")).map((message) => extractLatestAssistantText([message]) ?? (isRecord(message) && Array.isArray(message.content) ? message.content.filter(isRecord).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
+  const joined = messages.filter((message) => isRecord(message) && (message.role === "assistant" || isRecord(message.info) && message.info.role === "assistant")).map((message) => extractLatestAssistantText([message]) ?? (isRecord(message) && Array.isArray(message.content) ? message.content.filter(isRecord).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
 `) : "")).join(`
 `);
+  return joined.trim() ? joined : null;
 }
 function currentManifest(text) {
   const start = text.lastIndexOf("<mappings>");
   return start < 0 ? text : text.slice(start);
 }
+function parseMapMemoriesCompletion(text, completion, expectedIds) {
+  return validateMapMemoriesManifest(currentManifest(assistantText(completion.messages ?? []) || text), expectedIds);
+}
+function validateClientMapMemories(messages, expectedIds) {
+  if (hasLengthCappedOutput(messages)) {
+    throw new Error("map-memories returned length-capped output");
+  }
+  const raw = assistantText(messages);
+  if (raw == null) {
+    throw new Error("map-memories returned no output");
+  }
+  return validateMapMemoriesManifest(currentManifest(raw), expectedIds);
+}
 function logBatchUsage(messages, committed, startedAt) {
   const steps = messages.filter((message) => isRecord(message) && (message.role === "assistant" || isRecord(message.info) && message.info.role === "assistant")).length;
   log2(`[dreamer] map-memories batch: steps=${steps} committed=${committed} steps_per_memory=${committed ? (steps / committed).toFixed(2) : "n/a"} elapsed_ms=${Date.now() - startedAt}`);
@@ -14366,8 +14445,11 @@ async function mapMemories(args) {
   const inputs = allInputs.filter((memory) => !isDeferred(memory, retries));
   result.remaining = allInputs.length;
   result.complete = result.remaining === 0;
-  if (inputs.length === 0)
+  if (inputs.length === 0) {
+    if (allInputs.length > 0)
+      result.deferred = true;
     return result;
+  }
   const batches = [];
   for (let i = 0;i < inputs.length; i += MAP_BATCH_SIZE) {
     batches.push({ inputs: inputs.slice(i, i + MAP_BATCH_SIZE), isOmissionRetry: false });
@@ -14393,6 +14475,10 @@ async function mapMemories(args) {
       if (!batch)
         break;
       const outcome = await mapOneBatch(args, batch.inputs, sliceMs, abortController.signal);
+      if (outcome.failure) {
+        result.failure = outcome.failure.error;
+        result.failureStage = outcome.failure.stage;
+      }
       const committed = outcome.mapped + outcome.independent;
       runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
         const committedIds = new Set(outcome.committedIds);
@@ -14456,6 +14542,7 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
   const startedAt = Date.now();
   let budgetFinalized = false;
   let failedCompletion;
+  let stage = "child-start";
   const onBudgetUpdate = (state) => {
     budgetFinalized ||= state.finalizeFired;
     args.onBudgetUpdate?.(state);
@@ -14477,15 +14564,19 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
         fallbackModels: args.fallbackModels,
         timeoutMs: sliceMs,
         signal,
+        onOpened: () => {
+          stage = "prompt";
+        },
         onFailureOutput: (completion) => {
           failedCompletion = completion;
         },
-        parse: (text, completion) => validateMapMemoriesManifest(currentManifest(assistantText(completion.messages ?? []) || text), new Set(batch.map((memory) => memory.id)))
+        parse: (text, completion) => parseMapMemoriesCompletion(text, completion, new Set(batch.map((memory) => memory.id)))
       });
       recordInvocation2(args, startedAt, {
         status: "completed",
         messages: run.completion.messages ?? []
       });
+      stage = "apply";
       const outcome = await applyParsedBatchMappings(args, batch, run.validated, budgetFinalized, true);
       logBatchUsage(run.completion.messages ?? [], outcome.mapped + outcome.independent, startedAt);
       const returnedIds = new Set(outcome.committedIds);
@@ -14510,6 +14601,7 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
     agentSessionId = typeof created?.id === "string" ? created.id : null;
     if (!agentSessionId)
       throw new Error("Could not create map-memories session.");
+    stage = "prompt";
     const run = await promptSyncWithValidatedOutputRetry(client, {
       path: { id: agentSessionId },
       query: { directory: args.sessionDirectory },
@@ -14537,18 +14629,11 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
           preferResponseOnMissingData: true
         });
       },
-      validateOutput: (messages) => {
-        if (hasLengthCappedOutput(messages)) {
-          throw new Error("map-memories returned length-capped output");
-        }
-        const text = currentManifest(assistantText(messages));
-        if (!text)
-          throw new Error("map-memories returned no output");
-        return validateMapMemoriesManifest(text, new Set(batch.map((memory) => memory.id)));
-      }
+      validateOutput: (messages) => validateClientMapMemories(messages, new Set(batch.map((memory) => memory.id)))
     });
     promptSettled = true;
     recordInvocation2(args, startedAt, { status: "completed", messages: run.output });
+    stage = "apply";
     const outcome = await applyParsedBatchMappings(args, batch, run.validated, budgetFinalized, true);
     logBatchUsage(run.output, outcome.mapped + outcome.independent, startedAt);
     const returnedIds = new Set(outcome.committedIds);
@@ -14577,6 +14662,8 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
     return {
       ...outcome,
       failure: {
+        error,
+        stage,
         class: isTimeoutClassError2(error) ? "timeout" : "other",
         elapsedMs: Date.now() - startedAt
       }
@@ -15701,10 +15788,28 @@ async function readRetrospectiveScanWindow(provider, projectIdentity, watermarkM
 }
 function readOpenCodeMessagesSince(db, sessionId, sinceMs, capPerSession) {
   const limit = Math.max(1, Math.floor(capPerSession));
-  const rows = db.prepare(`SELECT id, data, time_created
-               FROM message
-              WHERE session_id = ? AND time_created > ?
-              ORDER BY time_created ASC, id ASC
+  const rows = db.prepare(`SELECT current.id, current.data, current.time_created,
+                    EXISTS (
+                        SELECT 1 FROM message assistant_reply
+                         WHERE assistant_reply.session_id = current.session_id
+                           AND json_valid(assistant_reply.data)
+                           AND json_extract(assistant_reply.data, '$.role') = 'assistant'
+                           AND (assistant_reply.time_created < current.time_created
+                                OR (assistant_reply.time_created = current.time_created
+                                    AND assistant_reply.id < current.id))
+                           AND EXISTS (
+                               SELECT 1 FROM message prior_user
+                                WHERE prior_user.session_id = current.session_id
+                                  AND json_valid(prior_user.data)
+                                  AND json_extract(prior_user.data, '$.role') = 'user'
+                                  AND (prior_user.time_created < assistant_reply.time_created
+                                       OR (prior_user.time_created = assistant_reply.time_created
+                                           AND prior_user.id < assistant_reply.id))
+                           )
+                    ) AS has_prior_assistant_reply
+               FROM message current
+              WHERE current.session_id = ? AND current.time_created > ?
+              ORDER BY current.time_created ASC, current.id ASC
               LIMIT ?`).all(sessionId, sinceMs, limit + 1);
   const truncated = rows.length > limit;
   const kept = truncated ? rows.slice(0, limit) : rows;
@@ -15808,7 +15913,8 @@ function normalizeOpenCodeRows(db, sessionId, rows) {
       ordinal,
       role,
       parts,
-      ts: row.time_created
+      ts: row.time_created,
+      followsAssistantReply: row.has_prior_assistant_reply === 1
     });
   });
 }
@@ -15822,7 +15928,8 @@ function normalizeOpenCodeMessage(args) {
         ordinal: args.ordinal,
         role: "user",
         text,
-        ts: args.ts
+        ts: args.ts,
+        ...args.followsAssistantReply ? { followsAssistantReply: true } : {}
       });
     }
   }
@@ -16193,7 +16300,7 @@ var VERIFY_SYSTEM_PROMPT = `You are a memory verifier for the magic-context syst
 
 Each memory below comes with its backing file(s) — the code it makes a claim about. For EACH memory: use the provided git diff as evidence when present. If no diff is supplied, read its backing files (you may read more if needed) and decide whether the memory is still accurate.
 
-Tools (read-only): read, grep, glob. Request line ranges and keep reads short. You read code only when the evidence requires it; you change nothing.
+Tools (read-only): read, grep, glob, plus any available AFT navigation tools. Use at most 3 tool calls per memory, including searches and reads. Start with the backing files and likely identifier matches. Never read the same file twice in a batch; reuse evidence. Request short useful line ranges unless the claim concerns the file as a whole. If evidence is insufficient when the call budget runs out, SKIP that memory; uncertainty never justifies archival. You change nothing.
 
 Decide ONE of four outcomes per memory:
 - VERIFIED — still accurate. Keep it as-is.
@@ -16205,7 +16312,7 @@ UPDATE and ARCHIVE are ONLY for claims a repository file can falsify, such as an
 
 BE CONSERVATIVE ABOUT ARCHIVING. Wrong archival of a TRUE memory is the worst possible outcome — far worse than leaving a slightly-stale memory. If you cannot find the code, or you are unsure, or it might still be true somewhere you didn't look: mark it VERIFIED or SKIPPED, never archived. Archive ONLY when you have positive evidence the code contradicts a code fact.
 
-Output ONE XML manifest at the very end and NOTHING else — no narration, no per-memory commentary, no reasoning:
+Output ONE XML manifest and NOTHING else — no narration or reasoning. Open <verify> before investigating and emit each complete verdict immediately before investigating the next memory, so interruption preserves finished work. Close </verify> when done:
 <verify>
 <verified id="N" files="path/a.ts,path/b.ts"/>
 <update id="M" files="path/c.ts">corrected present-tense content</update>
@@ -16218,17 +16325,24 @@ Rules:
 - Every input memory id MUST appear exactly once, in exactly one of verified/update/archive/skip.
 - files = the COMPLETE current backing set (repo-relative, comma-separated). It may differ from the given mapping if a file moved — record what you actually verified against.
 - Default to VERIFIED. skip when code cannot decide the claim. update and archive are the exceptions, not the norm.`;
+async function seedVerifyCandidates(memories, directory) {
+  const seeded = await seedIdentifierCandidates(memories.map((m) => ({ ...m, candidates: [] })), directory);
+  return memories.map((m, i) => ({ ...m, candidates: seeded[i].candidates }));
+}
 function buildVerifyPrompt(projectPath, memories, evidence) {
   const list = memories.map((m) => `[${m.id}] ${m.category}
 Content: ${m.content}
-Backing files: ${m.mappedFiles.join(", ")}`).join(`
+Backing files: ${m.mappedFiles.join(", ")}${m.candidates?.length ? `
+Likely files (identifier matches, confirm before using): ${m.candidates.join(", ")}` : ""}`).join(`
 
 `);
   return `## Verify these memories against the code
 
 Project: ${projectPath}
 
-${evidence ? "The git diff below is the evidence. If changed hunks do not touch a claim, mark it verified without opening files. Open files only when a diff suggests the claim may have changed. A rename or deletion requires an update or archive when positively supported; do not archive on uncertainty." : "Read each memory's backing files to check its claims."} Decide verified / update / archive / skip (default verified; behavioral directives only permit verified or skip), then output ONE <verify> manifest covering every id.
+When available in this session, use aft_outline to outline the backing file and aft_zoom on the claimed symbol (or aft_search to locate it), instead of paging through whole files. Read a whole file only when the claim is about the file as a whole. Otherwise use the available read-only tools.
+
+${evidence ? "The git diff below is the evidence. If changed hunks do not touch a claim, mark it verified without opening files. Open files only when a diff suggests the claim may have changed. A rename or deletion requires an update or archive when positively supported; do not archive on uncertainty." : "Check each memory's claim against its backing files."} Decide verified / update / archive / skip (default verified; behavioral directives only permit verified or skip), then output ONE <verify> manifest covering every id.
 
 <memories>
 ${list}
@@ -16305,13 +16419,57 @@ function validateVerifyManifest(text, expectedIds) {
   assertNoDuplicateManifestIds(ids.filter((id) => expectedIds.has(id)), "verify");
   return parsed;
 }
+function parsePartialVerifyManifest(text, expectedIds) {
+  const out = { verified: [], updated: [], archived: [], skipped: [] };
+  const start = text.lastIndexOf("<verify>");
+  if (start < 0)
+    return out;
+  const entries = new Map;
+  const conflicts = new Set;
+  for (const match of text.slice(start).matchAll(/<(?:verified|archive|skip)\b[^<>]*\/>|<update\b[^<>]*>[\s\S]*?<\/update>/g)) {
+    try {
+      const parsed = parseVerifyManifest(`<verify>${match[0]}</verify>`);
+      const id = verifyIds(parsed)[0];
+      if (!expectedIds.has(id) || conflicts.has(id))
+        continue;
+      const previous = entries.get(id);
+      if (previous && JSON.stringify(previous) !== JSON.stringify(parsed)) {
+        entries.delete(id);
+        conflicts.add(id);
+      } else
+        entries.set(id, parsed);
+    } catch {}
+  }
+  for (const parsed of entries.values()) {
+    out.verified.push(...parsed.verified);
+    out.updated.push(...parsed.updated);
+    out.archived.push(...parsed.archived);
+    out.skipped.push(...parsed.skipped);
+  }
+  return out;
+}
 
 // ../plugin/src/features/magic-context/dreamer/verify.ts
-var VERIFY_BATCH_SIZE = 20;
+var VERIFY_BATCH_SIZE = 5;
+var VERIFY_TOKENS_PER_MEMORY = 1e5;
+var VERIFY_RUN_TOKEN_BUDGET = 2500000;
+var VERIFY_RUN_SLICE_MS = 240000;
+function verifyBatchTokenBudget(size, configured) {
+  return Math.min(configured ?? Number.MAX_SAFE_INTEGER, size * VERIFY_TOKENS_PER_MEMORY);
+}
+function verifyAssistantText(messages) {
+  const text = messages.filter((m) => isRecord(m) && (m.role === "assistant" || isRecord(m.info) && m.info.role === "assistant")).map((m) => extractLatestAssistantText([m]) || (isRecord(m) && Array.isArray(m.content) ? m.content.filter(isRecord).filter((p) => p.type === "text").map((p) => p.text).join(`
+`) : "")).join(`
+`);
+  if (!text.trim())
+    return null;
+  const start = text.lastIndexOf("<verify>");
+  return start >= 0 ? text.slice(start) : text;
+}
 var IDENTICAL_PROVIDER_FAILURE_BATCH_LIMIT = 2;
-var VERIFY_BATCH_FLOOR_MS = 240000;
-function computeVerifyBatchSliceMs(remainingMs, batchesRemaining) {
-  return Math.min(remainingMs, Math.max(VERIFY_BATCH_FLOOR_MS, Math.floor(remainingMs / batchesRemaining)));
+var VERIFY_BATCH_FLOOR_MS = 30000;
+function computeVerifyBatchSliceMs(remainingMs, _batchesRemaining) {
+  return Math.min(remainingMs, VERIFY_RUN_SLICE_MS);
 }
 function closeBroadCycle(args, cycleStartAt) {
   if (!args.forceBroad || cycleStartAt === undefined)
@@ -16335,6 +16493,7 @@ async function runVerify(args) {
 }
 async function runVerifyWithCooldown(args) {
   const runStartedAt = Date.now();
+  const sliceDeadline = runStartedAt + VERIFY_RUN_SLICE_MS;
   const result = {
     verified: 0,
     updated: 0,
@@ -16377,16 +16536,31 @@ async function runVerifyWithCooldown(args) {
   let consecutiveProviderFailures = 0;
   let priorProviderFailureFingerprint = null;
   let lastProviderFailure = null;
+  let runSpent = 0;
+  const runTokenBudget = Math.min(args.tokenBudget ?? VERIFY_RUN_TOKEN_BUDGET, VERIFY_RUN_TOKEN_BUDGET);
   try {
     for (let i = 0;i < batches.length; i += 1) {
-      const remainingMs = Math.max(0, args.deadline - Date.now());
+      const remainingMs = Math.max(0, Math.min(args.deadline, sliceDeadline) - Date.now());
       if (remainingMs < VERIFY_BATCH_FLOOR_MS) {
         result.stopReason = "deadline";
         log2(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: stopping before batch ${i + 1}/${batches.length} — remaining budget ${remainingMs}ms is below the ${VERIFY_BATCH_FLOOR_MS}ms batch floor`);
         break;
       }
       const sliceMs = computeVerifyBatchSliceMs(remainingMs, batches.length - i);
-      const counts = await verifyOneBatch(args, batches[i], sliceMs, abortController.signal);
+      if (runSpent >= runTokenBudget) {
+        result.stopReason = "token-budget";
+        break;
+      }
+      let batchSpent = 0;
+      const counts = await verifyOneBatch({
+        ...args,
+        tokenBudget: runTokenBudget - runSpent,
+        onBudgetUpdate: (state) => {
+          runSpent += Math.max(0, state.spent - batchSpent);
+          batchSpent = Math.max(batchSpent, state.spent);
+          args.onBudgetUpdate?.(state);
+        }
+      }, batches[i], sliceMs, abortController.signal);
       result.verified += counts.verified;
       result.updated += counts.updated;
       result.archived += counts.archived;
@@ -16396,6 +16570,10 @@ async function runVerifyWithCooldown(args) {
       result.remaining -= batchProcessed;
       result.batches += 1;
       args.onProgress?.(result.verified + result.updated + result.archived + result.skipped + result.refused, result.refused);
+      if (counts.tokenLimited) {
+        result.stopReason = "token-budget";
+        break;
+      }
       if (counts.timedOut) {
         result.stopReason = "batch-timeout";
         log2(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: batch ${i + 1}/${batches.length} timed out after its ${sliceMs}ms slice; stopping with ${result.remaining} remaining`);
@@ -16430,18 +16608,41 @@ async function runVerifyWithCooldown(args) {
   }
 }
 async function verifyOneBatch(args, batch, sliceMs, signal) {
+  const batchController = new AbortController;
+  const abort = () => batchController.abort(signal.reason);
+  signal.addEventListener("abort", abort, { once: true });
+  if (signal.aborted)
+    abort();
+  const timer = setTimeout(() => batchController.abort(new Error(`verify slice timed out after ${sliceMs}ms`)), sliceMs);
+  const batchSignal = batchController.signal;
+  const tokenBudget = verifyBatchTokenBudget(batch.length, args.tokenBudget);
   let agentSessionId = null;
+  let hiddenSessionId = null;
   let promptSettled = false;
   const startedAt = Date.now();
   let budgetFinalized = false;
+  let failedCompletion;
+  let headAtPrompt = null;
   const onBudgetUpdate = (state) => {
     budgetFinalized ||= state.finalizeFired;
-    args.onBudgetUpdate?.(state);
+    args.onBudgetUpdate?.({
+      ...state,
+      ...hiddenSessionId ? { sessionId: hiddenSessionId } : {}
+    });
+  };
+  const reportUsage = (messages, sessionId, fallbackSpent = 0) => {
+    const usage = sumTokensFromChildMessages(messages);
+    onBudgetUpdate({
+      spent: Math.max(fallbackSpent, usage.input + usage.cacheRead + usage.cacheWrite),
+      finalizeFired: budgetFinalized,
+      ...sessionId ? { sessionId } : {}
+    });
   };
   try {
-    const headAtPrompt = await readGitHead(args.sessionDirectory);
-    const evidence = !args.forceBroad && batch.every((m) => m.verifiedAt) ? await buildVerifyDiffEvidence(args.sessionDirectory, batch) : null;
-    const prompt = buildVerifyPrompt(args.projectIdentity, batch, evidence);
+    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);
+    batchSignal.throwIfAborted();
     if (args.hiddenCompletionExecutor) {
       const run = await runHiddenSingleShotPrompt({
         executor: args.hiddenCompletionExecutor,
@@ -16452,41 +16653,53 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         prompt,
         title: "magic-context-dream-verify",
         callContext: "dreamer:verify",
-        metadata: { tokenBudget: args.tokenBudget, onBudgetUpdate },
+        metadata: { tokenBudget, onBudgetUpdate },
         model: args.model,
         fallbackModels: args.fallbackModels,
         language: args.language,
         timeoutMs: sliceMs,
-        signal,
+        signal: batchSignal,
+        onFailureOutput: (completion) => {
+          failedCompletion = completion;
+        },
+        onOpened: (sessionId) => {
+          hiddenSessionId = sessionId;
+          onBudgetUpdate({ spent: 0, finalizeFired: false, sessionId });
+        },
         parse: (text, completion) => {
           const providerFailure = providerOutputFailureFromInvalidManifest(completion.messages ?? [], text);
           if (providerFailure)
             throw providerFailure;
-          return validateVerifyManifest(text, new Set(batch.map((memory) => memory.id)));
+          const manifest = verifyAssistantText(completion.messages ?? []) ?? (text.trim() ? text : null);
+          if (!manifest)
+            throw new Error("verify returned no output");
+          return validateVerifyManifest(manifest, new Set(batch.map((memory) => memory.id)));
         }
       });
       recordInvocation4(args, startedAt, {
         status: "completed",
         messages: run.completion.messages ?? []
       });
-      return applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized);
+      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);
     }
     const client = args.client;
     if (!client)
       throw new Error("verify requires a client or hidden completion executor");
-    const createResponse = await createChildSessionWithFence({
+    const createResponse = await raceWithSignal(createChildSessionWithFence({
       client,
       db: args.db,
       parentSessionId: args.parentSessionId,
       title: args.forceBroad ? "magic-context-dream-verify-broad" : "magic-context-dream-verify",
       directory: args.sessionDirectory
-    });
+    }), batchSignal);
     const created = normalizeSDKResponse(createResponse, null, {
       preferResponseOnMissingData: true
     });
     agentSessionId = typeof created?.id === "string" ? created.id : null;
     if (!agentSessionId)
       throw new Error("Could not create verify session.");
+    onBudgetUpdate({ spent: 0, finalizeFired: false, sessionId: agentSessionId });
     const run = await promptSyncWithValidatedOutputRetry(client, {
       path: { id: agentSessionId },
       query: { directory: args.sessionDirectory },
@@ -16498,11 +16711,11 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
       }
     }, {
       transport: createPromptAsyncTransport(client, agentSessionId, {
-        tokenBudget: args.tokenBudget,
+        tokenBudget,
         onBudgetUpdate
       }),
       timeoutMs: sliceMs,
-      signal,
+      signal: batchSignal,
       fallbackModels: args.fallbackModels,
       callContext: "dreamer:verify",
       fetchOutput: async () => {
@@ -16518,7 +16731,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         if (hasLengthCappedOutput(messages)) {
           throw new Error("verify returned length-capped output");
         }
-        const text = extractLatestAssistantText(messages);
+        const text = verifyAssistantText(messages);
         if (!text)
           throw new Error("verify returned no output");
         const providerFailure = providerOutputFailureFromInvalidManifest(messages, text);
@@ -16529,27 +16742,31 @@ 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);
   } catch (error) {
     const desc = describeError(error);
     const providerFailure = error instanceof DreamerProviderOutputFailureError ? error : undefined;
     const promptFailure = getPromptFailureDetail(error);
     log2(`[dreamer] verify batch ${providerFailure ? "provider failure" : "failed"}: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
+    const messages = failedCompletion?.messages ?? await readFailedChildMessages(args.client, agentSessionId, args.sessionDirectory) ?? [];
+    reportUsage(messages, hiddenSessionId ?? agentSessionId, failedCompletion?.usage.input ?? 0);
     recordInvocation4(args, startedAt, {
       status: failedInvocationStatus(error),
       error,
-      messages: await readFailedChildMessages(args.client, agentSessionId, args.sessionDirectory)
+      messages
     });
-    if (error instanceof DreamerModuleFailureError || error instanceof DreamTokenBudgetExceeded || signal.aborted)
+    if (error instanceof DreamerModuleFailureError || signal.aborted)
       throw error;
-    if (promptFailure?.failureClass === "provider_timeout" || isPromptTimeoutError(error)) {
+    const interrupted = batchSignal.aborted || error instanceof DreamTokenBudgetExceeded || promptFailure?.failureClass === "provider_timeout" || isPromptTimeoutError(error);
+    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);
       return {
-        verified: 0,
-        updated: 0,
-        archived: 0,
-        skipped: 0,
-        refused: 0,
-        timedOut: true
+        ...counts,
+        timedOut: !(error instanceof DreamTokenBudgetExceeded),
+        tokenLimited: error instanceof DreamTokenBudgetExceeded
       };
     }
     if (promptFailure !== null && promptFailure.failureClass !== "parse_failed" && !providerFailure)
@@ -16564,7 +16781,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     };
   } finally {
     if (agentSessionId && args.client)
-      await teardownChildSession({
+      await raceWithSignal(teardownChildSession({
         client: args.client,
         sessionId: agentSessionId,
         sessionDirectory: args.sessionDirectory,
@@ -16572,7 +16789,9 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         privacySensitive: true,
         context: "[dreamer] verify",
         log: log2
-      });
+      }), batchSignal).catch(() => {});
+    clearTimeout(timer);
+    signal.removeEventListener("abort", abort);
   }
 }
 async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budgetFinalized = false) {
@@ -16599,7 +16818,7 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
     throw new Error(`verify manifest covers ${validIds.length}/${batch.length} batch ids after filtering unknown entries; rejecting mostly-wrong manifest`);
   }
   if (budgetFinalized && validIds.length < batch.length) {
-    log2(`[dreamer] verify: accepted partial manifest after token budget: ${validIds.length}/${batch.length}`);
+    log2(`[dreamer] verify: accepted partial manifest after investigation stop: ${validIds.length}/${batch.length}`);
   }
   if (validIds.length === 0) {
     return { verified: 0, updated: 0, archived: 0, skipped: 0, refused: 0 };
@@ -16834,10 +17053,10 @@ function dreamRunFailureDetail(error) {
       child_session_id: null
     };
   }
-  const localRefusal = error instanceof HiddenCompletionRefusal;
+  const localRefusal = error instanceof HiddenCompletionRefusal || error instanceof DreamerModuleFailureError;
   const providerFailure = error instanceof Error && error.name === "DreamerProviderOutputFailureError";
   return {
-    failure_class: localRefusal ? "local_refusal" : providerFailure ? "provider_error" : /no models?|model chain is empty/i.test(message) ? "no_models" : "unknown",
+    failure_class: localRefusal ? "local_refusal" : providerFailure ? "provider_error" : /lease_(?:lost|expired)|Dream lease (?:lost|unavailable)/i.test(message) ? "child_aborted" : /no models?|model chain is empty/i.test(message) ? "no_models" : "unknown",
     model_attempted: null,
     models_tried: [],
     provider_error: providerFailure ? sanitizeDiagnosticText(message).slice(0, 500) : null,
@@ -16848,6 +17067,10 @@ function dreamRunFailureDetail(error) {
     } : {}
   };
 }
+function incompleteFailure(error, fallback = "parse_failed") {
+  const detail = dreamRunFailureDetail(error);
+  return detail.failure_class === "unknown" ? { ...detail, failure_class: fallback } : detail;
+}
 function classifyFailure(error) {
   const described = describeError(error);
   const brief = described.brief;
@@ -17007,6 +17230,7 @@ function createDreamTaskExecutor(deps) {
     const { db, projectIdentity, holderId, leaseKey } = ctx;
     deps.client?.resetDreamTokenBudget?.(config.task);
     const startedAt = Date.now();
+    const effectiveTokenBudget = config.task === "verify" || config.task === "verify-broad" ? Math.min(config.tokenBudget ?? VERIFY_RUN_TOKEN_BUDGET, VERIFY_RUN_TOKEN_BUDGET) : config.tokenBudget;
     const leaseAcquisition = ctx.leaseAcquisition ?? acquireLeaseWithAcquisition(db, holderId, leaseKey) ?? (() => {
       throw new Error("Dream lease unavailable during executor setup");
     })();
@@ -17054,7 +17278,7 @@ function createDreamTaskExecutor(deps) {
       if (state.sessionId) {
         const previous = childSpending.get(state.sessionId) ?? 0;
         budgetSpent += Math.max(0, state.spent - previous);
-        childSpending.set(state.sessionId, state.spent);
+        childSpending.set(state.sessionId, Math.max(previous, state.spent));
       } else
         budgetSpent = Math.max(budgetSpent, state.spent);
       budgetFinalized ||= state.finalizeFired;
@@ -17081,9 +17305,15 @@ function createDreamTaskExecutor(deps) {
                 failure: extra?.failure ?? dreamRunFailureDetail(error ?? "unknown dreamer failure")
               } : {},
               ...extra?.progress ? { progress: extra.progress } : {},
-              ...config.tokenBudget ? {
+              ...childSpending.size ? {
+                children: [...childSpending].map(([sessionId, promptTokens]) => ({
+                  sessionId,
+                  promptTokens
+                }))
+              } : {},
+              ...effectiveTokenBudget ? {
                 tokenBudget: {
-                  budget: config.tokenBudget,
+                  budget: effectiveTokenBudget,
                   spent: budgetSpent,
                   finalizeFired: budgetFinalized,
                   banked: extra?.banked ?? processedDreamTaskItems(backlogAtStart.pending, (extra?.backlogAfter ?? getDreamTaskBacklog(db, projectIdentity, config.task)).pending)
@@ -17172,8 +17402,13 @@ function createDreamTaskExecutor(deps) {
         });
         log2(`[dreamer] compress-cues: compressed=${result.compressed} skipped=${result.skipped} chunks=${result.chunks} remaining=${result.remaining}`);
         if (!result.complete) {
-          const error = incompleteMessage(result.remaining);
-          recordRun("failed", error);
+          if (result.stopReason === "deadline" && result.chunks === 0)
+            return skip("compress-cues: insufficient time to start a chunk");
+          const error = `${incompleteMessage(result.remaining)}; ${result.failureStage ? `${result.failureStage}: ` : ""}${result.failure ? describeError(result.failure).brief : `${result.skipped} cues rejected by validation`}`;
+          recordRun("failed", error, {
+            banked: result.compressed,
+            failure: incompleteFailure(result.failure, result.failureStage === "child-start" ? "local_refusal" : result.stopReason === "timeout-circuit-breaker" ? "provider_timeout" : "parse_failed")
+          });
           return { status: "failed", transient: true, error };
         }
         recordRun("completed", null);
@@ -17219,9 +17454,15 @@ function createDreamTaskExecutor(deps) {
         });
         log2(`[dreamer] map-memories: committed=${result.mapped + result.independent} mapped=${result.mapped} independent=${result.independent} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}${result.stopReason ? ` stop_reason=${result.stopReason}` : ""}`);
         if (!result.complete) {
+          if (result.deferred)
+            return skip("map-memories: all pending mappings are in content-keyed retry backoff; no child started");
+          if (result.stopReason === "deadline" && result.batches === 0 && !result.failure)
+            return skip("map-memories: insufficient time to start a batch");
           if (result.stopReason === "timeout-circuit-breaker") {
             const error = `map-memories starvation: timeout circuit breaker stopped the run with ${result.remaining} remain`;
-            recordRun("failed", error);
+            recordRun("failed", error, {
+              failure: incompleteFailure(result.failure, "provider_timeout")
+            });
             return { status: "failed", transient: true, error };
           }
           const processed = result.mapped + result.independent;
@@ -17230,8 +17471,10 @@ function createDreamTaskExecutor(deps) {
             recordRun("completed", null, { progress });
             return { status: "completed" };
           }
-          const error = incompleteMessage(result.remaining);
-          recordRun("failed", error);
+          const error = `${incompleteMessage(result.remaining)}; ${result.failureStage ? `${result.failureStage}: ` : ""}${result.failure ? describeError(result.failure).brief : "manifest returned no accepted mapping decisions"}`;
+          recordRun("failed", error, {
+            failure: incompleteFailure(result.failure, result.failureStage === "child-start" ? "local_refusal" : "parse_failed")
+          });
           return { status: "failed", transient: true, error };
         }
         recordRun("completed", null);
@@ -17261,25 +17504,27 @@ function createDreamTaskExecutor(deps) {
         });
         const processed = result.verified + result.updated + result.archived + result.skipped + result.refused;
         const verificationProgress = `${config.task}${config.task === "verify-broad" ? ` cycle ${result.broadCycleStartAt ?? "open"}` : ""}: processed ${processed} (verified ${result.verified}, updated ${result.updated}, archived ${result.archived}, skipped ${result.skipped}, refused ${result.refused}); ${result.remaining} remain`;
-        const broadProgress = config.task === "verify-broad" ? verificationProgress : null;
         const backlogAfter = config.task === "verify-broad" ? { pending: result.remaining, total: backlogAtStart.total } : undefined;
         if (!result.complete) {
-          if (broadProgress && processed > 0) {
+          if (processed > 0) {
             recordRun("completed", null, {
-              progress: broadProgress,
+              progress: verificationProgress,
               memoryChanges: computeMemoryDelta(memoryBefore),
               backlogAfter,
               banked: result.verified + result.updated + result.archived
             });
             return { status: "completed" };
           }
+          if (result.stopReason === "deadline")
+            return skip(`${config.task}: insufficient time to start a batch`);
           const batchTimedOut = result.stopReason === "batch-timeout";
           const error = batchTimedOut ? `${config.task}: a batch timed out within its time slice; ${result.remaining} remain` : incompleteMessage(result.remaining);
           recordRun("failed", error, {
             progress: verificationProgress,
             memoryChanges: computeMemoryDelta(memoryBefore),
             backlogAfter,
-            banked: result.verified + result.updated + result.archived
+            banked: result.verified + result.updated + result.archived,
+            failure: incompleteFailure(error, batchTimedOut ? "provider_timeout" : result.stopReason === "token-budget" ? "token_budget" : "parse_failed")
           });
           return { status: "failed", transient: !batchTimedOut, error };
         }
@@ -17403,6 +17648,7 @@ function createDreamTaskExecutor(deps) {
         if (retro.skipReason)
           return skip(retro.skipReason);
         recordRun("completed", null, {
+          progress: retro.noOpReason,
           memoryChanges: computeMemoryDelta(memoryBefore),
           backlogAfter: retro.retrospectiveWatermarkMs == null ? undefined : getDreamTaskBacklog(db, projectIdentity, "retrospective", {
             retrospectiveWatermarkMs: retro.retrospectiveWatermarkMs
@@ -17410,6 +17656,7 @@ function createDreamTaskExecutor(deps) {
         });
         return {
           status: "completed",
+          ...retro.noOpReason ? { detail: retro.noOpReason } : {},
           schedulePatch: retro.retrospectiveWatermarkMs != null || retro.taskStateJson !== undefined ? {
             ...retro.retrospectiveWatermarkMs != null ? {
               retrospectiveWatermarkMs: retro.retrospectiveWatermarkMs
@@ -17609,20 +17856,28 @@ async function runRetrospectiveTask(config, ctx, helpers) {
   const recencyCutoffMs = helpers.invocationStartedAt - recencyDays * RETROSPECTIVE_DAY_MS;
   const scan = await readRetrospectiveScanWindow(provider, projectIdentity, watermarkMs, RETROSPECTIVE_OVERLAP_USER_LINES, { usableInputTokens, recencyCutoffMs });
   const clearedTaskStateJson = activeOverflow ? writeRetrospectiveOverflowState(taskState.root, null) : undefined;
-  const completedWindow = (retrospectiveWatermarkMs) => ({
+  const completedWindow = (retrospectiveWatermarkMs, noOpReason) => ({
     retrospectiveWatermarkMs,
-    ...clearedTaskStateJson ? { taskStateJson: clearedTaskStateJson } : {}
+    ...clearedTaskStateJson ? { taskStateJson: clearedTaskStateJson } : {},
+    ...noOpReason ? { noOpReason } : {}
   });
   const messages = withGlobalOrdinals(scan.messages);
   const userMessages = messages.filter((message) => message.role === "user" && message.text.trim().length > 0);
   if (userMessages.length === 0) {
-    log2("[dreamer] retrospective: no user messages in window");
-    return completedWindow(scan.maxScannedTs);
+    const noOpReason = "no reply-following user lines";
+    log2(`[dreamer] retrospective: ${noOpReason}`);
+    return completedWindow(scan.maxScannedTs, noOpReason);
   }
-  const postWatermarkOrdinals = new Set(userMessages.filter((message) => message.ts > watermarkMs).map((message) => message.ordinal));
-  if (postWatermarkOrdinals.size === 0) {
+  const newUserOrdinals = new Set(userMessages.filter((message) => message.ts > watermarkMs).map((message) => message.ordinal));
+  if (newUserOrdinals.size === 0) {
     log2("[dreamer] retrospective: only overlap lines, nothing new");
-    return completedWindow(scan.maxScannedTs);
+    return completedWindow(scan.maxScannedTs, "only overlap lines, nothing new");
+  }
+  const postWatermarkOrdinals = new Set(userMessages.filter((message) => message.ts > watermarkMs && message.followsAssistantReply === true).map((message) => message.ordinal));
+  if (postWatermarkOrdinals.size === 0) {
+    const noOpReason = "no reply-following user lines";
+    log2(`[dreamer] retrospective: ${noOpReason}`);
+    return completedWindow(scan.maxScannedTs, noOpReason);
   }
   const abortController = new AbortController;
   let leaseLost = false;
@@ -19574,31 +19829,6 @@ function emptyPiModelChainsKey(chains) {
   return chains.map((chain) => `${chain.owner}=${chain.dropped.map((dropped) => dropped.model).join("|")}`).join(";");
 }
 
-// src/subagent-runner.ts
-import * as childProcess from "node:child_process";
-import {
-  existsSync as existsSync10,
-  mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync9,
-  realpathSync as realpathSync3,
-  rmSync as rmSync2,
-  statSync as statSync4,
-  writeFileSync as writeFileSync4
-} from "node:fs";
-import { createRequire } from "node:module";
-import { homedir, tmpdir as tmpdir2 } from "node:os";
-import {
-  basename,
-  dirname as dirname2,
-  isAbsolute,
-  join as join10,
-  resolve as resolvePath,
-  sep
-} from "node:path";
-import { createInterface } from "node:readline";
-import { StringDecoder } from "node:string_decoder";
-import { fileURLToPath } from "node:url";
-
 // src/pi-zen-free-tier.ts
 var ZEN_FREE_TIER_FAILURE = "opencode_zen_free_tier";
 function isZenModel(model) {
@@ -19631,6 +19861,29 @@ function classifyZenFreeTierFailure(result, model, agent, harness) {
 }
 
 // src/subagent-runner.ts
+import * as childProcess from "node:child_process";
+import {
+  existsSync as existsSync10,
+  mkdtempSync as mkdtempSync2,
+  readFileSync as readFileSync9,
+  realpathSync as realpathSync3,
+  rmSync as rmSync2,
+  statSync as statSync4,
+  writeFileSync as writeFileSync4
+} from "node:fs";
+import { createRequire } from "node:module";
+import { homedir, tmpdir as tmpdir2 } from "node:os";
+import {
+  basename,
+  dirname as dirname2,
+  isAbsolute,
+  join as join10,
+  resolve as resolvePath,
+  sep
+} from "node:path";
+import { createInterface } from "node:readline";
+import { StringDecoder } from "node:string_decoder";
+import { fileURLToPath } from "node:url";
 var PI_CODING_AGENT_MODULE = "@earendil-works/pi-coding-agent";
 var PI_CODING_AGENT_PACKAGE_NAMES = new Set([
   PI_CODING_AGENT_MODULE,
@@ -21765,8 +22018,17 @@ class PiRetrospectiveRawProvider {
       }
       const entries = this.deps.loadEntriesFromFile ? await this.deps.loadEntriesFromFile(filePath) : asyncSessionEntries(filePath);
       let ordinal = 0;
+      let sawUserMessage = false;
+      let sawAssistantReply = false;
       for await (const entry of entries) {
-        const row = normalizePiUserEntry(entry, sessionId, ++ordinal);
+        ordinal++;
+        let row = null;
+        if (isPiUserEntry(entry)) {
+          row = normalizePiUserEntry(entry, sessionId, ordinal, sawUserMessage && sawAssistantReply);
+          sawUserMessage = true;
+        } else if (sawUserMessage && isPiAssistantEntry(entry)) {
+          sawAssistantReply = true;
+        }
         if (!row || !eligible(row.ts))
           continue;
         kept.push(row);
@@ -21784,7 +22046,7 @@ class PiRetrospectiveRawProvider {
     return kept;
   }
 }
-function normalizePiUserEntry(entry, sessionId, ordinal) {
+function normalizePiUserEntry(entry, sessionId, ordinal, followsAssistantReply) {
   const e = entry;
   if (!e || typeof e !== "object" || e.type !== "message")
     return null;
@@ -21801,9 +22063,23 @@ function normalizePiUserEntry(entry, sessionId, ordinal) {
     ordinal,
     role: "user",
     text,
-    ts: message.timestamp
+    ts: message.timestamp,
+    ...followsAssistantReply ? { followsAssistantReply: true } : {}
   };
 }
+function isPiUserEntry(entry) {
+  return piMessageRole(entry) === "user";
+}
+function isPiAssistantEntry(entry) {
+  return piMessageRole(entry) === "assistant";
+}
+function piMessageRole(entry) {
+  const e = entry;
+  if (!e || typeof e !== "object" || e.type !== "message")
+    return null;
+  const message = e.message;
+  return message && typeof message === "object" ? message.role : null;
+}
 function extractPiTextContent(content) {
   if (typeof content === "string")
     return content;
@@ -22097,6 +22373,8 @@ function createPiDreamerClient(opts, onAdjunctsRefreshNeeded = opts.onAdjunctsRe
         accountingSubagent: "dreamer",
         accountingTask: accountingTaskFromTitle(dreamSession.title),
         tokenBudget: (() => {
+          if (args.tokenBudget !== undefined)
+            return args.tokenBudget;
           const task = accountingTaskFromTitle(dreamSession.title);
           if (!task)
             return;
@@ -22107,8 +22385,15 @@ function createPiDreamerClient(opts, onAdjunctsRefreshNeeded = opts.onAdjunctsRe
       try {
         const result = await runPromise;
         const budget = result.meta?.tokenBudget;
-        if (budget)
-          childBudgetStates.set(sessionId, budget);
+        if (budget) {
+          const prior = childBudgetStates.get(sessionId);
+          childBudgetStates.set(sessionId, {
+            ...budget,
+            budget: prior?.budget ?? budget.budget,
+            spent: (prior?.spent ?? 0) + budget.spent,
+            finalizeFired: (prior?.finalizeFired ?? false) || budget.finalizeFired
+          });
+        }
         const budgetTask = accountingTaskFromTitle(dreamSession.title);
         if (budgetTask && budget && typeof budget.spent === "number") {
           const prior = budgetStates.get(budgetTask);
@@ -22119,8 +22404,15 @@ function createPiDreamerClient(opts, onAdjunctsRefreshNeeded = opts.onAdjunctsRe
         }
         assertRegistrationOwnerActive();
         const mappingMessages = result.meta?.mappingMessages;
-        if (budgetTask === "map-memories" && Array.isArray(mappingMessages)) {
+        const isVerification = budgetTask === "verify" || budgetTask === "verify-broad";
+        const hasMemoryDecisions = (budgetTask === "map-memories" || isVerification) && result.meta?.failureClass !== ZEN_FREE_TIER_FAILURE && Array.isArray(mappingMessages);
+        if (hasMemoryDecisions) {
           dreamSession.messages = mappingMessages.filter(isRecord).filter((message) => message.role === "assistant").map((message) => makeMessage("assistant", Array.isArray(message.content) ? message.content.filter(isRecord).flatMap((part) => part.type === "text" && typeof part.text === "string" ? [{ type: "text", text: part.text }] : part.type === "toolCall" ? syntheticToolParts(1) : []) : []));
+          if (result.ok && result.assistantText?.trim() && !dreamSession.messages.some((message) => extractLatestAssistantText([message])?.trim())) {
+            dreamSession.messages.push(makeMessage("assistant", [
+              { type: "text", text: result.assistantText }
+            ]));
+          }
         }
         if (!result.ok) {
           if (result.reason === "token_budget") {
@@ -22135,7 +22427,7 @@ function createPiDreamerClient(opts, onAdjunctsRefreshNeeded = opts.onAdjunctsRe
           }
           throw error;
         }
-        if (!(budgetTask === "map-memories" && Array.isArray(mappingMessages)))
+        if (!hasMemoryDecisions)
           dreamSession.messages = [
             makeMessage("user", [{ type: "text", text: userMessage }]),
             makeMessage("assistant", [
@@ -22534,6 +22826,85 @@ Unknown task "${requested}".`,
   });
 }
 
+// ../plugin/src/hooks/magic-context/auto-embed-session.ts
+function embeddingIdentity(projectIdentity) {
+  const snapshot = getProjectEmbeddingSnapshot2(projectIdentity);
+  return JSON.stringify([
+    projectIdentity,
+    snapshot?.providerIdentity,
+    snapshot?.chunkModelId,
+    snapshot?.runtimeFingerprint
+  ]);
+}
+function maybeAutoEmbedSessionBackfill(deps, sessionId) {
+  const markActive = () => activeEmbeddingSessions.set(sessionId, {
+    project: deps.projectIdentity,
+    model: getProjectEmbeddingSnapshot2(deps.projectIdentity)?.chunkModelId ?? "off"
+  });
+  markActive();
+  const identity = embeddingIdentity(deps.projectIdentity);
+  if (autoEmbedIdentityBySession.get(sessionId) !== identity) {
+    invalidateAutoEmbedSession(sessionId);
+    autoEmbedIdentityBySession.set(sessionId, identity);
+  }
+  if (autoEmbedAttemptedBySession.has(sessionId) || embedPauseBySession.has(sessionId) || embedRunStateBySession.has(sessionId) || Date.now() < (autoEmbedRetryAfterBySession.get(sessionId) ?? 0))
+    return;
+  const controller = new AbortController;
+  embedRunStateBySession.set(sessionId, controller);
+  (async () => {
+    let complete = false;
+    let retryDelay = 1000;
+    let started = false;
+    let reason = "error";
+    let registeredIdentity = identity;
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      if (controller.signal.aborted)
+        return;
+      await deps.ensureRegistered();
+      if (controller.signal.aborted)
+        return;
+      markActive();
+      registeredIdentity = embeddingIdentity(deps.projectIdentity);
+      autoEmbedIdentityBySession.set(sessionId, registeredIdentity);
+      const coverage = await getAutoEmbeddingSessionCoverage2(deps.db, deps.projectIdentity, sessionId);
+      if (controller.signal.aborted || !coverage.enabled)
+        return;
+      if (coverage.embedded === coverage.total) {
+        complete = true;
+        return;
+      }
+      const model = getProjectEmbeddingSnapshot2(deps.projectIdentity)?.model;
+      log2(`[magic-context] session backfill start session=${sessionId} missing=${coverage.total - coverage.embedded} model=${model}`);
+      started = true;
+      const outcome = await embedSessionCompartmentChunks2(deps.db, deps.projectIdentity, sessionId, { signal: controller.signal, automatic: true });
+      reason = outcome.status;
+      const after = await getAutoEmbeddingSessionCoverage2(deps.db, deps.projectIdentity, sessionId);
+      complete = after.enabled && after.embedded === after.total;
+      if (!complete && outcome.status !== "busy" && outcome.status !== "aborted") {
+        retryDelay = 60000;
+        if (outcome.status === "nothing" || outcome.status === "done")
+          reason = "deferred";
+      }
+    } catch (error) {
+      log2("[magic-context] auto-embed drain failed:", error);
+      retryDelay = 60000;
+    } finally {
+      if (started)
+        log2(`[magic-context] session backfill ${complete ? "complete" : "stop"} session=${sessionId} reason=${reason}`);
+      if (embedRunStateBySession.get(sessionId) === controller) {
+        embedRunStateBySession.delete(sessionId);
+      }
+      if (!controller.signal.aborted && autoEmbedIdentityBySession.get(sessionId) === registeredIdentity && embeddingIdentity(deps.projectIdentity) === registeredIdentity) {
+        if (complete)
+          autoEmbedAttemptedBySession.add(sessionId);
+        else
+          autoEmbedRetryAfterBySession.set(sessionId, Date.now() + retryDelay);
+      }
+    }
+  })();
+}
+
 // ../plugin/src/hooks/magic-context/format-embed-failure.ts
 function formatEmbedFailureSummary(embedded, remaining, failure, style = "markdown") {
   const historyBlocks = `history block${embedded === 1 ? "" : "s"}`;
@@ -22591,6 +22962,7 @@ function formatEmbedStatusText(coverage, drain) {
 var EMBED_PROGRESS_COMPARTMENT_STEP = 8;
 var EMBED_PROGRESS_MIN_INTERVAL_MS = 1e4;
 function clearPiEmbedSessionState(sessionId) {
+  activeEmbeddingSessions.delete(sessionId);
   embedPauseBySession.delete(sessionId);
   const ctrl = embedRunStateBySession.get(sessionId);
   if (ctrl) {
@@ -22779,35 +23151,11 @@ ${statusText}`,
 function maybeAutoEmbedPiSession(deps, sessionId, projectDir, projectIdentity) {
   if (!isUsableProjectIdentity(projectIdentity))
     return;
-  const snapshot = getProjectEmbeddingSnapshot2(projectIdentity);
-  const embedIdentity = snapshot ? JSON.stringify([
-    snapshot.providerIdentity,
-    snapshot.chunkModelId,
-    snapshot.runtimeFingerprint
-  ]) : "off";
-  if (autoEmbedIdentityBySession.get(sessionId) !== embedIdentity)
-    invalidateAutoEmbedSession(sessionId);
-  if (autoEmbedAttemptedBySession.has(sessionId))
-    return;
-  if (embedPauseBySession.has(sessionId))
-    return;
-  autoEmbedAttemptedBySession.add(sessionId);
-  autoEmbedIdentityBySession.set(sessionId, embedIdentity);
-  (async () => {
-    try {
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      await ensureProjectRegisteredFromPiDirectory(projectDir, deps.db);
-      const coverage = await getAutoEmbeddingSessionCoverage2(deps.db, projectIdentity, sessionId);
-      if (!coverage.enabled) {
-        invalidateAutoEmbedSession(sessionId);
-        return;
-      }
-      const remaining = coverage.total - coverage.embedded;
-      if (remaining <= 0)
-        return;
-      await runEmbedDrain(deps.db, projectIdentity, sessionId);
-    } catch {}
-  })();
+  maybeAutoEmbedSessionBackfill({
+    db: deps.db,
+    projectIdentity,
+    ensureRegistered: () => ensureProjectRegisteredFromPiDirectory(projectDir, deps.db)
+  }, sessionId);
 }
 
 // ../plugin/src/hooks/magic-context/execute-flush.ts
@@ -38802,7 +39150,7 @@ class PiThinkingBindingRecoveryRefusal extends EmergencyFailClosedError {
 function applyPiThinkingBindingRecovery(args) {
   const protectedMessages = latestAssistantTurnMessages(args.messages);
   const frozenEntryIds = frozenBindingEntryIds(args.db, args.sessionId);
-  const flagTargetCandidate = isPrefixBoundThinkingModel(args.provider, args.model) ? getThinkingBindingRecoveryTarget(args.db, args.sessionId) : null;
+  const flagTargetCandidate = !args.replayOnly && isPrefixBoundThinkingModel(args.provider, args.model) ? getThinkingBindingRecoveryTarget(args.db, args.sessionId) : null;
   const flagTarget = flagTargetCandidate?.startsWith(LATEST_THINKING_RESTORE) ? null : flagTargetCandidate;
   let applied = null;
   if (flagTarget) {
@@ -42239,6 +42587,7 @@ function registerPiContextHandler(pi, baseOptions) {
       const scheduler = schedulerFor(options);
       lkgCompactionOff = options.compactionOff === true;
       const projectIdentity = resolveProjectIdentityForSession(projectDirectory, options.allowHomeProject) ?? "";
+      withoutSqliteTransformPass2(() => options.maybeAutoEmbedSession?.(sessionId, projectDirectory, projectIdentity));
       logTransformTiming(sessionId, "findSessionId", tFindSession, `messages=${event.messages.length}`);
       budget.stage = "branch projection";
       const tEntryBranch = performance.now();
@@ -42973,14 +43322,15 @@ function registerPiContextHandler(pi, baseOptions) {
         hostEditBeforeNewestThinking = stickyBefore === null || [...stickyAfter].some((key) => !stickyBefore.has(key)) || JSON.stringify(getPersistedTodoSyntheticAnchor(options.db, sessionId)) !== todoAnchorBefore;
       } catch {}
       const outputEntryIds = resolvePiLkgOutputEntryIds(outputMessages, result.syntheticLeadingCount, (message) => result.lkgEntryIdByRef.get(message) ?? result.postCommitEntryIdByRef.get(message) ?? bindingEntryIdByRef.get(message)).map((entryId) => entryId ?? undefined);
-      const thinkingBindingRecoveryApplied = bindingStripOrder === "end" && (!result.signedPrefixRewritten || !result.prefixBustPermitted) ? applyPiThinkingBindingRecovery({
+      const thinkingBindingRecoveryApplied = bindingStripOrder === "end" ? applyPiThinkingBindingRecovery({
         db: options.db,
         sessionId,
         messages: outputMessages,
         entryIds: outputEntryIds,
         provider: lkgProviderKey ?? undefined,
         model: ctx.model?.id,
-        endOfPassOrder: true
+        endOfPassOrder: true,
+        replayOnly: result.signedPrefixRewritten && result.prefixBustPermitted
       }) : startOfPassBindingRecovery;
       if (shouldRunPiProactiveThinkingStrip({
         compactionOff: options.compactionOff === true,
@@ -43135,8 +43485,6 @@ function registerPiContextHandler(pi, baseOptions) {
       logTransformTiming(sessionId, "stableIdSchemePersist", tStableIdSchemePersist);
       logTransformTiming(sessionId, "postTransformPhase", tPostTransform);
       clearLastTransformErrorIfSet(options.db, sessionId, sessionMeta.lastTransformError);
-      if (budget.remainingWork() > PI_CONTEXT_BUDGET.completionReserveMs)
-        withoutSqliteTransformPass2(() => options.maybeAutoEmbedSession?.(sessionId, projectDirectory, projectIdentity));
       logTransformTiming(sessionId, "postPipelineTotal", postPipelineStart);
       const transformElapsedMs = performance.now() - transformStartTime;
       recordPiTransformTiming({
@@ -44566,7 +44914,7 @@ async function runPipeline(args) {
     ...message,
     parts: message.parts
   }));
-  const recoveryNormalized = !!args.recoveryPrefix && (foldBustsServedPrefixThisPass || firstRenderBust || identityRebuild);
+  const recoveryNormalized = !!args.recoveryPrefix && (isCacheBustingPass || identityRebuild);
   const taggingView = args.recoveryPrefix && !recoveryNormalized ? mutationView.filter((message) => !args.recoveryPrefix?.untaggedInputIds.has(message.info.id ?? "")) : mutationView;
   let tagTextTokenCache = piTagTextTokenCacheBySession.get(args.sessionId);
   if (!tagTextTokenCache) {