@cortexkit/opencode-magic-context 0.49.12 → 0.49.13

package/dist/v2/{context-x60fa16g.js → context-w055w17c.js}

@@ -6,7 +6,7 @@ import {
   resolveLegacyConfigSources,
   getProtectedTokensTierOverrides,
   loadPluginConfigDetailed
-} from "./server-37ngj8qw.js";
+} from "./server-zc3e54vy.js";
 import {
   getHarness2,
   harnessOwnsOpenCodeStore2
@@ -33,7 +33,7 @@ import {
   getSdkContextLimit,
   getSdkOutputLimit,
   getModelsDevCacheState
-} from "./server-kn9n2qgd.js";
+} from "./server-tbe1femw.js";
 import {
   isValidLanguageCode,
   withContentLanguageDirective,
@@ -71,13 +71,6 @@ import {
   pluginConfigReader,
   currentPluginConfigReader,
   withLiveDreamerOutputCap,
-  embedPauseBySession,
-  embedRunStateBySession,
-  autoEmbedAttemptedBySession,
-  autoEmbedIdentityBySession,
-  invalidateAutoEmbedSession,
-  getEmbedDrainUiStatus,
-  clearEmbedSessionState,
   acquireCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
@@ -214,9 +207,11 @@ import {
   toModelEntry,
   isPromptTimeoutError,
   getPromptFailureDetail,
+  raceWithSignal,
   promptSyncWithValidatedOutputRetry,
   normalizeSDKResponse,
   failedInvocationStatus,
+  sumTokensFromChildMessages,
   recordChildInvocation,
   createPromptAsyncTransport,
   CTX_NOTE_LIGHT_DESCRIPTION,
@@ -286,7 +281,7 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-5gvkzzrf.js";
+} from "./server-b81w6sw3.js";
 import {
   resolveHistorianModel2
 } from "./server-8cd2j99z.js";
@@ -311,7 +306,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-50mkkhy1.js";
+} from "./server-n8ch9683.js";
 import {
   setHomeProjectPermission,
   shouldSkipHomeProjectMemory,
@@ -515,6 +510,35 @@ import {
   readSessionChunk2,
   readRawSessionSeedTail2
 } from "./server-m97brnat.js";
+import {
+  embedPauseBySession,
+  embedRunStateBySession,
+  activeEmbeddingSessions,
+  autoEmbedAttemptedBySession,
+  autoEmbedIdentityBySession,
+  autoEmbedRetryAfterBySession,
+  invalidateAutoEmbedSession,
+  getEmbedDrainUiStatus,
+  clearEmbedSessionState,
+  describeShadowBackfillWriteRefusal2,
+  markProjectLoadUntrusted2,
+  drainProjectEmbeddingIdentityMaintenance2,
+  drainStaleEmbeddingIdentitiesForProject2,
+  registerProjectEmbedding2,
+  registerProjectShadowEmbedding2,
+  enqueueShadowEmbeddingItems2,
+  registerProjectInObservationMode2,
+  unregisterProjectShadowEmbedding2,
+  getProjectEmbeddingSnapshot2,
+  embedTextForProject2,
+  embedBatchForProject2,
+  embedUnembeddedMemoriesForProject2,
+  embedUnembeddedMemoriesForProjectOutcome2,
+  drainCommitBacklogForProject2,
+  embedSessionCompartmentChunks2,
+  getEmbeddingCoverageStatus2,
+  getAutoEmbeddingSessionCoverage2
+} from "./server-hek6z3w6.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -551,7 +575,7 @@ import {
 import"./server-yrvqaswb.js";
 import {
   deleteChunkEmbedBackoffForSession
-} from "./server-vknbt0gq.js";
+} from "./server-qhfvvfxj.js";
 import {
   registerOwnRpcServerInstance,
   rpcPortDir,
@@ -577,7 +601,7 @@ import {
   isMessageIndexReconciledThrough2,
   indexMessagesAfterOrdinal2,
   sweepOrphanedOpenCodeMessageIndexes2
-} from "./server-nmrm2rjy.js";
+} from "./server-t4prcjc1.js";
 import {
   stableStringify,
   getTemporalDecisions,
@@ -719,35 +743,7 @@ import {
   resolveStoredPathWorkspaceIdentity,
   storedPathBelongsToWorkspace,
   computeWorkspaceEpochFingerprint
-} from "./server-fa75w6gp.js";
-import {
-  GIT_SWEEP_LEASE_RENEWAL_MS,
-  acquireGitSweepLease,
-  renewGitSweepLease,
-  markGitSweepSuccessAndRelease,
-  parkGitSweepNonIndexable,
-  releaseGitSweepLease,
-  recordSessionProjectIdentity,
-  hasRecordedSessionProjectIdentity,
-  describeShadowBackfillWriteRefusal2,
-  markProjectLoadUntrusted2,
-  drainProjectEmbeddingIdentityMaintenance2,
-  drainStaleEmbeddingIdentitiesForProject2,
-  registerProjectEmbedding2,
-  registerProjectShadowEmbedding2,
-  enqueueShadowEmbeddingItems2,
-  registerProjectInObservationMode2,
-  unregisterProjectShadowEmbedding2,
-  getProjectEmbeddingSnapshot2,
-  embedTextForProject2,
-  embedBatchForProject2,
-  embedUnembeddedMemoriesForProject2,
-  embedUnembeddedMemoriesForProjectOutcome2,
-  drainCommitBacklogForProject2,
-  embedSessionCompartmentChunks2,
-  getEmbeddingCoverageStatus2,
-  getAutoEmbeddingSessionCoverage2
-} from "./server-sz8jj92q.js";
+} from "./server-k2bzedxk.js";
 import {
   configureContextDatabasePragmas2
 } from "./server-fb3zxn06.js";
@@ -793,18 +789,28 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./server-4c10404h.js";
+} from "./server-6cdy4rc0.js";
 import {
   deriveTriggerBudget2,
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianProducerLimits2,
   resolveHistorianContextLimit2
-} from "./server-f7jfmrrz.js";
+} from "./server-34kwfsr4.js";
 import"./server-05xjtq6c.js";
 import {
   isEmbeddingHostBusy2
 } from "./server-qt1qqasc.js";
+import {
+  GIT_SWEEP_LEASE_RENEWAL_MS,
+  acquireGitSweepLease,
+  renewGitSweepLease,
+  markGitSweepSuccessAndRelease,
+  parkGitSweepNonIndexable,
+  releaseGitSweepLease,
+  recordSessionProjectIdentity,
+  hasRecordedSessionProjectIdentity
+} from "./server-4gn3z5an.js";
 import {
   saveEmbeddingIfHashMatches,
   invalidateProject2,
@@ -812,10 +818,10 @@ import {
 } from "./server-4dhv7mqz.js";
 import {
   getLocalEmbeddingNativeMemoryStats
-} from "./server-2x42esxd.js";
+} from "./server-g10mdym6.js";
 import {
   cosineSimilarity
-} from "./server-9ewkzqgd.js";
+} from "./server-ef89gdsx.js";
 import {
   computeCueContentHash,
   hasMuralCueColumns,
@@ -852,7 +858,7 @@ import"./server-h0410h0v.js";
 import {
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./server-83ygfha2.js";
+} from "./server-vbe4se57.js";
 import {
   renderSingleStoreMigrationRequiredRefusal,
   SingleStoreMigrationRequiredError,
@@ -873,7 +879,7 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-25tg45b4.js";
+} from "./server-xh7jar6k.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
@@ -893,21 +899,6 @@ import {
 import {
   computeNormalizedHash
 } from "./server-2bvekkfy.js";
-import {
-  sameProjectDirectory,
-  canonicalProjectDirectory
-} from "./server-knvkbfvh.js";
-import {
-  getErrorMessage,
-  describeError
-} from "./server-y8v6yerm.js";
-import {
-  shouldEnforcePrivateStoragePermissions,
-  ensureStorageDirectorySync,
-  writeStorageFileAtomicSync,
-  writeStorageFileAsync,
-  createStorageWriteStream
-} from "./server-fvnzcnww.js";
 import {
   normalizeProtectedToolName,
   mergeProtectedTools
@@ -917,6 +908,14 @@ import {
   piModelRefToCanonical,
   modelRefLookupOrder
 } from "./server-avwt563y.js";
+import {
+  sameProjectDirectory,
+  canonicalProjectDirectory
+} from "./server-knvkbfvh.js";
+import {
+  getErrorMessage,
+  describeError
+} from "./server-y8v6yerm.js";
 import {
   closeQuietly,
   isKnownAutocommit
@@ -924,6 +923,13 @@ import {
 import {
   logSlowWriteTransaction
 } from "./server-6pmqg9m4.js";
+import {
+  shouldEnforcePrivateStoragePermissions,
+  ensureStorageDirectorySync,
+  writeStorageFileAtomicSync,
+  writeStorageFileAsync,
+  createStorageWriteStream
+} from "./server-fvnzcnww.js";
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -9809,11 +9815,6 @@ async function runPostTransformPhase(args) {
     }
     sessionLog2(args.sessionId, `m[0] HARD fold decision: reason=${m0MaterializeReason ?? foldDueDecision.reason ?? (foldExecutedThisPass ? "drift" : "soft_refresh")} executed=${foldExecutedThisPass} bustsServedPrefix=${foldBustsServedPrefixThisPass}`);
   }
-  if (args.normalizeRecoveryTail && (foldBustsServedPrefixThisPass || firstRenderBust)) {
-    args.normalizeRecoveryTail();
-    args.tags = getTagsBySession2(args.db, args.sessionId);
-    newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
-  }
   logTransformTiming(args.sessionId, "pp.prefixPreflight", tPostprocessSetup, `foldExecuted=${foldExecutedThisPass} m1Refreshed=${publishedM1RefreshedThisPass}`);
   const tPassDecisions = performance.now();
   const frontToolCandidates = args.tags.filter((tag) => tag.type === "tool" && tag.status === "active" && args.targets.get(tag.tagNumber)?.canDrop?.());
@@ -9847,6 +9848,11 @@ async function runPostTransformPhase(args) {
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
   const shouldRunHeuristics = publishedWorkDrainAllowed && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
+  if (args.normalizeRecoveryTail && isCacheBustingPass) {
+    args.normalizeRecoveryTail();
+    args.tags = getTagsBySession2(args.db, args.sessionId);
+    newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
+  }
   const reclaimDistance = isCacheBustingPass ? toolReclaimDistanceEntries(args.messages, args.targets) : [];
   const canEditWholePrefix = isCacheBustingPass && !activeThinkingPrefixHold;
   const previousTemporalDecisions = args.temporalCandidates && !compactionOff ? new Map([
@@ -20533,7 +20539,7 @@ function getAsyncModule() {
       await beforeModuleLoad();
     const [{ default: singlefileAsyncifyVariant }, { newQuickJSAsyncWASMModuleFromVariant }] = await importPluginModule(() => Promise.all([
       import("./index-6e4mwffh.js").then((m)=>__toESM(m.default,1)),
-      import("./index-e6xnpach.js")
+      import("./index-b7p25tm0.js")
     ]));
     const module = await newQuickJSAsyncWASMModuleFromVariant(singlefileAsyncifyVariant);
     return module;
@@ -22559,7 +22565,7 @@ function registerRpcHandlers(rpcServer, args) {
     return { count: buildCompartmentCount(db, sessionId, moduleStatus) };
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-z25jw3py.js"));
+    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-2zh4gm2c.js"));
     const { resolveHistorianModel } = await importPluginModule(() => import("./model-resolution-nx97z3x7.js"));
     const { userObservationCollectionEnabled, userObservationsRequested } = await importPluginModule(() => import("./task-config-nvz8mapa.js"));
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 10 * 60 * 1000;
@@ -22611,8 +22617,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-8w3449eb.js"));
-    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-jevgj9fe.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-ca7qt75a.js"));
+    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-8ghn9tnv.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -22696,7 +22702,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-r82y780v.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-e1a2w6jh.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -26804,9 +26810,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;
       }
@@ -26815,6 +26824,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;
@@ -26824,6 +26837,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;
         }
@@ -26840,7 +26854,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;
@@ -26848,6 +26862,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,
@@ -26868,6 +26883,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 },
@@ -26919,16 +26935,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
@@ -27082,7 +27101,7 @@ async function applyCuesThroughModule(args, chunk, manifestText, signal) {
 // 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",
@@ -27094,6 +27113,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)
@@ -27148,12 +27178,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);
   }
 }
 
@@ -30228,14 +30262,28 @@ function isDeferred(memory, retries) {
   return !!retry && retry.content === contentKey2(memory) && retry.deferUntil > Date.now();
 }
 function assistantText2(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(assistantText2(completion.messages ?? []) || text), expectedIds);
+}
+function validateClientMapMemories(messages, expectedIds) {
+  if (hasLengthCappedOutput(messages)) {
+    throw new Error("map-memories returned length-capped output");
+  }
+  const raw = assistantText2(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}`);
@@ -30300,8 +30348,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 });
@@ -30327,6 +30378,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);
@@ -30390,6 +30445,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);
@@ -30411,15 +30467,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(assistantText2(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);
@@ -30444,6 +30504,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 },
@@ -30471,18 +30532,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(assistantText2(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);
@@ -30511,6 +30565,8 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
     return {
       ...outcome,
       failure: {
+        error,
+        stage,
         class: isTimeoutClassError2(error) ? "timeout" : "other",
         elapsedMs: Date.now() - startedAt
       }
@@ -31667,10 +31723,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;
@@ -31774,7 +31848,8 @@ function normalizeOpenCodeRows(db, sessionId, rows) {
       ordinal,
       role,
       parts,
-      ts: row.time_created
+      ts: row.time_created,
+      followsAssistantReply: row.has_prior_assistant_reply === 1
     });
   });
 }
@@ -31788,7 +31863,8 @@ function normalizeOpenCodeMessage(args) {
         ordinal: args.ordinal,
         role: "user",
         text,
-        ts: args.ts
+        ts: args.ts,
+        ...args.followsAssistantReply ? { followsAssistantReply: true } : {}
       });
     }
   }
@@ -32154,7 +32230,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.
@@ -32166,7 +32242,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>
@@ -32179,17 +32255,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}
@@ -32266,13 +32349,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;
+}
 
 // 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)
@@ -32296,6 +32423,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,
@@ -32338,16 +32466,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;
@@ -32357,6 +32500,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`);
@@ -32391,18 +32538,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,
@@ -32413,41 +32583,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 },
@@ -32459,11 +32641,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 () => {
@@ -32479,7 +32661,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);
@@ -32490,27 +32672,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)
@@ -32525,7 +32711,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,
@@ -32533,7 +32719,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) {
@@ -32560,7 +32748,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 };
@@ -32795,10 +32983,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,
@@ -32809,6 +32997,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;
@@ -32968,6 +33160,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");
     })();
@@ -33015,7 +33208,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;
@@ -33042,9 +33235,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)
@@ -33133,8 +33332,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);
@@ -33180,9 +33384,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;
@@ -33191,8 +33401,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);
@@ -33222,25 +33434,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 };
         }
@@ -33364,6 +33578,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
@@ -33371,6 +33586,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
@@ -33570,20 +33786,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;
@@ -34537,7 +34761,8 @@ class V2RetrospectiveRawProvider {
       ordinal: row.seq,
       role: "user",
       text: cleanUserText2(row.text),
-      ts: row.time_created
+      ts: row.time_created,
+      ...row.follows_assistant_reply === 1 ? { followsAssistantReply: true } : {}
     }));
   }
   readUserMessagesSince(sessionId, sinceMs, capPerSession) {
@@ -50533,6 +50758,85 @@ function bindV2TransformDecision(args) {
   }
 }
 
+// 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);
+      }
+    }
+  })();
+}
+
 // src/v2/hooks/transform-features.ts
 function createV2TransformFeatureDeps(config, compactionOff, directory) {
   return {
@@ -50568,47 +50872,18 @@ function createV2TransformFeatureDeps(config, compactionOff, directory) {
 }
 function createV2AutoEmbedSession(deps) {
   return (sessionId) => {
-    if (isEmbeddingHostBusy2())
-      return;
     const directory = deps.resolveDirectory(sessionId);
-    const identity = resolveProjectIdentityForSession(directory, deps.allowHomeProject);
-    const snapshot = identity ? getProjectEmbeddingSnapshot2(identity) : undefined;
-    const embedIdentity = snapshot ? JSON.stringify([
-      snapshot.providerIdentity,
-      snapshot.chunkModelId,
-      snapshot.runtimeFingerprint
-    ]) : "off";
-    if (autoEmbedIdentityBySession.get(sessionId) !== embedIdentity)
-      invalidateAutoEmbedSession(sessionId);
-    if (autoEmbedAttemptedBySession.has(sessionId) || embedPauseBySession.has(sessionId))
+    const projectIdentity = resolveProjectIdentityForSession(directory, deps.allowHomeProject);
+    if (!projectIdentity)
       return;
-    autoEmbedAttemptedBySession.add(sessionId);
-    autoEmbedIdentityBySession.set(sessionId, embedIdentity);
-    (async () => {
-      try {
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        if (isEmbeddingHostBusy2()) {
-          invalidateAutoEmbedSession(sessionId);
-          return;
-        }
+    maybeAutoEmbedSessionBackfill({
+      db: deps.db,
+      projectIdentity,
+      ensureRegistered: async () => {
         await ensureProjectRegisteredFromOpenCodeDirectory(directory, deps.db);
-        const project = resolveProjectIdentityForSession(directory, deps.allowHomeProject);
-        if (!project) {
-          invalidateAutoEmbedSession(sessionId);
-          return;
-        }
-        const coverage = await getAutoEmbeddingSessionCoverage2(deps.db, project, sessionId);
-        if (!coverage.enabled) {
-          invalidateAutoEmbedSession(sessionId);
-          return;
-        }
-        if (coverage.total <= coverage.embedded)
-          return;
-        await runEmbedHistoryDrain(deps, sessionId, { silent: true });
-      } catch (error) {
-        log2("[magic-context] auto-embed drain failed:", error);
+        deps.onDirectoryResolved?.(sessionId, directory);
       }
-    })();
+    }, sessionId);
   };
 }