@cortexkit/pi-magic-context 0.49.19 → 0.49.21

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   log2,
   sessionLog2,
   flushLogger2
-} from "./index-7bqrfyny.js";
+} from "./index-fgs78jyd.js";
 import {
   COMPACTION_ENABLED_PATH,
   isDreamerRunnable,
@@ -249,7 +249,7 @@ import {
   registerTodoStateLifecycle,
   syncCtxMemoryToolEnabled,
   registerMagicContextTools
-} from "./index-ek9zvs4f.js";
+} from "./index-w6r3ggnp.js";
 import"./index-4knyh1kt.js";
 import {
   canonicalModelIdentity,
@@ -267,7 +267,7 @@ import {
   DEFAULT_HISTORIAN_TIMEOUT_MS,
   DREAM_TASK_PROMOTION_DEFAULTS,
   LIVE_RELOAD_CONFIG_PATHS
-} from "./index-bxmf4dhr.js";
+} from "./index-ccanzg8p.js";
 import {
   FAIL_CLOSED_DOCTOR_COMMAND,
   formatFailClosedBlockingMessage,
@@ -290,7 +290,7 @@ import {
   openCurrentDatabase,
   openDatabaseAsync,
   closeDatabase
-} from "./index-sqt2haap.js";
+} from "./index-dbgg6hsf.js";
 import {
   pruneMissingProjectIdentities,
   setHomeProjectPermission,
@@ -302,7 +302,7 @@ import {
   resolveProjectIdentityForSession,
   beginBootQuietPeriod,
   scheduleAfterBootQuiet
-} from "./index-g7p75667.js";
+} from "./index-hxp6q5f8.js";
 import {
   detectThinkingBindingMismatch,
   detectLatestTurnThinkingMismatch,
@@ -396,6 +396,7 @@ import {
   addProcessedImageStrippedIds,
   getPendingCompactionMarkerState,
   getCompactionMarkerHealth,
+  loadPostprocessReplaySnapshot,
   clearPendingCompactionMarkerStateIf,
   getPendingPiCompactionMarkerState,
   setPendingPiCompactionMarkerState,
@@ -462,7 +463,7 @@ import {
   getRawSessionTagKeysThrough2,
   getLegacyProtectedTailStartOrdinal2,
   readSessionChunk2
-} from "./index-wveb51es.js";
+} from "./index-gqjxy2p7.js";
 import {
   UNKNOWN_FIT_RATIO,
   hasMeasuredDecisionCalibration,
@@ -549,7 +550,7 @@ import {
   getToolTagNumberByOwner2,
   getNullOwnerToolTag2,
   adoptNullOwnerToolTag2
-} from "./index-rhprywn6.js";
+} from "./index-n8e5e9fp.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -561,11 +562,12 @@ import {
   estimateTokens,
   estimateFixedPromptTokens,
   normalizeText
-} from "./index-1kcfwk9c.js";
+} from "./index-my0dn413.js";
 import {
   inRootAsyncContext2,
   Database2,
   getSqliteDatabasePath2,
+  withSqliteTurnDeadline2,
   withSqliteBackgroundWriter2,
   withSqliteTransformPass2,
   withoutSqliteTransformPass2,
@@ -574,7 +576,7 @@ import {
   isTransientSqliteError2,
   withAsyncPrivilegedWriter2,
   indexCoordinationInput2
-} from "./index-rrwv9y2k.js";
+} from "./index-2qtx0q6h.js";
 import {
   stableStringify,
   closeQuietly,
@@ -582,14 +584,15 @@ import {
   observeTemporalDecisions,
   freezeTemporalDecisions,
   tagIdentityRevisionKey
-} from "./index-jrap43gc.js";
+} from "./index-w1avzkdt.js";
 import {
   piHarnessKindFromExecutable
-} from "./index-apgwdby5.js";
+} from "./index-n4wyxcgr.js";
 import {
   BoundedSessionMap,
   LkgRecoveryFenceError,
   clearLkgFenceProcessState,
+  takeLkgRecoveryLockSweepPage,
   lkgFenceRequiresRebuild,
   lkgRecoveryFenceUnclean,
   ownsLkgDirtyFence,
@@ -611,7 +614,7 @@ import {
   indexSingleMessage2,
   indexMessagesAfterOrdinal2,
   sweepOrphanedOpenCodeMessageIndexesCooperatively2
-} from "./index-ym6nh2gk.js";
+} from "./index-wgmhk91m.js";
 import {
   resolveOpenCodeDbPath,
   assertOpenCodeStoreGeneration,
@@ -621,24 +624,27 @@ import {
   claimOpenCodeDbDiagnosticOnce
 } from "./index-8976mezv.js";
 import"./index-399p688g.js";
+import {
+  createWorkerShutdown
+} from "./index-54wmg4rj.js";
 import {
   runSessionWarmupWorker,
   RAW_SUMMARY_TEXT_MAX_CHARS2
-} from "./index-vktahpdj.js";
+} from "./index-at6py2k3.js";
 import {
   formatSynapseLaneDescriptor
-} from "./index-d8gc0112.js";
-import"./index-yygsh681.js";
+} from "./index-gwxaz0z5.js";
+import"./index-579m1751.js";
 import {
-  buildCanonicalChunkTextFromFts,
-  buildCompartmentSummaryFallbackText,
-  canonicalizeInMemoryChunkTextForEmbedding,
-  chunkCanonicalText,
-  chunkEmbeddingWindowsAreCurrent,
-  replaceCompartmentChunkEmbeddings,
-  deleteChunkEmbedBackoffForSession,
-  chunkWindowSourceKey
-} from "./index-xnch62s6.js";
+  buildCanonicalChunkTextFromFts2,
+  buildCompartmentSummaryFallbackText2,
+  canonicalizeInMemoryChunkTextForEmbedding2,
+  chunkCanonicalText2,
+  chunkEmbeddingWindowsAreCurrent2,
+  replaceCompartmentChunkEmbeddings2,
+  deleteChunkEmbedBackoffForSession2,
+  chunkWindowSourceKey2
+} from "./index-vx6f7wff.js";
 import {
   recordSessionProjectIdentity,
   GIT_SWEEP_LEASE_RENEWAL_MS,
@@ -647,7 +653,7 @@ import {
   markGitSweepSuccessAndRelease,
   parkGitSweepNonIndexable,
   releaseGitSweepLease
-} from "./index-svgkv4g2.js";
+} from "./index-j3pz3a1b.js";
 import {
   embedPauseBySession,
   embedRunStateBySession,
@@ -673,7 +679,7 @@ import {
   embedSessionCompartmentChunks2,
   getEmbeddingCoverageStatus2,
   getAutoEmbeddingSessionCoverage2
-} from "./index-vmcgew7x.js";
+} from "./index-w1twp2kp.js";
 import {
   rememberV1HiddenRun
 } from "./index-6x556c2q.js";
@@ -688,7 +694,7 @@ import {
   expandWorkspaceIdentitySetWithAliases,
   sourceNameForMemory,
   computeWorkspaceEpochFingerprint
-} from "./index-msqrs4nf.js";
+} from "./index-3c3ztwgc.js";
 import {
   configureContextDatabasePragmas2
 } from "./index-fapenpch.js";
@@ -738,7 +744,7 @@ import {
   normalizeVerificationFiles,
   indexCommitsForProject,
   embedUnembeddedCommits
-} from "./index-58mj0dzc.js";
+} from "./index-ftvm2acc.js";
 import {
   setEmbeddingSessionBusy2,
   isEmbeddingHostBusy2
@@ -762,18 +768,20 @@ import {
   setMemoryClassification2,
   archiveMemory2,
   getMemoryCountsByStatus2
-} from "./index-e1rza8gp.js";
+} from "./index-29nw7n1r.js";
 import {
   invalidateMemory2
 } from "./index-yhzhdp3m.js";
 import {
   pushNotification2
 } from "./index-q1yc6bs0.js";
-import"./index-2mmy81qt.js";
+import {
+  getCachedLocalEmbeddingPooling
+} from "./index-wqpjhx1p.js";
 import {
   cosineSimilarity
-} from "./index-z2rkv0mb.js";
-import"./index-qpq6w67c.js";
+} from "./index-pe5gz5c4.js";
+import"./index-6wdwv3a6.js";
 import {
   DREAMER_PRIMER_INVESTIGATOR_ALLOWED_TOOLS,
   buildHiddenAgentRegistrations,
@@ -786,6 +794,10 @@ import {
   SUBAGENT_OUTPUT_CEILING_ENV2
 } from "./index-fa485mqs.js";
 import {
+  PI_CONTEXT_BUDGET,
+  PiContextDeadlineError,
+  PiContextSupersededError,
+  PiContextBudget,
   PiTagHydrationError,
   getPiTagSnapshotView,
   getPiActiveTagSnapshotView,
@@ -795,10 +807,10 @@ import {
   drainPiTagSnapshotSession,
   assertPiTagSnapshotReady,
   ensurePiTagSnapshotReady
-} from "./index-rc1dez8m.js";
-import"./index-f18ec69t.js";
+} from "./index-5j6vwg4z.js";
+import"./index-jn44h81p.js";
 import"./index-1cvyaw9a.js";
-import"./index-dtp1efvf.js";
+import"./index-st4gwt64.js";
 import {
   __toESM
 } from "./index-22jkk6wg.js";
@@ -814,7 +826,7 @@ import {
 import {
   logSlowWriteTransaction,
   WriteTransactionSteps
-} from "./index-d4dt19md.js";
+} from "./index-hqw0rt9k.js";
 import {
   setStoragePrivatePermissionEnforcement,
   ensureStorageDirectorySync,
@@ -1207,6 +1219,9 @@ function resolveHarnessBlock(container, harness) {
   const selected = harness === "omp" ? container?.omp ?? container?.pi : container?.[harness];
   return asRecord(selected);
 }
+function sourceHarness(container, harness) {
+  return harness === "omp" && container?.omp == null ? "pi" : harness;
+}
 function normalizeModelEntry(entry, harness) {
   if (typeof entry === "string") {
     const model = readString(entry);
@@ -1253,13 +1268,19 @@ function resolveHistorianModel(config, harness) {
   const block = resolveHarnessBlock(historian, harness);
   if (!block)
     return { fallbacks: [] };
+  const source = `historian.${sourceHarness(historian, harness)}`;
+  const primary = resolvePrimaryEntry({
+    entry: block.model,
+    defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
+    harness
+  });
+  const fallbacks = resolveFallbackEntries(block.fallback_models, harness);
   return {
-    primary: resolvePrimaryEntry({
-      entry: block.model,
-      defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
-      harness
-    }),
-    fallbacks: resolveFallbackEntries(block.fallback_models, harness)
+    primary: primary ? { ...primary, sourceConfigKey: `${source}.model` } : undefined,
+    fallbacks: fallbacks.map((entry) => ({
+      ...entry,
+      sourceConfigKey: `${source}.fallback_models`
+    }))
   };
 }
 function resolveDreamerTaskModel(args) {
@@ -1278,15 +1299,25 @@ function resolveDreamerTaskModel(args) {
   const taskQualifier = taskBlock?.[args.harness === "opencode" ? "variant" : "thinking_level"];
   const harnessQualifier = harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ?? normalizeModelEntry(harnessBlock.model, args.harness)?.qualifier;
   const taskHasModel = taskBlock !== undefined && hasOwn(taskBlock, "model");
+  const taskHasFallbacks = taskBlock !== undefined && hasOwn(taskBlock, "fallback_models");
   const primarySource = taskHasModel ? taskBlock?.model : harnessBlock.model;
-  const fallbackSource = taskBlock !== undefined && hasOwn(taskBlock, "fallback_models") ? taskBlock.fallback_models : harnessBlock.fallback_models;
+  const fallbackSource = taskHasFallbacks ? taskBlock?.fallback_models : harnessBlock.fallback_models;
+  const source = `dreamer.${sourceHarness(dreamer, args.harness)}`;
+  const primary = resolvePrimaryEntry({
+    entry: primarySource,
+    defaultQualifier: taskQualifier ?? harnessQualifier,
+    harness: args.harness
+  });
+  const fallbacks = resolveFallbackEntries(fallbackSource, args.harness);
   return {
-    primary: resolvePrimaryEntry({
-      entry: primarySource,
-      defaultQualifier: taskQualifier ?? harnessQualifier,
-      harness: args.harness
-    }),
-    fallbacks: resolveFallbackEntries(fallbackSource, args.harness),
+    primary: primary ? {
+      ...primary,
+      sourceConfigKey: taskHasModel ? `${source}.tasks.${args.task}.model` : `${source}.model`
+    } : undefined,
+    fallbacks: fallbacks.map((entry) => ({
+      ...entry,
+      sourceConfigKey: taskHasFallbacks ? `${source}.tasks.${args.task}.fallback_models` : `${source}.fallback_models`
+    })),
     schedule: readString(schedulingTask?.schedule),
     timeoutMinutes: typeof taskBlock?.timeout_minutes === "number" ? taskBlock.timeout_minutes : undefined,
     promotionThreshold: typeof schedulingTask?.promotion_threshold === "number" ? schedulingTask.promotion_threshold : undefined
@@ -1306,6 +1337,7 @@ function buildDreamTaskRuntimeConfigs(dreamer, harness, language, smartNotesEnab
       schedule: resolved.schedule ?? "",
       model: resolved.primary,
       fallbackModels: resolved.fallbacks,
+      modelConfigKey: resolved.primary?.sourceConfigKey ?? resolved.fallbacks[0]?.sourceConfigKey,
       thinkingLevel: harness === "pi" ? resolved.primary?.qualifier : undefined,
       language,
       timeoutMinutes: resolved.timeoutMinutes ?? 20,
@@ -3520,7 +3552,7 @@ function startHostStallProfilerSwitch() {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.49.19",
+  version: "0.49.21",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -3569,7 +3601,7 @@ var package_default = {
     "comment-json": "^5.0.0",
     "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c",
     "quickjs-emscripten": "^0.32.0",
-    zod: "^4.1.8"
+    zod: "^4.6.6"
   },
   optionalDependencies: {
     "onnxruntime-node": "1.30.0",
@@ -3585,9 +3617,12 @@ var package_default = {
     "@types/bun": "^1.3.10",
     "@types/node": "^22.20.0",
     "omp-coding-agent-1812": "npm:@oh-my-pi/pi-coding-agent@18.12.3",
+    "omp-coding-agent-18126": "npm:@oh-my-pi/pi-coding-agent@18.12.6",
+    "omp-pi-ai-171": "npm:@oh-my-pi/pi-ai@17.1.7",
     "omp-pi-ai-1889": "npm:@oh-my-pi/pi-ai@18.8.9",
     "omp-pi-ai-1811": "npm:@oh-my-pi/pi-ai@18.11.3",
     "omp-pi-ai-1812": "npm:@oh-my-pi/pi-ai@18.12.3",
+    "omp-pi-ai-18126": "npm:@oh-my-pi/pi-ai@18.12.6",
     "pi-agent-core-087": "npm:@earendil-works/pi-agent-core@0.87.1",
     "pi-ai-086": "npm:@earendil-works/pi-ai@0.86.0",
     "pi-ai-087": "npm:@earendil-works/pi-ai@0.87.1",
@@ -4961,7 +4996,7 @@ async function promptWithTimeout(client, args, timeoutMs, signal, transport, fir
     if (!activity.monitored || activity.received)
       return;
     silent = true;
-    controller.abort();
+    controller.abort(new ModelProducedNoOutputError(firstOutputTimeoutMs));
   }, firstOutputTimeoutMs) : undefined;
   const timeoutError = () => silent && firstOutputTimeoutMs !== undefined ? new ModelProducedNoOutputError(firstOutputTimeoutMs) : new Error(`prompt timed out after ${timeoutMs}ms`);
   const onExternalAbort = () => controller.abort();
@@ -5301,7 +5336,7 @@ async function promptSyncWithValidatedOutputRetry(client, args, options) {
       throwWithPromptFailure(failure.error, failedAttempts, args, timeoutMs, options.transport);
     }
     if (!cooledPrimary && !quota)
-      log2(`[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(failure.error)}; trying ${fallbacks.length} fallback(s)`);
+      log2(`[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(failure.error)}; ${fallbacks.length} fallback(s) configured, subject to remaining budget`);
   }
   for (let i = 0;i < fallbacks.length; i += 1) {
     const fallback = toModelEntry(fallbacks[i]);
@@ -5374,6 +5409,152 @@ function normalizeSDKResponse(response, fallback, options) {
   return fallback;
 }
 // ../plugin/src/features/magic-context/subagent-token-capture.ts
+var warnedUnknownModels = new Set;
+var loggedModelReroutes = new Set;
+var MAX_SUBAGENT_INVOCATION_ERROR_CHARS = 1000;
+var invocationErrorDetails = new WeakMap;
+function annotateSubagentInvocationError(error, details) {
+  if (error && typeof error === "object") {
+    const previous = invocationErrorDetails.get(error) ?? {};
+    invocationErrorDetails.set(error, {
+      ...previous,
+      ...details,
+      hostError: details.hostError ?? previous.hostError
+    });
+  }
+  return error;
+}
+function errorDetailsOf(error) {
+  const seen = new Set;
+  const visit = (value, depth) => {
+    if (!value || typeof value !== "object" || depth > 4 || seen.has(value))
+      return {};
+    seen.add(value);
+    const direct = invocationErrorDetails.get(value) ?? {};
+    const record = value;
+    const nested = visit(record.hostError, depth + 1);
+    const cause = visit(record.cause, depth + 1);
+    return {
+      ...cause,
+      ...nested,
+      ...direct,
+      hostError: direct.hostError ?? nested.hostError ?? cause.hostError ?? record.hostError
+    };
+  };
+  return visit(error, 0);
+}
+function modelRef(value) {
+  const reference = typeof value === "string" ? value : value?.model;
+  return typeof reference === "string" && reference.trim().length > 0 ? reference.trim() : undefined;
+}
+function splitModelRef(value) {
+  if (!value)
+    return { providerId: null, modelId: null };
+  const slash = value.indexOf("/");
+  return slash > 0 && slash < value.length - 1 ? { providerId: value.slice(0, slash), modelId: value.slice(slash + 1) } : { providerId: null, modelId: value };
+}
+function cleanOneLine(value) {
+  const oneLine = sanitizeDiagnosticText(value).replaceAll("\r", " ").replaceAll(`
+`, " ").replaceAll("\t", " ").replace(/\s+/g, " ").trim();
+  return oneLine.length <= MAX_SUBAGENT_INVOCATION_ERROR_CHARS ? oneLine : `${oneLine.slice(0, MAX_SUBAGENT_INVOCATION_ERROR_CHARS - 1)}…`;
+}
+function recordMessage(error) {
+  if (typeof error === "string")
+    return error;
+  if (!error || typeof error !== "object")
+    return String(error ?? "");
+  const record = error;
+  const data = record.data && typeof record.data === "object" ? record.data : undefined;
+  const message = typeof data?.message === "string" ? data.message : typeof record.message === "string" ? record.message : typeof record.description === "string" ? record.description : "";
+  const name = typeof record.name === "string" ? record.name : typeof record.type === "string" ? record.type : "";
+  return [name, message].filter(Boolean).join(": ") || "The host reported an error without a message.";
+}
+function modelNotFoundDetail(error, attemptedModel) {
+  const seen = new Set;
+  const visit = (value, depth) => {
+    if (typeof value === "string") {
+      const modelMatch = value.match(/model not found:\s*(.+?)(?=(?:\.?\s*did you mean|$))/i);
+      if (!modelMatch)
+        return null;
+      const model = modelMatch[1].trim().replace(/[.,;(]+$/, "");
+      const suggestion = value.match(/did you mean:?\s*\(?\s*([^?);]+)/i)?.[1]?.trim();
+      const message = `Model not found: ${model}${suggestion ? ` (did you mean ${suggestion}?)` : ""}`;
+      return { model, ...suggestion ? { suggestion } : {}, message };
+    }
+    if (!value || typeof value !== "object" || depth > 4 || seen.has(value))
+      return null;
+    seen.add(value);
+    const record = value;
+    const data = record.data && typeof record.data === "object" ? record.data : undefined;
+    const modelRecord = data?.model ?? record.model;
+    const modelId = (typeof data?.modelID === "string" ? data.modelID : undefined) ?? (typeof modelRecord?.modelID === "string" ? modelRecord.modelID : undefined) ?? (typeof modelRecord?.id === "string" ? modelRecord.id : undefined);
+    const providerId = (typeof data?.providerID === "string" ? data.providerID : undefined) ?? (typeof modelRecord?.providerID === "string" ? modelRecord.providerID : undefined);
+    const suggestions = data?.suggestions;
+    const suggestion = Array.isArray(suggestions) && typeof suggestions[0] === "string" ? suggestions[0] : typeof data?.suggestion === "string" ? data.suggestion : undefined;
+    const rawMessage = recordMessage(value);
+    const fromMessage = visit(rawMessage, depth + 1);
+    if (fromMessage)
+      return fromMessage.suggestion || !suggestion ? fromMessage : {
+        ...fromMessage,
+        suggestion,
+        message: `Model not found: ${fromMessage.model} (did you mean ${suggestion}?)`
+      };
+    const name = `${String(record.name ?? "")} ${String(record.type ?? "")}`;
+    if (/ProviderModelNotFoundError|model not found/i.test(name) && modelId) {
+      const model = providerId ? `${providerId}/${modelId}` : modelId;
+      const detail = `Model not found: ${model}${suggestion ? ` (did you mean ${suggestion}?)` : ""}`;
+      return { model, ...suggestion ? { suggestion } : {}, message: detail };
+    }
+    for (const key of ["data", "error", "cause", "hostError"]) {
+      const match = visit(record[key], depth + 1);
+      if (match)
+        return match;
+    }
+    return null;
+  };
+  const found = visit(error, 0);
+  if (!found && attemptedModel && (typeof error === "string" && /ProviderModelNotFoundError/i.test(error) || error !== null && typeof error === "object" && /ProviderModelNotFoundError/i.test(`${String(error.name ?? "")} ${String(error.type ?? "")}`))) {
+    return { model: attemptedModel, message: `Model not found: ${attemptedModel}` };
+  }
+  return found;
+}
+function hostLabel(harness) {
+  switch (harness) {
+    case "opencode2":
+      return "OpenCode 2";
+    case "opencode":
+      return "OpenCode";
+    case "pi":
+      return "Pi";
+    case "omp":
+      return "Oh My Pi";
+  }
+}
+function invocationErrorText(input, details, attemptedModel) {
+  if (input.error == null && input.hostError == null && details.hostError == null)
+    return null;
+  const rawHostError = input.hostError ?? details.hostError;
+  const modelError = modelNotFoundDetail(rawHostError ?? input.error, attemptedModel);
+  if (modelError) {
+    return cleanOneLine(`No reply: ${hostLabel(input.harness)} refused the model: ${modelError.message}`);
+  }
+  if (rawHostError != null) {
+    return cleanOneLine(`No reply: ${hostLabel(input.harness)} reported a child-session error: ${recordMessage(rawHostError)}`);
+  }
+  return cleanOneLine(describeError(input.error).brief);
+}
+function warnUnknownModel(input, details, attemptedModel, modelConfigKey) {
+  if (!attemptedModel)
+    return;
+  const issue = modelNotFoundDetail(input.hostError ?? details.hostError ?? input.error, attemptedModel);
+  if (!issue || warnedUnknownModels.has(attemptedModel))
+    return;
+  if (!modelConfigKey)
+    return;
+  warnedUnknownModels.add(attemptedModel);
+  const suggestion = issue.suggestion ? `provider suggests ${cleanOneLine(issue.suggestion)}` : "provider gave no model suggestion";
+  log2(`[magic-context] WARNING: ${modelConfigKey} configured ${attemptedModel}, but ${hostLabel(input.harness)} does not know that model; ${suggestion}`);
+}
 function asNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
@@ -5444,8 +5625,11 @@ function sumTokensFromChildMessages(messages) {
 function findLastAssistantModel(messages) {
   for (let index = messages.length - 1;index >= 0; index -= 1) {
     const message = messages[index];
-    if (isAssistantMessage(message))
-      return modelFromMessage(message);
+    if (isAssistantMessage(message)) {
+      const model = modelFromMessage(message);
+      if (model.providerId || model.modelId)
+        return model;
+    }
   }
   return { providerId: null, modelId: null };
 }
@@ -5454,10 +5638,25 @@ function recordChildInvocation(input) {
     return null;
   const tokens = input.tokens ?? sumTokensFromChildMessages(input.messages ?? []);
   const observedModel = findLastAssistantModel(input.messages ?? []);
+  const details = errorDetailsOf(input.error);
+  const attemptedModel = details.attemptedModel ?? modelRef(input.attemptedModel);
+  const attemptConfig = [input.attemptedModel, ...input.configuredModels ?? []].find((candidate) => modelRef(candidate) === attemptedModel);
+  const modelConfigKey = details.modelConfigKey ?? input.modelConfigKey ?? (typeof attemptConfig === "object" ? attemptConfig?.sourceConfigKey : undefined);
+  const attemptedParts = splitModelRef(attemptedModel);
   const model = {
-    providerId: input.providerId ?? observedModel.providerId,
-    modelId: input.modelId ?? observedModel.modelId
+    providerId: observedModel.providerId ?? input.providerId ?? attemptedParts.providerId,
+    modelId: observedModel.modelId ?? input.modelId ?? attemptedParts.modelId
   };
+  const reportedModelRef = observedModel.providerId && observedModel.modelId ? `${observedModel.providerId}/${observedModel.modelId}` : input.providerId && input.modelId ? `${input.providerId}/${input.modelId}` : undefined;
+  if (attemptedModel && reportedModelRef && attemptedModel !== reportedModelRef && (observedModel.providerId !== null || input.providerId !== undefined)) {
+    const rerouteKey = `${input.harness}\x00${attemptedModel}\x00${reportedModelRef}`;
+    if (!loggedModelReroutes.has(rerouteKey)) {
+      loggedModelReroutes.add(rerouteKey);
+      sessionLog2(input.parentSessionId, `subagent model rerouted by host: attempted=${attemptedModel} reported=${reportedModelRef}`);
+    }
+  }
+  warnUnknownModel(input, details, attemptedModel, modelConfigKey);
+  const errorText = invocationErrorText(input, details, attemptedModel);
   try {
     return recordSubagentInvocation(input.db, {
       sessionId: input.parentSessionId,
@@ -5473,7 +5672,7 @@ function recordChildInvocation(input) {
       outputTokens: tokens.output,
       cacheReadTokens: tokens.cacheRead,
       cacheWriteTokens: tokens.cacheWrite,
-      error: input.error ? describeError(input.error).brief : null,
+      error: errorText,
       parentInvocationId: input.parentInvocationId ?? null
     });
   } catch (error) {
@@ -5501,6 +5700,17 @@ var HOST_SESSION_ERROR = Symbol("promptAsyncHostSessionError");
 function isHostSessionError(error) {
   return error !== null && typeof error === "object" && error[HOST_SESSION_ERROR] === true;
 }
+function hostSessionErrorOf(error) {
+  if (!isHostSessionError(error))
+    return;
+  return error.hostError;
+}
+function requestModelRef(request) {
+  const model = request.body?.model;
+  if (model && typeof model.providerID === "string" && typeof model.modelID === "string")
+    return `${model.providerID}/${model.modelID}`;
+  return;
+}
 function supportsPromptAsync(client) {
   const session = sessionApi(client);
   return typeof session?.promptAsync === "function" && typeof session?.status === "function" && typeof session?.messages === "function";
@@ -5655,11 +5865,29 @@ async function promptAsyncAndWaitForIdle(client, request, options = {}) {
   const initialBaseline = new Set(completionBaseline);
   activeSessionErrors.set(sessionId, undefined);
   try {
-    const sent = await session.promptAsync?.(request);
+    let sent;
+    try {
+      sent = await session.promptAsync?.(request);
+    } catch (error) {
+      annotateSubagentInvocationError(error, {
+        attemptedModel: requestModelRef(request),
+        modelConfigKey: options.modelConfigKey,
+        hostError: error
+      });
+      throw error;
+    }
     if (sent && typeof sent === "object" && "error" in sent) {
       const rejection = sent.error;
       if (rejection) {
-        throw new Error(`prompt_async was rejected: ${describeRejection(rejection)}`);
+        const error = new Error(`prompt_async was rejected: ${describeRejection(rejection)}`, {
+          cause: rejection
+        });
+        annotateSubagentInvocationError(error, {
+          attemptedModel: requestModelRef(request),
+          modelConfigKey: options.modelConfigKey,
+          hostError: rejection
+        });
+        throw error;
       }
     }
     let sentAt = Date.now();
@@ -5674,7 +5902,13 @@ async function promptAsyncAndWaitForIdle(client, request, options = {}) {
         Object.assign(error, {
           name: "DreamerProviderOutputFailureError",
           transient: true,
-          [HOST_SESSION_ERROR]: true
+          [HOST_SESSION_ERROR]: true,
+          hostError
+        });
+        annotateSubagentInvocationError(error, {
+          attemptedModel: requestModelRef(request),
+          modelConfigKey: options.modelConfigKey,
+          hostError
         });
         throw error;
       }
@@ -9238,6 +9472,8 @@ function resolveHiddenCompletionExecutor(executor, client, db, directory, entryP
 }
 function createV1HiddenCompletionExecutor(client, db, directory) {
   const historianChildren = new Set;
+  const hostErrors = new Map;
+  const runIdentities = new Map;
   return {
     capabilities: { tools: true, harness: "opencode" },
     async open(run) {
@@ -9254,23 +9490,49 @@ function createV1HiddenCompletionExecutor(client, db, directory) {
         preferResponseOnMissingData: true
       });
       const id = typeof created?.id === "string" ? created.id : "";
-      if (id)
+      if (id) {
         rememberV1HiddenRun(id, run);
+        runIdentities.set(id, run);
+      }
       if (id && run.kind !== "dreamer-task") {
         historianChildren.add(id);
         rememberHistorianOutputCap(id, run.maxOutputTokens);
       }
-      return { id, childSessionId: id || undefined };
+      const configured = toModelEntry(run.model);
+      return {
+        id,
+        childSessionId: id || undefined,
+        ...configured ? { attemptedModel: configured.model } : {},
+        ...configured?.sourceConfigKey ? { modelConfigKey: configured.sourceConfigKey } : {}
+      };
     },
     async attempt(handle, request) {
       if (!client)
         throw new Error("Hidden completion client is unavailable");
+      const identity = runIdentities.get(handle.id);
+      const requestedModel = request.body?.model;
+      const requestedRef = requestedModel && typeof requestedModel.providerID === "string" && typeof requestedModel.modelID === "string" ? `${requestedModel.providerID}/${requestedModel.modelID}` : undefined;
+      const matchingConfigured = (identity?.configuredModels ?? []).map(toModelEntry).find((entry) => entry?.model === requestedRef);
+      const configured = matchingConfigured ?? (requestedRef && identity?.model && toModelEntry(identity.model)?.model === requestedRef ? toModelEntry(identity.model) : toModelEntry(identity?.model));
+      handle.attemptedModel = requestedRef ?? configured?.model ?? handle.attemptedModel;
+      handle.modelConfigKey = configured?.sourceConfigKey ?? handle.modelConfigKey;
       if (supportsPromptAsync(client)) {
         try {
-          await promptAsyncAndWaitForIdle(client, request);
+          await promptAsyncAndWaitForIdle(client, request, {
+            modelConfigKey: handle.modelConfigKey
+          });
         } catch (error) {
-          if (historianChildren.has(handle.id) && isHostSessionError(error))
-            return;
+          if (isHostSessionError(error)) {
+            const hostError = hostSessionErrorOf(error);
+            hostErrors.set(handle.id, hostError);
+            annotateSubagentInvocationError(error, {
+              attemptedModel: handle.attemptedModel,
+              modelConfigKey: handle.modelConfigKey,
+              hostError
+            });
+            if (historianChildren.has(handle.id))
+              return;
+          }
           throw error;
         }
         return;
@@ -9288,9 +9550,16 @@ function createV1HiddenCompletionExecutor(client, db, directory) {
         preferResponseOnMissingData: true
       });
       const assistantFailure = extractLatestAssistantFailure(messages);
+      const hostError = hostErrors.get(handle.id);
       if (assistantFailure) {
         const finish = assistantFailure.finish ? ` (finish=${assistantFailure.finish})` : "";
-        throw new Error(`Historian host recorded an assistant error${finish}: ${describeAssistantFailure(assistantFailure.error)}`);
+        const error = new Error(`Historian host recorded an assistant error${finish}: ${describeAssistantFailure(assistantFailure.error)}`, hostError === undefined ? undefined : { cause: hostError });
+        annotateSubagentInvocationError(error, {
+          attemptedModel: handle.attemptedModel,
+          modelConfigKey: handle.modelConfigKey,
+          hostError
+        });
+        throw error;
       }
       const text = extractLatestAssistantText(messages);
       const latest = Array.isArray(messages) ? messages.filter((message) => isRecord(message) && isRecord(message.info) && message.info.role === "assistant").sort((left, right) => historianMessageCreatedAt(right) - historianMessageCreatedAt(left))[0] : undefined;
@@ -9301,13 +9570,18 @@ function createV1HiddenCompletionExecutor(client, db, directory) {
         reasoning: text ? null : extractLatestHistorianReasoning(messages),
         lengthCapped: hasLengthCappedOutput(messages),
         usage: sumTokensFromChildMessages(messages),
-        tokenLog: runTokenLog(info.tokens, undefined, info.finish ?? info.finish_reason ?? info.finishReason)
+        tokenLog: runTokenLog(info.tokens, undefined, info.finish ?? info.finish_reason ?? info.finishReason),
+        attemptedModel: handle.attemptedModel,
+        modelConfigKey: handle.modelConfigKey,
+        ...hostError === undefined ? {} : { hostError }
       };
     },
     async close(handle, settlement) {
       if (handle?.id) {
         rememberV1HiddenRun(handle.id, undefined);
         historianChildren.delete(handle.id);
+        hostErrors.delete(handle.id);
+        runIdentities.delete(handle.id);
         forgetHistorianOutputCap(handle.id);
       }
       if (!client)
@@ -9462,7 +9736,8 @@ async function runHistorianPrompt(args) {
     if (invocationRecorded)
       return null;
     invocationRecorded = true;
-    const actualModelRef = completion?.providerId && completion.modelId ? `${completion.providerId}/${completion.modelId}` : null;
+    const configuredModel = toModelEntry(modelOverride);
+    const actualModelRef = completion?.providerId && completion.modelId ? `${completion.providerId}/${completion.modelId}` : handle?.attemptedModel ?? configuredModel?.model ?? null;
     const usedConfiguredFallback = actualModelRef !== null && (fallbackModels ?? []).some((candidate) => toModelEntry(candidate)?.model === actualModelRef);
     return recordChildInvocation({
       db: openDatabase(),
@@ -9478,6 +9753,10 @@ async function runHistorianPrompt(args) {
         providerId: completion.providerId,
         modelId: completion.modelId
       } : {},
+      attemptedModel: handle?.attemptedModel ?? modelOverride,
+      configuredModels: fallbackModels,
+      modelConfigKey: handle?.modelConfigKey ?? configuredModel?.sourceConfigKey,
+      hostError: params.hostError ?? completion?.hostError,
       error: params.error,
       parentInvocationId: agentId === HISTORIAN_EDITOR_AGENT ? parentInvocationId ?? null : null
     });
@@ -9591,7 +9870,8 @@ async function runHistorianPrompt(args) {
     const invocationId = recordInvocation({
       status: emptyError ? "empty" : "completed",
       messages: completion.messages,
-      error: emptyError
+      error: emptyError,
+      hostError: completion.hostError
     });
     if (emptyError && (!reasoningResult || lengthCapped)) {
       return {
@@ -10414,7 +10694,9 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
         status: "completed",
         tokens: run.output.usage,
         providerId: run.output.providerId,
-        modelId: run.output.modelId
+        modelId: run.output.modelId,
+        attemptedModel: args.model,
+        configuredModels: args.fallbackModels
       });
     }
     stage = "apply";
@@ -10606,6 +10888,7 @@ async function runHiddenSingleShotPrompt(args) {
       });
   }).catch(() => {});
   const handle = await raceWithSignal(opening, args.signal);
+  let completion;
   args.onOpened?.(handle.id);
   let promptSettled = false;
   try {
@@ -10627,7 +10910,10 @@ async function runHiddenSingleShotPrompt(args) {
       ...args.signal ? { signal: args.signal } : {},
       fallbackModels: args.fallbackModels,
       callContext: args.callContext,
-      fetchOutput: () => args.executor.collect(handle, 50),
+      fetchOutput: async () => {
+        completion = await args.executor.collect(handle, 50);
+        return completion;
+      },
       validateOutput: (completion) => {
         const tokens = completion.tokenLog ?? runTokenLog(undefined);
         sessionLog2(args.parentSessionId ?? "dreamer", `${args.callContext} response_chars=${(completion.text ?? completion.reasoning ?? "").length} ${formatRunTokenLog(tokens)}`);
@@ -10643,6 +10929,12 @@ async function runHiddenSingleShotPrompt(args) {
     promptSettled = true;
     return { validated: run.validated, completion: run.output, childSessionId: handle.id };
   } catch (error) {
+    const configuredModel = toModelEntry(args.model);
+    annotateSubagentInvocationError(error, {
+      attemptedModel: completion?.attemptedModel ?? handle.attemptedModel ?? configuredModel?.model,
+      modelConfigKey: completion?.modelConfigKey ?? handle.modelConfigKey ?? configuredModel?.sourceConfigKey,
+      ...completion?.hostError === undefined ? {} : { hostError: completion.hostError }
+    });
     if (args.onFailureOutput) {
       let timer;
       try {
@@ -10970,6 +11262,8 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
       startedAt,
       status: params.status,
       messages: params.messages,
+      attemptedModel: args.model,
+      configuredModels: args.fallbackModels,
       error: params.error
     });
   };
@@ -11757,6 +12051,8 @@ function recordInvocation(args, startedAt, params) {
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     ...params.completion && !params.completion.messages ? {
       tokens: params.completion.usage,
       providerId: params.completion.providerId,
@@ -11997,28 +12293,35 @@ function diff(name, before, after) {
     rmSync(dir, { recursive: true, force: true });
   }
 }
-function validateDocsProposal(projectDir, output, budget, expected) {
-  if (Object.entries(expected).some(([name, value]) => docsBaseHashes(projectDir)[name] !== value))
-    throw new Error("base drifted");
+function parseDocsProposalOutput(output) {
   const match = output.match(/```json\s*([\s\S]*?)```/);
   const parsed = JSON.parse(match?.[1] ?? output);
   if (!Array.isArray(parsed))
     throw new Error("proposal must be a JSON array");
   const changes = parsed;
-  if (!changes.length)
-    throw new Error("empty proposal");
   if (changes.some((item) => !item || !FILES.includes(item.file)))
     throw new Error("unknown proposal file");
+  const seen = new Set;
+  for (const change of changes) {
+    const key = `${change.file}:${change.heading}`;
+    if (!["replace", "add", "remove"].includes(change.action) || typeof change.heading !== "string" || !/^#{1,6} [^\r\n]+$/.test(change.heading) || typeof change.text !== "string" || typeof change.reason !== "string" || !change.reason.trim() || /[\r\n]/.test(change.reason) || seen.has(key))
+      throw new Error(`invalid section change in ${change.file}`);
+    seen.add(key);
+  }
+  return changes;
+}
+function validateDocsProposal(projectDir, output, budget, expected) {
+  if (Object.entries(expected).some(([name, value]) => docsBaseHashes(projectDir)[name] !== value))
+    throw new Error("base drifted");
+  const changes = parseDocsProposalOutput(output);
+  if (!changes.length)
+    throw new Error("empty proposal");
   let tokens = 0;
   let diffs = "";
   for (const file of FILES) {
     const before = existsSync6(join8(projectDir, file)) ? readFileSync6(join8(projectDir, file), "utf8") : "";
     let after = before;
-    const seen = new Set;
     for (const change of changes.filter((item) => item.file === file)) {
-      if (!["replace", "add", "remove"].includes(change.action) || typeof change.heading !== "string" || !/^#{1,6} [^\r\n]+$/.test(change.heading) || typeof change.text !== "string" || typeof change.reason !== "string" || !change.reason.trim() || /[\r\n]/.test(change.reason) || seen.has(change.heading))
-        throw new Error(`invalid section change in ${file}`);
-      seen.add(change.heading);
       const section = sections(after).find((item) => item.heading === change.heading);
       if (change.action === "add") {
         if (section || !change.text.startsWith(`${change.heading}
@@ -13292,6 +13595,8 @@ Remember: output only the JSON object described by the system prompt.`;
       startedAt,
       status: params.status,
       messages: params.messages,
+      attemptedModel: args.model,
+      configuredModels: args.fallbackModels,
       error: params.error
     });
   };
@@ -14039,6 +14344,8 @@ async function confirmReadOnly(args, noteId, content, surfaceCondition, leaseSig
       startedAt,
       status: params.status,
       messages: params.messages,
+      attemptedModel: args.model,
+      configuredModels: args.fallbackModels,
       error: params.error
     });
   };
@@ -14953,12 +15260,14 @@ function recordInvocation2(args, startedAt, params) {
   recordChildInvocation({
     db: args.db,
     parentSessionId: args.parentSessionId,
-    harness: "opencode",
+    harness: args.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
     subagent: "dreamer",
     task: "map-memories",
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     error: params.error
   });
 }
@@ -15583,12 +15892,14 @@ function recordInvocation3(args, startedAt, params) {
   recordChildInvocation({
     db: args.db,
     parentSessionId: args.parentSessionId,
-    harness: "opencode",
+    harness: args.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
     subagent: "dreamer",
     task: "refresh-primers",
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     error: params.error
   });
 }
@@ -17162,12 +17473,14 @@ function recordInvocation4(args, startedAt, params) {
   recordChildInvocation({
     db: args.db,
     parentSessionId: args.parentSessionId,
-    harness: "opencode",
+    harness: args.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
     subagent: "dreamer",
     task: args.forceBroad ? "verify-broad" : "verify",
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     error: params.error
   });
 }
@@ -18043,6 +18356,25 @@ async function runRetrospectiveTask(config, ctx, helpers) {
   let childSessionId = null;
   let hiddenHandle = null;
   let promptSettled = false;
+  let invocationRecorded = false;
+  const recordInvocation = (status, messages, error) => {
+    if (!parent || !childSessionId || invocationRecorded)
+      return;
+    invocationRecorded = true;
+    recordChildInvocation({
+      db,
+      parentSessionId: parent,
+      harness: deps.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
+      subagent: "dreamer",
+      task: config.task,
+      startedAt: helpers.invocationStartedAt,
+      status,
+      messages,
+      attemptedModel: config.model,
+      configuredModels: config.fallbackModels,
+      error
+    });
+  };
   try {
     if (deps.hiddenCompletionExecutor) {
       hiddenHandle = await deps.hiddenCompletionExecutor.open({
@@ -18127,18 +18459,8 @@ async function runRetrospectiveTask(config, ctx, helpers) {
       return { ...run, output };
     };
     const finish = (run, watermark) => {
-      if (parent && run) {
-        recordChildInvocation({
-          db,
-          parentSessionId: parent,
-          harness: "opencode",
-          subagent: "dreamer",
-          task: config.task,
-          startedAt: helpers.invocationStartedAt,
-          status: "completed",
-          messages: run.output
-        });
-      }
+      if (run)
+        recordInvocation("completed", run.output);
       return completedWindow(watermark);
     };
     const userLines = renderGateUserLines(messages);
@@ -18231,6 +18553,7 @@ async function runRetrospectiveTask(config, ctx, helpers) {
     log2(`[dreamer] retrospective: flagged=${flagged.length} learnings=${learnings.length} memory=${applied.memoryWritten} observations=${applied.observationsInserted} dropped=${applied.observationsDropped} rejected=${applied.rejected.length}`);
     return finish(deepenRun, scan.maxScannedTs);
   } catch (error) {
+    recordInvocation(abortController.signal.aborted ? "aborted" : failedInvocationStatus(error), undefined, error);
     if (!detectOverflow(error).isOverflow)
       throw error;
     const failures = (activeOverflow?.failures ?? 0) + 1;
@@ -18302,6 +18625,25 @@ async function runAgenticTask(config, ctx, helpers) {
   let childSessionId = null;
   let promptSettled = false;
   let expiredArchived = 0;
+  let invocationRecorded = false;
+  const recordInvocation = (status, messages, error) => {
+    if (!parent || !childSessionId || invocationRecorded)
+      return;
+    invocationRecorded = true;
+    recordChildInvocation({
+      db,
+      parentSessionId: parent,
+      harness: deps.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
+      subagent: "dreamer",
+      task,
+      startedAt: invocationStartedAt,
+      status,
+      messages,
+      attemptedModel: config.model,
+      configuredModels: config.fallbackModels,
+      error
+    });
+  };
   try {
     let curateMemories;
     let curateCategory;
@@ -18390,12 +18732,17 @@ async function runAgenticTask(config, ctx, helpers) {
           callContext: `dreamer:${task}`,
           metadata: { tokenBudget: config.tokenBudget, onBudgetUpdate },
           allowEmpty: task === "curate",
+          onOpened: (sessionId) => {
+            childSessionId = sessionId;
+          },
           model: config.model,
           fallbackModels: config.fallbackModels,
           language: task === "curate" ? config.language ?? deps.language : undefined,
           timeoutMs: Math.min(Math.max(0, deadline - Date.now()), config.timeoutMinutes * 60 * 1000),
           signal: abortController.signal,
           parse: (text, completion) => {
+            if (task === "maintain-docs")
+              parseDocsProposalOutput(text);
             if (task !== "curate")
               return text;
             const memoryOperations = inspectCurateMemoryOperations(completion.messages);
@@ -18459,6 +18806,8 @@ async function runAgenticTask(config, ctx, helpers) {
             if (task !== "curate") {
               if (!text)
                 throw new Error("Dreamer returned no assistant output.");
+              if (task === "maintain-docs")
+                parseDocsProposalOutput(text);
               return text;
             }
             const memoryOperations = inspectCurateMemoryOperations(messages);
@@ -18505,21 +18854,10 @@ async function runAgenticTask(config, ctx, helpers) {
       helpers.reportProgress(curateRefused, curateRefused);
       log2(`[dreamer] curate safety summary: refused=${curateRefused}`);
     }
-    if (parent) {
-      recordChildInvocation({
-        db,
-        parentSessionId: parent,
-        harness: "opencode",
-        subagent: "dreamer",
-        task,
-        startedAt: invocationStartedAt,
-        status: "completed",
-        messages: run.output
-      });
-    }
+    recordInvocation("completed", run.output);
     if (task === "maintain-docs" && docsHashes && changes) {
       try {
-        if (run.validated === "[]") {
+        if (parseDocsProposalOutput(String(run.validated)).length === 0) {
           helpers.recordRun("completed", null, { progress: "no corrections proposed" });
           return {
             status: "completed",
@@ -18570,6 +18908,9 @@ async function runAgenticTask(config, ctx, helpers) {
         }
       } : {}
     };
+  } catch (error) {
+    recordInvocation(abortController.signal.aborted ? "aborted" : failedInvocationStatus(error), undefined, error);
+    throw error;
   } finally {
     heartbeat.stop();
     if (childSessionId)
@@ -19157,6 +19498,8 @@ var RECONCILIATION_BATCH_SIZE = 100;
 
 class MagicContextMessageIndexHeapHolder {
   reconciledSessions = new Set;
+  reconciledSnapshots = new Map;
+  stalledSessions = new Set;
   reconciliationScheduledSessions = new Set;
   clearAndReindexScheduledSessions = new Map;
   sessionLocks = new Map;
@@ -19207,18 +19550,28 @@ function logIndexingError(sessionId, action, error) {
   sessionLog2(sessionId, `message FTS async ${action} failed: ${error instanceof Error ? error.message : String(error)}`);
   log2(`[message-index-async] ${action} failed for ${sessionId}:`, error);
 }
+function logReconciliationStall(sessionId, reason) {
+  if (heapHolder.stalledSessions.has(sessionId))
+    return;
+  heapHolder.stalledSessions.add(sessionId);
+  sessionLog2(sessionId, `message FTS reconciliation stalled: ${reason}; will retry`);
+}
 async function reconcileSessionIndex(db, sessionId, readMessages) {
-  if (!await sourceReady(readMessages, sessionId))
+  if (!await sourceReady(readMessages, sessionId)) {
+    logReconciliationStall(sessionId, "raw message reader is not ready");
     return false;
+  }
   await runWithSessionLock(sessionId, async () => {
-    if (heapHolder.reconciledSessions.has(sessionId))
+    if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId))
       return;
     let fallbackSnapshot = null;
     try {
       const fullReader = typeof readMessages === "function" ? readMessages : null;
-      const finalWatermark = readMessages.getCount ? readMessages.getCount(sessionId) : (fallbackSnapshot = fullReader?.(sessionId) ?? []).length;
+      const revision = readMessages.getRevision?.(sessionId);
+      const previous = heapHolder.reconciledSnapshots.get(sessionId);
+      const finalWatermark = previous && revision === previous.revision ? previous.count : revision !== undefined && readMessages.getCountAfterRevision ? previous && revision > previous.revision ? previous.count + readMessages.getCountAfterRevision(sessionId, previous.revision, revision) : readMessages.getCountAfterRevision(sessionId, -1, revision) : readMessages.getCount ? readMessages.getCount(sessionId) : (fallbackSnapshot = fullReader?.(sessionId) ?? []).length;
       let cursor = getMessageIndexReconciliationStartOrdinal2(db, sessionId);
-      let after;
+      let after = cursor === previous?.count ? previous.after : undefined;
       while (cursor < finalWatermark) {
         const pageEnd = Math.min(finalWatermark, cursor + RECONCILIATION_BATCH_SIZE);
         const messages = readMessages.readPage ? readMessages.readPage(sessionId, cursor, RECONCILIATION_BATCH_SIZE, finalWatermark, after) : (fallbackSnapshot ?? []).filter((message) => message.ordinal > cursor && message.ordinal <= pageEnd);
@@ -19237,6 +19590,20 @@ async function reconcileSessionIndex(db, sessionId, readMessages) {
       }
       if (isMessageIndexReconciledThrough2(db, sessionId, finalWatermark)) {
         heapHolder.reconciledSessions.add(sessionId);
+        if (revision !== undefined) {
+          if (!after && finalWatermark > 0 && readMessages.readPage) {
+            const last = readMessages.readPage(sessionId, finalWatermark - 1, 1, finalWatermark).at(-1);
+            if (last?.ordinal === finalWatermark && typeof last.createdAt === "number")
+              after = { timeCreated: last.createdAt, id: last.id };
+          }
+          heapHolder.reconciledSnapshots.set(sessionId, {
+            revision,
+            count: finalWatermark,
+            after
+          });
+        }
+      } else {
+        logReconciliationStall(sessionId, `gap after ordinal ${cursor} (store count ${finalWatermark})`);
       }
     } finally {
       heapHolder.activeReconcilerBuffers.delete(sessionId);
@@ -19245,25 +19612,32 @@ async function reconcileSessionIndex(db, sessionId, readMessages) {
   return true;
 }
 function scheduleReconciliation(db, sessionId, readMessages) {
-  if (heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
+  if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
     return;
   }
   heapHolder.reconciliationScheduledSessions.add(sessionId);
   scheduleAfterBootQuiet(() => {
     defer(() => {
+      let appendedDuringReconciliation = false;
+      const previousSnapshot = heapHolder.reconciledSnapshots.get(sessionId);
       reconcileSessionIndex(db, sessionId, readMessages).then((ran) => {
-        if (ran)
+        if (ran) {
+          const snapshot = heapHolder.reconciledSnapshots.get(sessionId);
+          appendedDuringReconciliation = snapshot !== undefined && snapshot !== previousSnapshot && readMessages.getRevision !== undefined && readMessages.getRevision(sessionId) !== snapshot.revision;
           return;
+        }
         inRootAsyncContext2(() => setTimeout(() => {
           heapHolder.reconciliationScheduledSessions.delete(sessionId);
           scheduleReconciliation(db, sessionId, readMessages);
         }, PREPARE_RETRY_MS)).unref?.();
       }).catch((error) => {
-        logIndexingError(sessionId, "reconciliation", error);
+        logReconciliationStall(sessionId, error instanceof Error ? error.message : String(error));
         if (isDatabaseLockedError(error))
           inRootAsyncContext2(() => setTimeout(() => scheduleReconciliation(db, sessionId, readMessages), 1000)).unref();
       }).finally(() => {
         heapHolder.reconciliationScheduledSessions.delete(sessionId);
+        if (appendedDuringReconciliation)
+          scheduleReconciliation(db, sessionId, readMessages);
       });
     });
   });
@@ -19355,6 +19729,11 @@ async function indexSingleMessageOffThread(db, sessionId, message) {
   return result.inserted;
 }
 async function sweepOrphanedOpenCodeMessageIndexesOffThread(db, openSource, options = {}) {
+  if (getHarness2() === "opencode" || getHarness2() === "opencode2")
+    options = {
+      ...options,
+      fenceLockNames: options.fenceLockNames ?? takeLkgRecoveryLockSweepPage()
+    };
   if (getHarness2() === "opencode2")
     openSource = () => new Database2(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"), {
       readonly: true,
@@ -19391,6 +19770,8 @@ function clearSessionTracking(sessionId) {
     Atomics.store(cancellation, 0, 1);
   heapHolder.clearAndReindexScheduledSessions.delete(sessionId);
   heapHolder.reconciledSessions.delete(sessionId);
+  heapHolder.reconciledSnapshots.delete(sessionId);
+  heapHolder.stalledSessions.delete(sessionId);
   heapHolder.reconciliationScheduledSessions.delete(sessionId);
   heapHolder.sessionLocks.delete(sessionId);
   heapHolder.activeReconcilerBuffers.delete(sessionId);
@@ -20580,7 +20961,8 @@ class PiSubagentRunner {
         ...options,
         model: attempt?.model,
         thinkingLevel: attempt?.qualifier,
-        fallbackModels: undefined
+        fallbackModels: undefined,
+        accountingModelConfigKey: typeof attempt === "object" ? attempt.sourceConfigKey ?? options.accountingModelConfigKey : options.accountingModelConfigKey
       };
       const result = await this.runOnce(attemptOptions, runMode, index === 0 ? primaryModelRef : undefined);
       if (result.ok)
@@ -20635,6 +21017,8 @@ class PiSubagentRunner {
         subagent: options.accountingSubagent ?? inferAccountingSubagent(options.agent),
         task: options.accountingTask ?? null,
         startedAt: startTime,
+        attemptedModel: modelRef,
+        modelConfigKey: options.accountingModelConfigKey,
         status: result.ok ? "completed" : result.meta?.failureClass === ZEN_FREE_TIER_FAILURE ? "failed" : result.reason === "abort" ? "aborted" : result.reason === "timeout" ? "timed_out" : result.reason === "no_assistant" || result.reason === "truncated" ? "empty" : "failed",
         messages,
         providerId: hasProvider ? modelRef?.slice(0, providerSeparator) : undefined,
@@ -21184,10 +21568,11 @@ class PiSubagentRunner {
         if (settled)
           return;
         terminateChild(child);
+        const silentCut = options.signal?.reason instanceof ModelProducedNoOutputError ? options.signal.reason : undefined;
         settle({
           ok: false,
-          reason: "abort",
-          error: "pi subagent aborted by caller",
+          reason: silentCut ? "timeout" : "abort",
+          error: silentCut?.message ?? "pi subagent aborted by caller",
           durationMs: Date.now() - startTime
         });
       };
@@ -21593,6 +21978,28 @@ function terminateChild(child) {
   }
 }
 
+// src/dreamer/model-activity.ts
+function piEventShowsModelOutput(event) {
+  if (!isRecord(event))
+    return false;
+  if (event.type !== "message_update" && event.type !== "message_end")
+    return false;
+  const update = event.assistantMessageEvent;
+  if (event.type === "message_update" && isRecord(update)) {
+    if (update.type === "toolcall_start")
+      return true;
+    if (["text_delta", "thinking_delta", "toolcall_delta"].includes(String(update.type)) && typeof update.delta === "string" && update.delta.length > 0)
+      return true;
+  }
+  const message = event.message;
+  if (!isRecord(message) || message.role !== "assistant")
+    return false;
+  if (Array.isArray(message.content) && message.content.some((part) => isRecord(part) && (part.type === "toolCall" || part.type === "text" && typeof part.text === "string" && part.text.length > 0 || part.type === "thinking" && typeof part.thinking === "string" && part.thinking.length > 0)))
+    return true;
+  const usage = message.usage;
+  return isRecord(usage) && ["input", "output", "cacheRead", "cacheWrite"].some((key) => typeof usage[key] === "number" && usage[key] > 0);
+}
+
 // src/dreamer/primer-raw-provider-pi.ts
 import { join as join13 } from "node:path";
 
@@ -22275,7 +22682,7 @@ function extractPiTextContent(content) {
 }
 
 // src/dreamer/index.ts
-var warnedUnknownModels = new Set;
+var warnedUnknownModels2 = new Set;
 var modelAvailability = new WeakMap;
 function validatePiDreamerModels(tasks, registry, harness = "pi") {
   let resolved = modelAvailability.get(registry);
@@ -22297,9 +22704,9 @@ function validatePiDreamerModels(tasks, registry, harness = "pi") {
       }
       if (available)
         return true;
-      if (!warnedUnknownModels.has(model)) {
+      if (!warnedUnknownModels2.has(model)) {
         log2(`[dreamer] WARNING: dropping Pi model not found: ${model}`);
-        warnedUnknownModels.add(model);
+        warnedUnknownModels2.add(model);
       }
       return false;
     });
@@ -22531,6 +22938,8 @@ function createPiDreamerClient(opts, onAdjunctsRefreshNeeded = opts.onAdjunctsRe
       const systemPrompt = extractSystemPrompt(args);
       const perTaskModel = extractBodyModel(args);
       const requestedAgent = extractBodyAgent(args) ?? "magic-context-dreamer";
+      const accountingTask = accountingTaskFromTitle(dreamSession.title);
+      const taskConfig = accountingTask ? buildDreamTaskRuntimeConfigs(getDreamerConfig(), opts.harness).find((entry) => entry.task === accountingTask) : undefined;
       const controller = new AbortController;
       let controllers = dreamAbortControllers.get(opts.registrationOwner);
       if (!controllers) {
@@ -22538,7 +22947,12 @@ function createPiDreamerClient(opts, onAdjunctsRefreshNeeded = opts.onAdjunctsRe
         dreamAbortControllers.set(opts.registrationOwner, controllers);
       }
       controllers.add(controller);
+      noteModelActivityMonitored(args.signal ?? undefined);
       const runPromise = runner.run({
+        onProgress: (progress) => {
+          if (progress.type === "raw_event" && piEventShowsModelOutput(progress.event))
+            noteModelOutputReceived(args.signal ?? undefined);
+        },
         agent: requestedAgent,
         systemPrompt,
         userMessage,
@@ -22551,15 +22965,9 @@ function createPiDreamerClient(opts, onAdjunctsRefreshNeeded = opts.onAdjunctsRe
         maxOutputTokens: getMaxOutputTokens(),
         accountingSessionId: opts.projectIdentity,
         accountingSubagent: "dreamer",
-        accountingTask: accountingTaskFromTitle(dreamSession.title),
-        tokenBudget: (() => {
-          if (args.tokenBudget !== undefined)
-            return args.tokenBudget;
-          const task = accountingTaskFromTitle(dreamSession.title);
-          if (!task)
-            return;
-          return buildDreamTaskRuntimeConfigs(getDreamerConfig(), opts.harness).find((entry) => entry.task === task)?.tokenBudget;
-        })()
+        accountingTask,
+        accountingModelConfigKey: taskConfig?.modelConfigKey,
+        tokenBudget: args.tokenBudget ?? taskConfig?.tokenBudget
       });
       inFlightDreams.set(runPromise, opts.registrationOwner);
       try {
@@ -23007,6 +23415,13 @@ Unknown task "${requested}".`,
 }
 
 // ../plugin/src/hooks/magic-context/auto-embed-session.ts
+function localPoolingPreflightPending(projectIdentity) {
+  const snapshot = getProjectEmbeddingSnapshot2(projectIdentity);
+  if (snapshot?.provider !== "local")
+    return false;
+  const metadata = getCachedLocalEmbeddingPooling(snapshot.model);
+  return !metadata || metadata.status === "unresolved";
+}
 function embeddingIdentity(projectIdentity) {
   const snapshot = getProjectEmbeddingSnapshot2(projectIdentity);
   return JSON.stringify([
@@ -23027,7 +23442,8 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
     invalidateAutoEmbedSession(sessionId);
     autoEmbedIdentityBySession.set(sessionId, identity);
   }
-  if (autoEmbedAttemptedBySession.has(sessionId) || embedPauseBySession.has(sessionId) || embedRunStateBySession.has(sessionId) || Date.now() < (autoEmbedRetryAfterBySession.get(sessionId) ?? 0))
+  const poolingPreflightPending = localPoolingPreflightPending(deps.projectIdentity);
+  if (embedPauseBySession.has(sessionId) || embedRunStateBySession.has(sessionId) || Date.now() < (autoEmbedRetryAfterBySession.get(sessionId) ?? 0) || autoEmbedAttemptedBySession.has(sessionId) && !poolingPreflightPending)
     return;
   const controller = new AbortController;
   embedRunStateBySession.set(sessionId, controller);
@@ -23037,6 +23453,7 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
     let started = false;
     let reason = "error";
     let registeredIdentity = identity;
+    let poolingPendingAfterRegistration = poolingPreflightPending;
     try {
       await new Promise((resolve) => setTimeout(resolve, 0));
       if (controller.signal.aborted)
@@ -23044,6 +23461,7 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
       await deps.ensureRegistered();
       if (controller.signal.aborted)
         return;
+      poolingPendingAfterRegistration = localPoolingPreflightPending(deps.projectIdentity);
       markActive();
       registeredIdentity = embeddingIdentity(deps.projectIdentity);
       autoEmbedIdentityBySession.set(sessionId, registeredIdentity);
@@ -23051,7 +23469,9 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
       if (controller.signal.aborted || !coverage.enabled)
         return;
       if (coverage.embedded === coverage.total) {
-        complete = true;
+        complete = !poolingPendingAfterRegistration;
+        if (!complete)
+          retryDelay = 60000;
         return;
       }
       const model = getProjectEmbeddingSnapshot2(deps.projectIdentity)?.model;
@@ -23060,8 +23480,11 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
       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") {
+      complete = after.enabled && after.embedded === after.total && !poolingPendingAfterRegistration;
+      if (poolingPendingAfterRegistration) {
+        retryDelay = 60000;
+        reason = "pooling metadata unavailable";
+      } else if (!complete && outcome.status !== "busy" && outcome.status !== "aborted") {
         retryDelay = 60000;
         if (outcome.status === "nothing" || outcome.status === "done")
           reason = "deferred";
@@ -23334,7 +23757,9 @@ function maybeAutoEmbedPiSession(deps, sessionId, projectDir, projectIdentity) {
   maybeAutoEmbedSessionBackfill({
     db: deps.db,
     projectIdentity,
-    ensureRegistered: () => ensureProjectRegisteredFromPiDirectory(projectDir, deps.db)
+    ensureRegistered: () => ensureProjectRegisteredFromPiDirectory(projectDir, deps.db, {
+      preflightLocalPooling: true
+    })
   }, sessionId);
 }
 
@@ -24348,7 +24773,8 @@ function capturePendingDropEligibility(targets, protectedTagIds) {
         eligible.add(number);
     } else {
       const content = target.getContent?.();
-      if (typeof content === "string" && content.length > `[dropped §${number}§]`.length)
+      const replacement = `[dropped §${number}§]`;
+      if (typeof content === "string" && content.length > replacement.length && target.canSetContent?.(replacement) !== false)
         eligible.add(number);
     }
   }
@@ -24635,12 +25061,16 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
               }
             } else if (target) {
               const replacement = buildReplacementContent(pendingOp.tagId);
+              if (target.canSetContent?.(replacement) === false) {
+                reject("content_unchanged");
+                continue;
+              }
               persistDrop();
               mutations.push(() => {
                 const priorContent = target.getContent?.();
                 const changed = target.setContent(replacement);
-                record(changed);
                 if (changed) {
+                  record(true);
                   const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
                   onTagReduced?.({
                     tagNumber: pendingOp.tagId,
@@ -24731,7 +25161,7 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
 
 // ../plugin/src/hooks/magic-context/cache-busting-signals.ts
 function hasReclaimRide(signals) {
-  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.subagentExecute === true;
+  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.subagentExecute === true || signals.executeReclaim === true || signals.servedShapeRepair === true;
 }
 function prefixMutationPermitted(gate) {
   return !gate.signedThinkingHold || gate.firstRender || gate.idleExpiry || gate.emergency;
@@ -24744,7 +25174,9 @@ var RECLAIM_RIDE_NAMES = [
   "force",
   "explicitFlush",
   "publishedHistory",
-  "subagentExecute"
+  "subagentExecute",
+  "executeReclaim",
+  "servedShapeRepair"
 ];
 function reclaimRideLabel(signals) {
   const active = RECLAIM_RIDE_NAMES.filter((name) => signals[name]);
@@ -24977,6 +25409,140 @@ function rearmChannel2AfterMeasuredCollapse(input) {
   return casChannel2NudgeState(input.db, input.sessionId, "delivered", "");
 }
 
+// ../plugin/src/hooks/magic-context/postprocess-read-cache.ts
+var connections = new WeakMap;
+function snapshot(db, sessionId) {
+  const transaction = db;
+  try {
+    if (transaction.inTransaction || transaction.isTransaction) {
+      connections.delete(db);
+      return { version: -1, changes: -1 };
+    }
+  } catch {
+    connections.delete(db);
+    return { version: -1, changes: -1 };
+  }
+  let connection = connections.get(db);
+  if (!connection) {
+    connection = {
+      stamp: db.prepare("SELECT total_changes() AS changes, data_version AS version FROM pragma_data_version"),
+      sessions: new BoundedSessionMap(100)
+    };
+    connections.set(db, connection);
+  }
+  const stamp = connection.stamp.get();
+  const previous = connection.sessions.get(sessionId);
+  if (previous?.version === stamp.version && previous.changes === stamp.changes) {
+    return previous;
+  }
+  const value = { ...stamp };
+  connection.sessions.set(sessionId, value);
+  return value;
+}
+function postprocessReplaySnapshot(db, sessionId) {
+  const state = snapshot(db, sessionId);
+  const replay = state.replay ??= loadPostprocessReplaySnapshot(db, sessionId);
+  return {
+    ...replay,
+    staleReduceStrippedIds: new Set(replay.staleReduceStrippedIds),
+    processedImageStrippedIds: new Set(replay.processedImageStrippedIds),
+    processedImageMarkers: new Map(replay.processedImageMarkers),
+    strippedPlaceholderIds: new Set(replay.strippedPlaceholderIds),
+    hiddenSeamPlaceholderIds: new Set(replay.hiddenSeamPlaceholderIds),
+    mergedReasoningStrippedIds: new Set(replay.mergedReasoningStrippedIds),
+    trailingBlankDecisions: new Map(replay.trailingBlankDecisions),
+    noteNudgeAnchors: structuredClone(replay.noteNudgeAnchors),
+    autoSearchHintDecisions: structuredClone(replay.autoSearchHintDecisions),
+    todoSyntheticAnchor: structuredClone(replay.todoSyntheticAnchor),
+    pendingCompactionMarker: structuredClone(replay.pendingCompactionMarker),
+    compactionMarker: structuredClone(replay.compactionMarker)
+  };
+}
+
+// ../plugin/src/hooks/magic-context/execute-reclaim.ts
+var NAMESPACE2 = "executeReclaim";
+var failedWrites = new WeakMap;
+function readExecuteReclaimState(db, sessionId) {
+  return parseState2(postprocessReplaySnapshot(db, sessionId).executeReclaim);
+}
+function parseState2(lane) {
+  const value = lane;
+  return {
+    heldPasses: typeof value?.heldPasses === "number" ? Math.max(0, value.heldPasses) : 0,
+    floorOrdinal: typeof value?.floorOrdinal === "number" ? value.floorOrdinal : null,
+    floorPromptId: typeof value?.floorPromptId === "string" ? value.floorPromptId : null
+  };
+}
+function writeExecuteReclaimState(db, sessionId, patch) {
+  if (failedWrites.get(db)?.has(sessionId))
+    return false;
+  try {
+    const current = readExecuteReclaimState(db, sessionId);
+    if (JSON.stringify(current) === JSON.stringify({ ...current, ...patch }))
+      return true;
+    if (!updateReplayDocument(db, sessionId, (doc) => {
+      const previous = parseState2(doc[NAMESPACE2]);
+      const state = { ...previous, ...patch };
+      if (JSON.stringify(previous) === JSON.stringify(state))
+        return false;
+      doc.version = 2;
+      doc[NAMESPACE2] = state;
+      return true;
+    }))
+      throw new Error("Could not persist execute reclaim state");
+    return true;
+  } catch (error) {
+    let failed = failedWrites.get(db);
+    if (!failed)
+      failedWrites.set(db, failed = new Set);
+    failed.add(sessionId);
+    sessionLog2(sessionId, `execute reclaim state persistence failed; retaining existing policy: ${String(error)}`);
+    return false;
+  }
+}
+function clearExecuteReclaimState(db, sessionId) {
+  writeExecuteReclaimState(db, sessionId, {
+    heldPasses: 0,
+    floorOrdinal: null,
+    floorPromptId: null
+  });
+}
+function maintainExecuteFloorMark(db, sessionId, promptId, belowExecute) {
+  failedWrites.get(db)?.delete(sessionId);
+  const state = readExecuteReclaimState(db, sessionId);
+  if (state.floorOrdinal !== null && (belowExecute || promptId !== null && promptId !== state.floorPromptId)) {
+    writeExecuteReclaimState(db, sessionId, { floorOrdinal: null, floorPromptId: null });
+  }
+}
+function estimateExecuteReclaimTokens(args) {
+  const eligible = capturePendingDropEligibility(args.targets, args.protectedTagIds);
+  const queued = new Set(args.pendingOps.filter((op) => op.operation === "drop").map((op) => op.tagId));
+  const candidates = args.tags.filter((tag) => tag.status === "active" && queued.has(tag.tagNumber) && eligible.has(tag.tagNumber));
+  const preparationTargets = new Map;
+  for (const tag of candidates) {
+    const target = args.targets.get(tag.tagNumber);
+    if (target?.prepareDrop)
+      preparationTargets.set(tag.tagNumber, target);
+  }
+  const prepared = preparationTargets.size === 0 ? new Set : args.probePreparation?.(preparationTargets) ?? new Set([...preparationTargets].filter(([, target]) => target.prepareDrop?.() !== false).map(([number]) => number));
+  const seed = sessionDecisionCalibration(args.db, args.sessionId);
+  return candidates.reduce((total, tag) => {
+    if (preparationTargets.has(tag.tagNumber) && !prepared.has(tag.tagNumber))
+      return total;
+    const ratio = tag.type === "tool" ? seed.toolsRatio : seed.proseRatio;
+    return total + Math.max(0, (tag.tokenCount ?? Math.ceil(tag.byteSize / 4)) * ratio);
+  }, 0);
+}
+function originateExecuteReclaim(args) {
+  if (failedWrites.get(args.db)?.has(args.sessionId))
+    return false;
+  const state = readExecuteReclaimState(args.db, args.sessionId);
+  const heldPasses = args.primaryExecute && args.reclaimableTokens > 0 && !args.alreadyBusting ? state.heldPasses + 1 : 0;
+  if (!writeExecuteReclaimState(args.db, args.sessionId, { heldPasses }))
+    return false;
+  return args.primaryExecute && !args.alreadyBusting && !args.summaryCanCome && args.reclaimableTokens > 0 && (args.usableWindow > 0 && args.reclaimableTokens >= args.usableWindow * 0.02 || heldPasses >= 3);
+}
+
 // ../plugin/src/hooks/magic-context/file-token-coverage.ts
 function omitIncompleteFileTokenTotals(db, sessionId, messages, totals) {
   const filesByMessage = new Map;
@@ -25364,7 +25930,8 @@ function resolveProtectedTailBoundary(ctx) {
       break;
     }
     livePromptFloor.ordinal = lastMeaningfulUserOrdinal || null;
-    if (lastMeaningfulUserOrdinal >= offset) {
+    livePromptFloor.messageId = boundaryMessageId(index, lastMeaningfulUserOrdinal);
+    if (!ctx.liftLivePromptFloor && lastMeaningfulUserOrdinal >= offset) {
       protectedTailStart = Math.min(protectedTailStart, lastMeaningfulUserOrdinal);
     }
   }
@@ -25492,6 +26059,7 @@ function resolveBoundaryContext(args) {
     protectedTailPolicyVersion: meta.protectedTailPolicyVersion,
     migrationFloorActive,
     emergencyTailScale: args.emergencyTailScale,
+    liftLivePromptFloor: args.liftLivePromptFloor,
     providerShapeVersion: args.providerShapeVersion ?? "opencode-v1",
     cacheNamespace: args.cacheNamespace ?? `opencode:${args.sessionId}`,
     storedTokenTotalsForMessages,
@@ -25873,7 +26441,7 @@ function resolveBoundaryContextLimit(usage, fallbackContextLimit) {
   }
   return 128000;
 }
-function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail, taggerFloor = 0) {
+function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail, taggerFloor = 0, liftLivePromptFloor = false) {
   return withRawSessionMessageCache2(() => {
     try {
       const memoryPrimed = inMemoryTail ? primeInMemoryTailRawMessageCache2({
@@ -25903,7 +26471,8 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
         executeThresholdPercentage,
         usage,
         usageSource: "live",
-        taggerFloor
+        taggerFloor,
+        liftLivePromptFloor
       });
       const hasProtectedEligibleHead = boundary.offset < Math.min(boundary.protectedTailStart, boundary.eligibleEndOrdinal);
       if (!hasProtectedEligibleHead) {
@@ -25939,7 +26508,10 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
 function formatProjectedPostDropPercentage(value) {
   return value === null ? "none" : `${value.toFixed(1)}%`;
 }
-function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, keepReasoningTokens, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide, eligiblePendingDropTagIds) {
+function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, keepReasoningTokens, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide, eligiblePendingDropTagIds, primaryExecute = false) {
+  if (usage.percentage < executeThresholdPercentage) {
+    writeExecuteReclaimState(db, sessionId, { floorOrdinal: null, floorPromptId: null });
+  }
   if (sessionMeta.compartmentInProgress) {
     sessionLog2(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
@@ -25992,7 +26564,22 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
       resolvedInMemoryTail = undefined;
     }
   }
-  const tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor);
+  let tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor);
+  const markState = readExecuteReclaimState(db, sessionId);
+  const mark = markState.floorOrdinal;
+  const livePromptOrdinal = tailInfo.boundarySnapshot?.diagnostics?.livePromptFloor.ordinal;
+  let consumedFloorMark = false;
+  if (mark !== null) {
+    const consumed = writeExecuteReclaimState(db, sessionId, {
+      floorOrdinal: null,
+      floorPromptId: null
+    });
+    if (consumed && mark === livePromptOrdinal && markState.floorPromptId === tailInfo.boundarySnapshot?.diagnostics?.livePromptFloor.messageId && usage.percentage >= executeThresholdPercentage) {
+      consumedFloorMark = true;
+      sessionLog2(sessionId, `compartment trigger: live-prompt floor mark consumed at ${mark}`);
+      tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor, true);
+    }
+  }
   if (!tailInfo.hasNewRawHistory) {
     try {
       const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
@@ -26076,7 +26663,21 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     return { shouldFire: false };
   }
   if (!tailInfo.hasProtectedEligibleHead || !tailInfo.isMeaningful) {
-    sessionLog2(sessionId, `compartment trigger: not firing at ${usage.percentage.toFixed(1)}% because unsummarized tail from ${tailInfo.nextStartOrdinal} is too small`);
+    let floorOnly = false;
+    const boundary = tailInfo.boundarySnapshot;
+    const floor = boundary?.diagnostics?.livePromptFloor;
+    if (!consumedFloorMark && floor?.ordinal && floor.from > floor.to) {
+      const withoutFloor = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor, true);
+      floorOnly = withoutFloor.hasProtectedEligibleHead && withoutFloor.isMeaningful;
+      if (floorOnly && primaryExecute && usage.percentage >= executeThresholdPercentage && writeExecuteReclaimState(db, sessionId, {
+        floorOrdinal: floor.ordinal,
+        floorPromptId: floor.messageId ?? null
+      })) {
+        sessionLog2(sessionId, `compartment trigger: live-prompt floor mark set at ${floor.ordinal}`);
+      }
+    }
+    const refusal = floorOnly ? `no eligible head (live-prompt floor at ${floor?.ordinal})` : tailInfo.hasProtectedEligibleHead ? "below meaningfulness" : "no eligible head";
+    sessionLog2(sessionId, `compartment trigger: not firing at ${usage.percentage.toFixed(1)}% — ${refusal}; offset=${tailInfo.nextStartOrdinal} protectedStart=${boundary?.protectedTailStart ?? "none"} eligibleEnd=${boundary?.eligibleEndOrdinal ?? "none"} rawTokens=${tailInfo.trueRawEligibleTokens} chunkTokens=${tailInfo.tokenEstimate}`);
     return { shouldFire: false };
   }
   sessionLog2(sessionId, `compartment trigger: proactive fire at ${usage.percentage.toFixed(1)}% (floor=${proactiveTriggerPercentage}% projected post-drop=${formatProjectedPostDropPercentage(projectedPostDropPercentage)} target=${relativePostDropTarget.toFixed(1)}%)`);
@@ -26245,6 +26846,9 @@ function latestAssistantTurnStart(messages) {
 function latestAssistantTurnMessages(messages) {
   return new Set(messages.slice(latestAssistantTurnStart(messages)));
 }
+function isAnthropicThinkingPart(part, familyRoute) {
+  return isRecord(part) && THINKING_TYPES.has(String(part.type ?? part.kind)) && (familyRoute || isRecord(part.metadata) && isRecord(part.metadata.anthropic));
+}
 function hasActiveAnthropicThinkingTurn(messages, provider, model) {
   const familyRoute = isAnthropicFamilyRoute(provider, model);
   for (const message of messages.slice(latestAssistantTurnStart(messages))) {
@@ -26253,7 +26857,7 @@ function hasActiveAnthropicThinkingTurn(messages, provider, model) {
     const parts = content(message);
     if (!Array.isArray(parts))
       continue;
-    if (parts.some((part) => isRecord(part) && THINKING_TYPES.has(String(part.type ?? part.kind)) && (familyRoute || isRecord(part.metadata) && isRecord(part.metadata.anthropic))))
+    if (parts.some((part) => isAnthropicThinkingPart(part, familyRoute)))
       return true;
   }
   return false;
@@ -27141,6 +27745,7 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
           db,
           targets,
           skipPrefixInjection,
+          preserveTagOnlyAssistantText: options.preserveTagOnlyAssistantText,
           entryFingerprint: options.entryFingerprintByMessageId?.get(messageId) ?? null,
           reuseIdentity: reuseIdentity || contentDerivedTextIds !== undefined,
           timing,
@@ -27532,7 +28137,7 @@ function isRecord2(value) {
 function tagTextPart(args) {
   const identityStart = args.timing ? performance.now() : 0;
   const text = args.part.getText() ?? "";
-  if (args.message.info.role === "assistant" && stripWellFormedLeadingTagPrefix(text).trim().length === 0) {
+  if (args.message.info.role === "assistant" && (stripWellFormedLeadingTagPrefix(text).trim().length === 0 || args.preserveTagOnlyAssistantText && text.includes("§") && stripPersistedAssistantText(text).length === 0)) {
     if (args.timing)
       args.timing.identity += performance.now() - identityStart;
     return;
@@ -28022,7 +28627,8 @@ ${trimmedBody}…
   return wrapped;
 }
 function selectAutoSearchResults(results, threshold) {
-  return results.filter((result) => (result.relevanceScore ?? result.score) >= threshold);
+  const relevance = (result) => result.relevanceScore ?? result.score;
+  return results.filter((result) => relevance(result) >= threshold).sort((left, right) => relevance(right) - relevance(left));
 }
 
 // ../plugin/src/hooks/magic-context/auto-search-worker-client.ts
@@ -28115,22 +28721,42 @@ function retryUnpublishedAutoSearchNoHint(db, sessionId, messageId, startedAt) {
   }
   return true;
 }
+
+class AutoSearchBusyError extends Error {
+  constructor() {
+    super("an earlier auto-search of this session is still running");
+    this.name = "AutoSearchBusyError";
+  }
+}
 async function searchAutoHint(db, sessionId, projectPath, query, options, entry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./auto-search-worker.ts" : "./auto-search-worker.js", import.meta.url)) {
-  return executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, "search");
+  const {
+    rerankConfig: _rerankConfig,
+    rerankClient: _rerankClient,
+    rerankConnectionFile: _rerankConnectionFile,
+    onRerankSkipped: _onRerankSkipped,
+    captureRerankLanes: _captureRerankLanes,
+    ...hintOptions
+  } = options;
+  return executeAutoSearchWorker(db, sessionId, projectPath, query, { ...hintOptions, explicitSearch: false, rerank: false }, entry, "search");
 }
 var pendingBackfills = new WeakMap;
 var searchWorkers = new WeakMap;
 var liveSearchWorkers = new Set;
 var MAX_IDLE_SEARCH_WORKERS = 4;
 var SEARCH_WORKER_IDLE_MS = 5 * 60000;
+var DETACHED_SEARCH_LIMIT_MS = 30000;
+var AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS = 2000;
 var workersCreated = 0;
 var workersReused = 0;
+var searchesSkippedBusy = 0;
 async function acquireSearchWorker(db, key, entry, input, signal) {
   const pool = searchWorkers.get(db) ?? new Map;
   searchWorkers.set(db, pool);
   while (!signal.aborted) {
     let slot = pool.get(key);
     if (slot?.busy) {
+      if (input.job === "search" && (slot.detached || slot.busySessionId === input.sessionId))
+        return "busy";
       const current = slot;
       await new Promise((resolve) => {
         const done = () => {
@@ -28139,6 +28765,8 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
         };
         signal.addEventListener("abort", done, { once: true });
         current.busy?.then(done);
+        if (!current.detached)
+          current.detachedSignal?.then(done);
         if (signal.aborted)
           done();
       });
@@ -28147,14 +28775,16 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
     const fresh = !slot;
     if (!slot) {
       const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { ...input, persistent: true } }));
+      const shutdown = createWorkerShutdown(worker, "auto-search", AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS);
       slot = {
         worker,
         dispose() {
+          this.disposed = true;
           clearTimeout(this.idleTimer);
           if (pool.get(key) === this)
             pool.delete(key);
           liveSearchWorkers.delete(this);
-          worker.terminate();
+          shutdown.close();
           worker.unref();
         }
       };
@@ -28168,9 +28798,14 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
       workersReused++;
     clearTimeout(slot.idleTimer);
     const current = slot;
+    current.busySessionId = input.sessionId;
+    current.detached = false;
     current.busy = new Promise((resolve) => {
       current.release = resolve;
     });
+    current.detachedSignal = new Promise((resolve) => {
+      current.markDetached = resolve;
+    });
     current.worker.ref();
     return { slot: current, fresh };
   }
@@ -28179,6 +28814,9 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
 function queueAutoSearchBackfill(db, sessionId, projectPath, query) {
   if (isEmbeddingHostBusy2())
     return Promise.resolve();
+  const snapshot = getProjectEmbeddingSnapshot2(projectPath);
+  if (!snapshot?.enabled || !snapshot.features.memoryEnabled)
+    return Promise.resolve();
   const key = `${sessionId}\x00${projectPath}`;
   const pending = pendingBackfills.get(db) ?? new Map;
   pendingBackfills.set(db, pending);
@@ -28226,6 +28864,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     signal: deadlineSignal,
     readMessages: _readMessages,
     searchMessageHistory: _searchMessageHistory,
+    stepTimings: _stepTimings,
     ...serializable
   } = options;
   const lifecycle = registerAutoSearchWork(sessionId);
@@ -28261,30 +28900,55 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     lifecycle.done();
     return [];
   }
+  if (lease === "busy") {
+    lifecycle.done();
+    searchesSkippedBusy++;
+    throw new AutoSearchBusyError;
+  }
   const { slot, fresh } = lease;
   const worker = slot.worker;
+  const detachable = job === "search" && entry.href === defaultAutoSearchWorkerEntry().href;
+  const startedAt = performance.now();
+  let detachedAt;
+  let ownerVectorMs;
+  let abandonTimer;
   return new Promise((resolve, reject) => {
     let settled = false;
-    const finish = (results, error) => {
+    let released = false;
+    const settle = (results, error) => {
       if (settled)
         return;
       settled = true;
+      if (error)
+        reject(error);
+      else
+        resolve(results);
+    };
+    const release = (dispose) => {
+      if (released)
+        return;
+      released = true;
+      clearTimeout(abandonTimer);
       signal?.removeEventListener("abort", abort);
       lifecycle.signal.removeEventListener("abort", abort);
       lifecycle.done();
       worker.off("message", onMessage);
       worker.off("error", onError);
       worker.off("exit", onExit);
-      if (error || signal.aborted || entry.href !== defaultAutoSearchWorkerEntry().href)
+      if (dispose || !detachable)
         slot.dispose();
-      else {
+      else if (!slot.disposed) {
         slot.idleTimer = setTimeout(() => slot.dispose(), SEARCH_WORKER_IDLE_MS);
         slot.idleTimer.unref?.();
       }
-      const release = slot.release;
+      const free = slot.release;
       slot.busy = undefined;
       slot.release = undefined;
-      release?.();
+      slot.busySessionId = undefined;
+      slot.detached = false;
+      slot.detachedSignal = undefined;
+      slot.markDetached = undefined;
+      free?.();
       const reusable = liveSearchWorkers.delete(slot);
       if (reusable)
         liveSearchWorkers.add(slot);
@@ -28292,51 +28956,82 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       for (const prior of idle.slice(0, Math.max(0, idle.length - MAX_IDLE_SEARCH_WORKERS)))
         prior.dispose();
       worker.unref();
-      if (error)
-        reject(error);
-      else
-        resolve(results);
     };
-    const abort = () => finish([]);
+    const finish = (results, error) => {
+      settle(results, error);
+      release(Boolean(error) || signal.aborted);
+    };
+    const abort = () => {
+      if (lifecycle.signal.aborted || !detachable) {
+        finish([]);
+        return;
+      }
+      if (settled)
+        return;
+      detachedAt = performance.now();
+      slot.detached = true;
+      slot.markDetached?.();
+      settle([]);
+      abandonTimer = setTimeout(() => {
+        log2(`[auto-search] session ${sessionId}: search still running ${DETACHED_SEARCH_LIMIT_MS} ms after its deadline; disposing its worker (owner vector wait ${formatMs(ownerVectorMs)})`);
+        release(true);
+      }, DETACHED_SEARCH_LIMIT_MS);
+      abandonTimer.unref?.();
+    };
     signal?.addEventListener("abort", abort, { once: true });
     lifecycle.signal.addEventListener("abort", abort, { once: true });
     const onError = (error) => finish([], error);
     const onExit = (code) => finish([], new Error(`auto-search worker exited (${code})`));
     const onMessage = async (reply) => {
-      if (settled)
+      if (released)
         return;
-      if (reply.kind === "result") {
+      if (reply.kind === "result" || reply.kind === "error") {
+        if (detachedAt !== undefined) {
+          logLateSearch(sessionId, performance.now() - detachedAt, detachedAt - startedAt, ownerVectorMs, reply.kind === "result" ? reply.timings : undefined, reply.kind === "error");
+          release(reply.kind === "error");
+          return;
+        }
+        if (reply.kind === "error") {
+          finish([], new Error(reply.error));
+          return;
+        }
         if (snapshot && getProjectEmbeddingSnapshot2(projectPath)?.generation !== snapshot.generation)
           finish([]);
         else
           finish(reply.results);
         return;
       }
-      if (reply.kind === "error") {
-        finish([], new Error(reply.error));
-        return;
-      }
       if (reply.kind === "messages" || reply.kind === "accepted")
         return;
       const response = { id: reply.id };
-      try {
+      if (!signal.aborted) {
+        const requestedAt = performance.now();
+        try {
+          if (reply.kind === "query")
+            response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : boundedHintEmbedding(embedQuery, reply.text, signal)) ?? null;
+          else {
+            const passage = await embedBatchForProject2(projectPath, reply.texts, signal, reply.purpose);
+            const current = getProjectEmbeddingSnapshot2(projectPath);
+            response.passage = passage && current ? {
+              ...passage,
+              providerIdentity: current.providerIdentity,
+              runtimeFingerprint: current.runtimeFingerprint,
+              dimensions: passage.vectors.find((vector) => vector !== null)?.length ?? null
+            } : null;
+          }
+        } catch (error) {
+          response.error = error instanceof Error ? error.message : String(error);
+        }
         if (reply.kind === "query")
-          response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : boundedHintEmbedding(embedQuery, reply.text, signal)) ?? null;
-        else {
-          const passage = await embedBatchForProject2(projectPath, reply.texts, signal, reply.purpose);
-          const current = getProjectEmbeddingSnapshot2(projectPath);
-          response.passage = passage && current ? {
-            ...passage,
-            providerIdentity: current.providerIdentity,
-            runtimeFingerprint: current.runtimeFingerprint,
-            dimensions: passage.vectors.find((vector) => vector !== null)?.length ?? null
-          } : null;
+          ownerVectorMs = performance.now() - requestedAt;
+        if (signal.aborted) {
+          response.result = undefined;
+          response.passage = undefined;
+          response.error = undefined;
         }
-      } catch (error) {
-        response.error = error instanceof Error ? error.message : String(error);
       }
       response.embeddingHostBusy = isEmbeddingHostBusy2();
-      if (!settled && !signal?.aborted) {
+      if (!released) {
         try {
           worker.postMessage(response);
         } catch (error) {
@@ -28358,6 +29053,15 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     }
   });
 }
+function formatMs(value) {
+  return value === undefined ? "n/a" : `${Math.round(value)} ms`;
+}
+function logLateSearch(sessionId, lateMs, waitedMs, ownerVectorMs, timings, failed) {
+  const steps = timings?.steps;
+  const warm = timings?.lastPoolWarm;
+  const pool = warm ? `last pool refresh ${warm.outcome} in ${formatMs(warm.totalMs)} (probe ${formatMs(warm.probeMs)}, read ${formatMs(warm.readMs)}, decode ${formatMs(warm.decodeMs)}, ${warm.probedRows} rows probed, ${warm.decodedRows} decoded)` : "no pool refresh yet";
+  log2(`[auto-search] session ${sessionId}: deadline passed after ${formatMs(waitedMs)}; the search ${failed ? "failed" : "finished"} ${formatMs(lateMs)} later. Steps: message FTS ${formatMs(steps?.messageMs)}, vector wait ${formatMs(steps?.vectorWaitMs)} (owner embedding ${formatMs(ownerVectorMs)}), chunk lane ${formatMs(steps?.chunkMs)} (pool ${steps?.chunkPool ?? "n/a"}), other lanes ${formatMs(steps?.otherLanesMs)}, job ${formatMs(timings?.jobMs)}; ${pool}`);
+}
 async function boundedHintEmbedding(embed, text, signal) {
   const controller = new AbortController;
   const combined = AbortSignal.any([signal, controller.signal]);
@@ -28581,7 +29285,8 @@ async function runAutoSearchHintForPi(args) {
           },
           isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
           visibleMemoryIds: options.visibleMemoryIds ?? null,
-          sources: ["memory", "message", "git_commit"]
+          sources: ["memory", "message", "git_commit"],
+          chunkPoolWarmOnly: true
         };
         return searchAutoHint(db, sessionId, options.projectPath, rawPrompt, {
           ...searchOptions,
@@ -28593,6 +29298,11 @@ async function runAutoSearchHintForPi(args) {
       args.passGuard?.assert();
       if (lifecycleSignal.aborted)
         return messages;
+      if (error instanceof AutoSearchBusyError) {
+        sessionLog2(sessionId, "auto-search: an earlier search of this session is still running, skipping hint for this turn");
+        persistAutoSearchSkip(db, sessionId, userMsgId);
+        return messages;
+      }
       log2(`[auto-search] unified search failed for session ${sessionId} (no-hint frozen for this turn): ${error instanceof Error ? error.message : String(error)}`);
       await writeNoHintAndReconcile("error");
       return messages;
@@ -28644,7 +29354,7 @@ ${hintText}`;
       if (outcome.decision.decision === "hint") {
         appendHintToUserMessage(userMsg, outcome.decision.text);
       }
-      sessionLog2(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top score ${results[0].score.toFixed(3)})`);
+      sessionLog2(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top relevance ${(results[0].relevanceScore ?? results[0].score).toFixed(3)})`);
       return messages;
     } finally {
       if (!lifecycleSignal.aborted && results !== null) {
@@ -28680,19 +29390,19 @@ async function embedAndStoreCompartmentChunks(db, sessionId, projectPath, compar
   const maxInputTokens = getProjectEmbeddingMaxInputTokens2(projectPath);
   for (const compartment of compartments) {
     try {
-      const fromMemory = compartment.sourceChunkText ? canonicalizeInMemoryChunkTextForEmbedding(compartment.sourceChunkText, compartment.startMessage, compartment.endMessage) : "";
-      const mappedText = fromMemory ? fromMemory : buildCanonicalChunkTextFromFts(db, sessionId, compartment.startMessage, compartment.endMessage);
+      const fromMemory = compartment.sourceChunkText ? canonicalizeInMemoryChunkTextForEmbedding2(compartment.sourceChunkText, compartment.startMessage, compartment.endMessage) : "";
+      const mappedText = fromMemory ? fromMemory : buildCanonicalChunkTextFromFts2(db, sessionId, compartment.startMessage, compartment.endMessage);
       if (mappedText === null)
         continue;
-      const canonicalText = mappedText || buildCompartmentSummaryFallbackText(db, compartment.id);
+      const canonicalText = mappedText || buildCompartmentSummaryFallbackText2(db, compartment.id);
       if (canonicalText.length === 0)
         continue;
-      const windows = chunkCanonicalText(canonicalText, compartment.startMessage, compartment.endMessage, maxInputTokens);
+      const windows = chunkCanonicalText2(canonicalText, compartment.startMessage, compartment.endMessage, maxInputTokens);
       if (windows.length === 0)
         continue;
-      const windowSourceKey = chunkWindowSourceKey(canonicalText, compartment.startMessage, compartment.endMessage, maxInputTokens);
+      const windowSourceKey = chunkWindowSourceKey2(canonicalText, compartment.startMessage, compartment.endMessage, maxInputTokens);
       const currentModelId = getProjectChunkEmbeddingModelId2(projectPath);
-      if (currentModelId !== "off" && chunkEmbeddingWindowsAreCurrent(db, compartment.id, currentModelId, windows, projectPath)) {
+      if (currentModelId !== "off" && chunkEmbeddingWindowsAreCurrent2(db, compartment.id, currentModelId, windows, projectPath)) {
         continue;
       }
       const result = await embedItemsForProject2(projectPath, windows.map((window) => ({
@@ -28702,7 +29412,7 @@ async function embedAndStoreCompartmentChunks(db, sessionId, projectPath, compar
       })), undefined, db, sessionId);
       if (!result)
         continue;
-      if (chunkEmbeddingWindowsAreCurrent(db, compartment.id, currentModelId, windows, projectPath)) {
+      if (chunkEmbeddingWindowsAreCurrent2(db, compartment.id, currentModelId, windows, projectPath)) {
         continue;
       }
       const rows = [];
@@ -28720,7 +29430,7 @@ async function embedAndStoreCompartmentChunks(db, sessionId, projectPath, compar
         });
       }
       if (rows.length === windows.length) {
-        replaceCompartmentChunkEmbeddings(db, rows, windowSourceKey);
+        replaceCompartmentChunkEmbeddings2(db, rows, windowSourceKey);
         enqueueShadowEmbeddingItems2(projectPath, "chunk", [String(compartment.id)]);
       }
     } catch (error) {
@@ -29489,7 +30199,8 @@ ${chunkText}`,
           maxOutputTokens,
           onProgress: buildProgressLogger("first"),
           accountingSessionId: sessionId,
-          accountingSubagent: "historian"
+          accountingSubagent: "historian",
+          accountingModelConfigKey: deps.modelConfigKey
         }
       });
       let validatedPass = await validateHistorianResult(firstResult, sessionId, chunk, priorCompartments, sequenceOffset);
@@ -29549,6 +30260,7 @@ ${chunkText}`,
               onProgress: buildProgressLogger("fallback"),
               accountingSessionId: sessionId,
               accountingSubagent: "historian",
+              accountingModelConfigKey: candidate.sourceConfigKey ?? deps.modelConfigKey,
               accountingTask: "fallback"
             }
           });
@@ -29600,7 +30312,8 @@ ${chunkText}`,
               maxOutputTokens,
               onProgress: buildProgressLogger("editor"),
               accountingSessionId: sessionId,
-              accountingSubagent: "historian_editor"
+              accountingSubagent: "historian_editor",
+              accountingModelConfigKey: deps.modelConfigKey
             }
           });
           const editorPass = await validateHistorianResult(editorResult, sessionId, chunk, priorCompartments, sequenceOffset);
@@ -31655,7 +32368,7 @@ function promoteRecompStagingWithM0Mutation(db, sessionId, holderId) {
       finished = true;
       return null;
     }
-    deleteChunkEmbedBackoffForSession(db, sessionId);
+    deleteChunkEmbedBackoffForSession2(db, sessionId);
     db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
     insertRecompCompartmentRows(db, sessionId, staging.compartments, now);
@@ -32563,7 +33276,7 @@ function dropCompartmentsAfter(db, sessionId, anchor, holderId, activeBranch = f
       if (marker && clearPendingPiCompactionMarkerStateIf(db, sessionId, marker, null))
         clearedMarker = marker;
     }
-    deleteChunkEmbedBackoffForSession(db, sessionId);
+    deleteChunkEmbedBackoffForSession2(db, sessionId);
     queueM0Mutation(db, { sessionId, mutationType: "recomp_boundary_change" });
     clearCachedM0M1(db, sessionId);
     db.exec("COMMIT");
@@ -34521,7 +35234,7 @@ function isSentinelPart(part) {
 
 // src/pi-append-compaction.ts
 var loggedIncompatibleHost = false;
-var failedWrites = new WeakMap;
+var failedWrites2 = new WeakMap;
 function adaptPiAppendCompaction(sessionManager) {
   if (!sessionManager || typeof sessionManager !== "object")
     return;
@@ -34529,7 +35242,7 @@ function adaptPiAppendCompaction(sessionManager) {
   const append = host.appendCompaction;
   if (typeof append !== "function")
     return;
-  if (failedWrites.has(host))
+  if (failedWrites2.has(host))
     return;
   const harness = resolvePiHarnessKind();
   if ((harness === "omp" ? append.length !== 4 && append.length !== 7 : append.length !== 5 && append.length !== 6) || typeof host.getEntry !== "function") {
@@ -34541,7 +35254,7 @@ function adaptPiAppendCompaction(sessionManager) {
   }
   const getEntry = host.getEntry.bind(host);
   return (summary, firstKeptEntryId, tokensBefore, details, fromHook) => {
-    const previousFailure = failedWrites.get(host);
+    const previousFailure = failedWrites2.get(host);
     if (previousFailure)
       throw previousFailure;
     let id;
@@ -34559,7 +35272,7 @@ function adaptPiAppendCompaction(sessionManager) {
       }
     } catch {
       const error = new Error("Compaction marker read-back failed; writes disabled for this session manager until restart");
-      failedWrites.set(host, error);
+      failedWrites2.set(host, error);
       log2(`ERROR: compaction marker read-back failed harness=${harness} compactionId=${typeof id === "string" ? id : "<missing>"} expectedFirstKept=${firstKeptEntryId}; further writes disabled for this session manager until restart; leaving marker pending`);
       throw error;
     }
@@ -34567,123 +35280,6 @@ function adaptPiAppendCompaction(sessionManager) {
   };
 }
 
-// src/pi-context-budget.ts
-var PI_CONTEXT_BUDGET = {
-  hostDeadlineMs: 30000,
-  hostMarginMs: 5000,
-  outcomeMs: 25000,
-  fallbackObservedMs: 4,
-  workMs: 21000,
-  writerMs: 16500,
-  completionReserveMs: 2000,
-  searchMs: 3000
-};
-
-class PiContextDeadlineError extends Error {
-}
-
-class PiContextSupersededError extends Error {
-  origin;
-  constructor(message, origin = "context ownership") {
-    super(message);
-    this.origin = origin;
-  }
-}
-
-class PiContextBudget {
-  startedAt;
-  now;
-  sideTurn = false;
-  stage = "entry";
-  recovery = "not attempted";
-  abandoned = false;
-  completed = false;
-  failureReason;
-  signal;
-  cancelled = false;
-  isCancelled(error) {
-    return this.cancelled || this.signal?.aborted === true || !this.signal && typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
-  }
-  cancel() {
-    this.cancelled = true;
-    this.abandoned = true;
-    this.completed = false;
-    this.failureReason = undefined;
-  }
-  assertOwner = () => {};
-  constructor(startedAt = performance.now(), now = () => performance.now()) {
-    this.startedAt = startedAt;
-    this.now = now;
-  }
-  elapsed() {
-    return this.now() - this.startedAt;
-  }
-  remainingWork = () => {
-    return Math.max(0, PI_CONTEXT_BUDGET.workMs - this.elapsed());
-  };
-  remainingOutcome = () => Math.max(0, PI_CONTEXT_BUDGET.outcomeMs - this.elapsed());
-  writerAllowance() {
-    return Math.max(0, Math.min(PI_CONTEXT_BUDGET.writerMs, this.remainingWork() - PI_CONTEXT_BUDGET.completionReserveMs));
-  }
-  hydrationAllowance() {
-    return Math.max(0, Math.min(this.remainingWork() - PI_CONTEXT_BUDGET.completionReserveMs, this.remainingOutcome() - PI_CONTEXT_BUDGET.completionReserveMs));
-  }
-  assertOutcome = () => {
-    this.assertOwner();
-    this.signal?.throwIfAborted();
-    if (this.abandoned || this.elapsed() >= PI_CONTEXT_BUDGET.outcomeMs)
-      throw new PiContextDeadlineError(this.diagnostic());
-  };
-  assert = () => {
-    this.assertOutcome();
-    if (this.elapsed() >= PI_CONTEXT_BUDGET.workMs)
-      throw new PiContextDeadlineError(this.diagnostic());
-  };
-  assertDecisionPublication = () => {
-    this.signal?.throwIfAborted();
-    if (!this.completed)
-      this.assertOwner();
-    if (this.abandoned || !this.completed && this.elapsed() >= PI_CONTEXT_BUDGET.outcomeMs)
-      throw new PiContextDeadlineError(this.diagnostic());
-  };
-  diagnostic() {
-    return `stage=${this.stage} elapsed=${Math.round(this.elapsed())}ms recovery=${this.recovery}`;
-  }
-  waitUntil = async (pending, assert, remaining) => {
-    try {
-      assert();
-    } catch (error) {
-      pending.catch(() => {});
-      throw error;
-    }
-    let timer;
-    let onAbort;
-    try {
-      return await Promise.race([
-        pending,
-        ...this.signal ? [
-          new Promise((_, reject) => {
-            onAbort = () => reject(this.signal?.reason);
-            this.signal?.addEventListener("abort", onAbort, {
-              once: true
-            });
-          })
-        ] : [],
-        new Promise((_, reject) => {
-          timer = setTimeout(() => reject(new PiContextDeadlineError(this.diagnostic())), remaining());
-        })
-      ]);
-    } finally {
-      clearTimeout(timer);
-      if (onAbort)
-        this.signal?.removeEventListener("abort", onAbort);
-      assert();
-    }
-  };
-  wait = (pending) => this.waitUntil(pending, this.assert, () => this.remainingWork());
-  waitMandatory = (pending) => this.waitUntil(pending, this.assertOutcome, this.remainingOutcome);
-}
-
 // src/pi-context-limit.ts
 var MIN_SANE_LIMIT = 16000;
 var MAX_SANE_LIMIT = 1e7;
@@ -35376,6 +35972,11 @@ function piHasManagedSignature(payload, signature) {
   return false;
 }
 
+// src/pi-dispatch-assistant-history.ts
+function piOmitsTruncatedAssistant(message) {
+  return (message.stopReason === "length" || message.stopReason === "error" || message.stopReason === "aborted") && Array.isArray(message.content) && !message.content.some((block) => block?.type === "text" || block?.type === "toolCall");
+}
+
 // src/pi-dispatch-tool-pairing.ts
 var RESPONSES_APIS = new Set([
   "openai-responses",
@@ -35425,14 +36026,14 @@ function object5(value) {
 function omitsAssistant(message, model, compat) {
   if (!Array.isArray(message.content))
     return false;
+  if (piOmitsTruncatedAssistant(message))
+    return true;
   let thinking = false;
-  let hasTextBlock = false;
   for (const value of message.content) {
     const block = object5(value);
     if (!block)
       return false;
     if (block.type === "text") {
-      hasTextBlock = true;
       if (typeof block.text !== "string" || block.text.trim())
         return false;
     } else if (block.type === "thinking") {
@@ -35442,8 +36043,6 @@ function omitsAssistant(message, model, compat) {
     } else
       return false;
   }
-  if (!hasTextBlock && ["length", "error", "aborted"].includes(String(message.stopReason)))
-    return true;
   if (compat.requiresReasoningContentForAllAssistantTurns === true)
     return false;
   if (!thinking)
@@ -35748,11 +36347,25 @@ ${wellFormed(text)}
 </think>`;
   return;
 }
-function piResponsesAssistantTexts(value, model) {
+function coldReplayable(items) {
+  let reasoning = false;
+  for (const value of items) {
+    const item = object7(value);
+    if (typeof item?.encrypted_content === "string")
+      return false;
+    if (item?.type !== "reasoning")
+      continue;
+    if (!Array.isArray(item.content) || !item.content.some((part) => object7(part)?.type === "reasoning_text"))
+      return false;
+    reasoning = true;
+  }
+  return reasoning;
+}
+function piResponsesAssistantTexts(value, model, host, alternatives) {
   const message = object7(value);
   if (!message || !Array.isArray(message.content))
     return;
-  if (["length", "error", "aborted"].includes(String(message.stopReason)) && !message.content.some((value) => ["text", "toolCall"].includes(String(object7(value)?.type))))
+  if (piOmitsTruncatedAssistant(message))
     return [];
   const texts = [];
   const blocks = [];
@@ -35795,6 +36408,13 @@ function piResponsesAssistantTexts(value, model) {
   const replay = [];
   let bound = 0;
   let output = false;
+  const allowUnsigned = host === "omp" && message.role === "assistant" && [
+    "openai-responses",
+    "azure-openai-responses",
+    "openai-codex-responses"
+  ].includes(model?.api ?? "");
+  let unsigned = false;
+  let rewrittenText = false;
   for (const value of payload.items) {
     const item = object7(value);
     if (item?.type === "reasoning")
@@ -35818,8 +36438,14 @@ function piResponsesAssistantTexts(value, model) {
       } catch {
         return texts;
       }
-      if (signature?.v !== 1 || typeof signature.id !== "string" || item.id !== signature.id || item.phase !== signature.phase || part.text !== block.text.replace(/^§\d+§ /u, ""))
-        return texts;
+      const signed = signature?.v === 1 && typeof signature.id === "string" && item.id === signature.id && item.phase === signature.phase && part.text === block.text.replace(/^§\d+§ /u, "");
+      if (!signed) {
+        const stripped = stripPersistedAssistantText(part.text);
+        if (!allowUnsigned || "textSignature" in block || stripped !== block.text.replace(/^§\d+§ /u, ""))
+          return texts;
+        unsigned = true;
+        rewrittenText ||= part.text !== stripped && part.text !== block.text;
+      }
       bound++;
       itemTexts.push(part.text);
     }
@@ -35829,7 +36455,13 @@ function piResponsesAssistantTexts(value, model) {
     for (const text of itemTexts)
       replay.push(textIdentity2(wellFormed(text), item.phase));
   }
-  return output && bound === blocks.length ? replay : texts;
+  if (!output || bound !== blocks.length || unsigned && !rewrittenText)
+    return texts;
+  if (unsigned && alternatives) {
+    alternatives.fallback = texts;
+    alternatives.cold = coldReplayable(payload.items) ? replay : texts;
+  }
+  return replay;
 }
 function piResponsesWireTexts(value, phase) {
   if (phase !== undefined && phase !== null && phase !== "commentary" && phase !== "final_answer")
@@ -36071,11 +36703,10 @@ function projectMissingToolResults(messages, model, host = "omp") {
     const message = object8(value);
     if (message?.role === "assistant") {
       flush(message.timestamp);
+      if (piOmitsTruncatedAssistant(message))
+        continue;
       projected.push(value);
       const calls = windowCalls(message);
-      const truncated = ["length", "error", "aborted"].includes(String(message.stopReason));
-      if (truncated && Array.isArray(message.content) && !message.content.some((part) => ["toolCall", "text"].includes(String(object8(part)?.type))))
-        continue;
       if (message.stopReason === "aborted" || message.stopReason === "error") {
         aborted = new Map(calls.map((call) => [pairingId(call.id), call]));
         abortedTimestamp = message.timestamp;
@@ -36369,31 +37000,43 @@ function buildPiPreparedStructure(messages, model, prepareUser, host = "omp") {
   }
   const responsesApi = responsesLane(model?.api);
   let responsesMessages = responsesApi ? [] : undefined;
+  const fallbackMessages = [];
+  const coldMessages = [];
+  let unsignedAlternatives = false;
+  const appendResponse = (output, row, texts) => {
+    if (!texts.length && !row.calls.length)
+      return;
+    const previous = output.at(-1);
+    if (previous?.role === "assistant") {
+      previous.calls.push(...row.calls);
+      previous.wireCalls?.push(...row.wireCalls ?? []);
+      previous.responseTexts?.push(...texts);
+    } else
+      output.push({
+        ...row,
+        calls: [...row.calls],
+        ...row.wireCalls ? { wireCalls: [...row.wireCalls] } : {},
+        responseTexts: [...texts]
+      });
+  };
   if (responsesMessages) {
     for (const [index, row] of byIndex) {
       if (row.role !== "assistant") {
         responsesMessages.push(row);
+        fallbackMessages.push(row);
+        coldMessages.push(row);
         continue;
       }
-      const texts = piResponsesAssistantTexts(projectedMessages[index], model);
+      const alternatives = {};
+      const texts = piResponsesAssistantTexts(projectedMessages[index], model, host, alternatives);
       if (!texts) {
         responsesMessages = undefined;
         break;
       }
-      if (!texts.length && !row.calls.length)
-        continue;
-      const previous = responsesMessages.at(-1);
-      if (previous?.role === "assistant") {
-        previous.calls.push(...row.calls);
-        previous.wireCalls?.push(...row.wireCalls ?? []);
-        previous.responseTexts?.push(...texts);
-      } else
-        responsesMessages.push({
-          ...row,
-          calls: [...row.calls],
-          ...row.wireCalls ? { wireCalls: [...row.wireCalls] } : {},
-          responseTexts: [...texts]
-        });
+      unsignedAlternatives ||= alternatives.fallback !== undefined;
+      appendResponse(responsesMessages, row, texts);
+      appendResponse(fallbackMessages, row, alternatives.fallback ?? texts);
+      appendResponse(coldMessages, row, alternatives.cold ?? texts);
     }
   }
   const plan = piChatHistoryPlan(projectedMessages, model);
@@ -36428,6 +37071,7 @@ function buildPiPreparedStructure(messages, model, prepareUser, host = "omp") {
     ...responsesApi && !responsesMessages ? { structuralSkipReason: "Responses history transform is not modeled" } : model?.api === "openai-completions" && !chatMessages ? { structuralSkipReason: "Chat history transform is not modeled" } : {},
     ...chatMessages ? { chatMessages } : {},
     ...responsesMessages ? { responsesMessages } : {},
+    ...responsesMessages && unsignedAlternatives ? { responsesAlternatives: [fallbackMessages, coldMessages] } : {},
     ...model?.api ? { api: model.api } : {},
     ...model?.api?.startsWith("google-") ? {
       googleFunctionIds: object8(model.compat)?.supportsFunctionPartId === true
@@ -36744,6 +37388,10 @@ function piPreparedStructureMismatch(payload, prepared, onImageTrim) {
     const chat = !!body && Array.isArray(body.messages) && (prepared?.api === "openai-completions" || body.system === undefined) && body.input === undefined && body.inferenceConfig === undefined;
     stage = "prepared rows";
     expectedRows = responses && prepared?.responsesMessages ? prepared.responsesMessages : chat && prepared?.chatMessages ? prepared.chatMessages : prepared?.messages;
+    if (responses && rows && prepared?.responsesAlternatives) {
+      const actual = rows;
+      expectedRows = [prepared.responsesMessages, ...prepared.responsesAlternatives].find((candidate) => candidate?.length === actual.length && candidate.every((expected, index) => JSON.stringify(expected.responseTexts) === JSON.stringify(actual[index].responseTexts))) ?? expectedRows;
+    }
     if (expectedRows && imageProjection && imageBudget)
       expectedRows = trimPreparedImageRows(expectedRows, imageBudget, trimmed);
     if (!rows || !expectedRows)
@@ -38520,7 +39168,7 @@ function registerPiGuardedContext(pi, handler, options = {}) {
         inputs = messageSnapshots(event.messages);
         active.inputMessages = inputs;
       }
-      const result = await budget.waitMandatory(Promise.resolve(withSqliteTransformPass2(() => handler(event, ctx, budget))));
+      const result = await budget.waitMandatory(Promise.resolve(withSqliteTurnDeadline2(() => Math.max(0, budget.remainingOutcome() - PI_CONTEXT_BUDGET.completionReserveMs), () => withSqliteTransformPass2(() => handler(event, ctx, budget)))));
       if (result?.messages) {
         const prepared = preparePiDispatch(result.messages, fenceEnabled ? ctx.model : undefined, fenceEnabled);
         if (prepared.messages !== result.messages)
@@ -38788,13 +39436,15 @@ function recordPiUpperEstimateReclaim(db, cursor, reservation) {
   pendingInput.delete(cursor.sessionId);
 }
 function releasePiUpperEstimateReclaim(db, cursor, reservation) {
-  if (!updateReplayDocument(db, cursor.sessionId, (doc) => {
-    if (claimFrom(doc[KEY2], cursor.sessionId)?.reservation !== reservation)
-      return false;
-    delete doc[KEY2];
-    return true;
-  }))
-    throw new Error("Could not release upper-estimate reclaim");
+  withoutSqliteTransformPass2(() => withSqliteTurnDeadline2(() => 0, () => {
+    if (!updateReplayDocument(db, cursor.sessionId, (doc) => {
+      if (claimFrom(doc[KEY2], cursor.sessionId)?.reservation !== reservation)
+        return false;
+      delete doc[KEY2];
+      return true;
+    }))
+      throw new Error("Could not release upper-estimate reclaim");
+  }));
 }
 function resetPiUpperEstimateReclaim(db, sessionId) {
   if (!claimFrom(readReplayEnvelope(db, sessionId)[KEY2], sessionId))
@@ -38806,6 +39456,21 @@ function resetPiUpperEstimateReclaim(db, sessionId) {
     throw new Error("Could not clear upper-estimate reclaim cursor");
 }
 
+// src/pi-historian-turn-wait.ts
+var foregroundWaits = new Map;
+function inPiHistorianRootContext(sessionId, operation) {
+  return inRootAsyncContext2(() => withSqliteTurnDeadline2(() => foregroundWaits.get(sessionId)?.() ?? Infinity, operation));
+}
+async function waitForPiHistorianInTurn(sessionId, remainingMs, wait) {
+  foregroundWaits.set(sessionId, remainingMs);
+  try {
+    return await wait();
+  } finally {
+    if (foregroundWaits.get(sessionId) === remainingMs)
+      foregroundWaits.delete(sessionId);
+  }
+}
+
 // src/pi-lkg-fit-envelope.ts
 import { createHash as createHash13 } from "node:crypto";
 function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen, wireSchema) {
@@ -44124,6 +44789,20 @@ function registerPiContextHandler(pi, baseOptions) {
           elapsedMs: performance.now() - fitInputStart,
           extra: inputForFitReclaim ? "snapshot" : "no-snapshot"
         });
+      if (!options.compactionOff && !sessionMeta.isSubagent) {
+        let promptId = null;
+        for (let i = event.messages.length - 1;i >= 0; i--) {
+          const message = event.messages[i];
+          if (message?.role !== "user")
+            continue;
+          const parts = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+          if (!hasMeaningfulUserText2(parts))
+            continue;
+          promptId = entryIds?.[i] ?? null;
+          break;
+        }
+        maintainExecuteFloorMark(options.db, sessionId, promptId, usagePercentage < effectiveExecuteThresholdPercentage);
+      }
       const pipelineArgs = {
         recoveryPrefix: recovery.prefix,
         recoveryRebuildReason: recovery.rebuildReason,
@@ -44225,6 +44904,65 @@ function registerPiContextHandler(pi, baseOptions) {
       };
       if (!options.compactionOff)
         assertPiTagSnapshotReady(options.db, sessionId);
+      let historianEvaluatedThisPass = false;
+      const historian = options.historian;
+      const scheduleHistorian = (result) => {
+        if (historianEvaluatedThisPass)
+          return;
+        historianEvaluatedThisPass = true;
+        const tHistorianScheduling = performance.now();
+        budget.stage = "historian scheduling";
+        if (historian && !options.compactionOff && budget.remainingWork() > 0) {
+          guardSqliteTransformPass2({
+            assert: budget.assert,
+            remainingMs: budget.remainingWork
+          });
+          try {
+            budget.assert();
+            maybeFireHistorian({
+              startGuard: () => {
+                if (!budget.completed)
+                  budget.assertOwner();
+                if (budget.abandoned || budget.remainingWork() === 0)
+                  throw new PiContextDeadlineError(budget.diagnostic());
+              },
+              pi,
+              ctx,
+              sessionId,
+              db: options.db,
+              historian,
+              isFirstContextPassForSession,
+              activeTags: result.activeTags,
+              eligiblePendingDropTagIds: result.eligiblePendingDropTagIds,
+              rawMessageProvider,
+              ordinalAlignment: ordinalAlignment(),
+              taggerFloor,
+              sessionMeta,
+              piUsage,
+              pressureSnapshot: {
+                percentage: usagePercentage,
+                inputTokens: usageInputTokens
+              },
+              minimumPercentage: usagePercentage,
+              liveIsRawBranchEstimate: piLiveUsageIsRawBranchEstimate,
+              historianStateSnapshot: historianStateForPass,
+              publishedHistoryRide: isCacheBusting,
+              primaryExecute: schedulerDecision === "execute" && !sessionMeta.isSubagent,
+              signedThinkingHeld: result.strictThinkingKept
+            });
+          } catch (error) {
+            budget.assertOutcome();
+            sessionLog2(sessionId, `historian scheduling skipped: ${String(error)}`);
+          } finally {
+            guardSqliteTransformPass2({
+              assert: budget.assertOutcome,
+              remainingMs: budget.remainingOutcome
+            });
+          }
+        }
+        logTransformTiming(sessionId, "historianScheduling", tHistorianScheduling);
+      };
+      pipelineArgs.evaluateHistorianBeforeReclaim = scheduleHistorian;
       let result = await budget.waitMandatory(runPipeline(pipelineArgs));
       observePipelineResultForTests(sessionId, result);
       logTransformTiming(sessionId, "runPipeline", tRunPipeline);
@@ -44256,57 +44994,7 @@ function registerPiContextHandler(pi, baseOptions) {
         }, piDecisionSnapshotNewestAssistant, budget.assertDecisionPublication);
       } : undefined;
       logTransformTiming(sessionId, "transformDecisionAndReuseState", tTransformDecision);
-      const tHistorianScheduling = performance.now();
-      const historian = options.historian;
-      budget.stage = "historian scheduling";
-      if (historian && !options.compactionOff && budget.remainingWork() > 0) {
-        guardSqliteTransformPass2({
-          assert: budget.assert,
-          remainingMs: budget.remainingWork
-        });
-        try {
-          budget.assert();
-          maybeFireHistorian({
-            startGuard: () => {
-              if (!budget.completed)
-                budget.assertOwner();
-              if (budget.abandoned || budget.remainingWork() === 0)
-                throw new PiContextDeadlineError(budget.diagnostic());
-            },
-            pi,
-            ctx,
-            sessionId,
-            db: options.db,
-            historian,
-            isFirstContextPassForSession,
-            activeTags: result.activeTags,
-            eligiblePendingDropTagIds: result.eligiblePendingDropTagIds,
-            rawMessageProvider,
-            ordinalAlignment: ordinalAlignment(),
-            taggerFloor,
-            sessionMeta,
-            piUsage,
-            pressureSnapshot: {
-              percentage: usagePercentage,
-              inputTokens: usageInputTokens
-            },
-            minimumPercentage: usagePercentage,
-            liveIsRawBranchEstimate: piLiveUsageIsRawBranchEstimate,
-            historianStateSnapshot: historianStateForPass,
-            publishedHistoryRide: isCacheBusting,
-            signedThinkingHeld: result.strictThinkingKept
-          });
-        } catch (error) {
-          budget.assertOutcome();
-          sessionLog2(sessionId, `historian scheduling skipped: ${String(error)}`);
-        } finally {
-          guardSqliteTransformPass2({
-            assert: budget.assertOutcome,
-            remainingMs: budget.remainingOutcome
-          });
-        }
-      }
-      logTransformTiming(sessionId, "historianScheduling", tHistorianScheduling);
+      scheduleHistorian(result);
       const tPostTransform = performance.now();
       let outputMessages = result.messages;
       let assertTailHygieneLastWriter;
@@ -44693,7 +45381,7 @@ function registerPiContextHandler(pi, baseOptions) {
                   const pending = inFlightHistorian.get(sessionId);
                   if (pending) {
                     budget.stage = "headless fit historian";
-                    await budget.wait(pending);
+                    await waitForPiHistorianInTurn(sessionId, () => Math.max(0, budget.remainingOutcome() - PI_CONTEXT_BUDGET.completionReserveMs), () => budget.wait(pending));
                   }
                 }
                 budget.stage = "outgoing fit reclaim";
@@ -44738,7 +45426,7 @@ function registerPiContextHandler(pi, baseOptions) {
                 estimate = estimatePiOutgoingInputTokens(outputMessages, envelope, undefined, outgoingFitLimit);
               } finally {
                 if (!reclaimCompleted && upperCursor && reservation)
-                  withoutSqliteTransformPass2(() => releasePiUpperEstimateReclaim(options.db, upperCursor, reservation));
+                  releasePiUpperEstimateReclaim(options.db, upperCursor, reservation);
               }
             }
           }
@@ -45105,7 +45793,7 @@ function spawnPiHistorianRun(args) {
   const holderId = crypto3.randomUUID();
   const controller = new AbortController;
   historianAbortControllers.set(sessionId, controller);
-  const runPromise = inRootAsyncContext2(() => (async () => {
+  const runPromise = inPiHistorianRootContext(sessionId, () => (async () => {
     await new Promise((resolve) => setTimeout(resolve, 0));
     if (controller.signal.aborted)
       return;
@@ -45135,6 +45823,7 @@ function spawnPiHistorianRun(args) {
         runner: historian.runner,
         signal: controller.signal,
         historianModel: historian.model,
+        modelConfigKey: historian.modelConfigKey,
         fallbackModels: historian.fallbackModels,
         fallbackModelId,
         historianChunkTokens: historian.historianChunkTokens,
@@ -45457,7 +46146,7 @@ Historian previously failed ${failureCount} time(s), so Magic Context is retryin
         idleExpiry: false,
         emergency: usage.percentage >= historianForceMaterializationPercentage
       }
-    }, args.eligiblePendingDropTagIds);
+    }, args.eligiblePendingDropTagIds, args.primaryExecute === true);
     if (!trigger.shouldFire) {
       sessionLog2(sessionId, `historian trigger eval: shouldFire=false (no trigger condition met)`);
       try {
@@ -45557,7 +46246,7 @@ function captureReasoningMutationRollback(messages) {
 async function runCompactionOffPipeline(args) {
   let injectionResult = null;
   const transcript = [...args.messages];
-  let headChangedUnderSignedTurn = false;
+  let headChangedUnderSignedThinking = false;
   if (args.injection) {
     const state = {
       sessionId: args.sessionId,
@@ -45579,10 +46268,16 @@ async function runCompactionOffPipeline(args) {
     if (servedBeforeFirstRender !== undefined) {
       const headCount = injectionResult?.syntheticLeadingCount ?? 0;
       const head = JSON.stringify(args.messages.slice(0, headCount));
-      headChangedUnderSignedTurn = servedBeforeFirstRender === null || JSON.stringify(servedBeforeFirstRender.slice(0, headCount)) !== head;
+      headChangedUnderSignedThinking = servedBeforeFirstRender === null || JSON.stringify(servedBeforeFirstRender.slice(0, headCount)) !== head;
+    } else if (!signedTurnHoldsHead && args.reasoningClearing?.prefixBound === true && (injectionResult?.m0Materialized === true || injectionResult?.m1RenderedCoverage != null)) {
+      const served = args.readLastServedMessages?.() ?? null;
+      const headCount = injectionResult?.syntheticLeadingCount ?? 0;
+      headChangedUnderSignedThinking = served === null || JSON.stringify(served.slice(0, headCount)) !== JSON.stringify(args.messages.slice(0, headCount));
+      if (headChangedUnderSignedThinking)
+        sessionLog2(args.sessionId, "compaction-off fold changed the head: stripping signed thinking");
     }
   }
-  if (headChangedUnderSignedTurn)
+  if (headChangedUnderSignedThinking)
     applyPiProactiveThinkingStrip({
       db: args.db,
       sessionId: args.sessionId,
@@ -45896,6 +46591,7 @@ async function runPipeline(args) {
     logTransformTiming(args.sessionId, "injectTemporalMarkers", tTemporal);
   }
   let nativeRemovalInputs;
+  let probingExecuteRemoval = false;
   try {
     nativeRemovalInputs = getNativeReplayState(args.db, args.sessionId).toolInputs;
   } catch {}
@@ -45907,7 +46603,7 @@ async function runPipeline(args) {
       sessionId: args.sessionId,
       callId,
       saved: nativeRemovalInputs,
-      canApply: isCacheBustingPass
+      canApply: isCacheBustingPass || probingExecuteRemoval
     }),
     authorizeToolRemovals: (callIds) => preparePiToolRemovalMeasurements({
       db: args.db,
@@ -45939,6 +46635,7 @@ async function runPipeline(args) {
   const heldIdleExpiryRebuild = protectedSignedPrefix && piHardSignals?.cacheExpired === true;
   const systemPrefixChangedThisPass = !prefixPreflightContended && effectiveSystemChangedThisPass;
   const rideSignals = {
+    executeReclaim: false,
     subagentExecute: args.sessionMeta.isSubagent && args.schedulerDecision === "execute",
     hardFold: foldBustsServedPrefixThisPass || systemPrefixChangedThisPass || firstRenderBust || heldIdleExpiryRebuild || isCacheBustingPass,
     force: (args.forceMaterialization === true || emergencyDropEligible) && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
@@ -46051,11 +46748,14 @@ async function runPipeline(args) {
       }
     }
   }
-  if (args.temporalAwareness && isCacheBustingPass && !protectedSignedPrefix) {
+  const applyTemporalOnRide = () => {
+    if (!args.temporalAwareness || !isCacheBustingPass || protectedSignedPrefix)
+      return;
     temporalDecisions = freezeTemporalDecisions(args.db, args.sessionId, temporalCandidates);
     if (injectPiTemporalMarkers(args.messages, temporalDecisions, stableIdResolver) > 0)
       recordFirstApplicationWireEdit(true);
-  }
+  };
+  applyTemporalOnRide();
   logPiUnresolvedIdentities(args.sessionId, [
     ...guardPiToolAllocations(args.db, args.sessionId, args.messages, stableIdResolver, args.tagger, fallbackIndex.guardIndexes),
     ...guardPiMessageAllocations(args.db, args.sessionId, entryFingerprintByMessageId)
@@ -46084,6 +46784,7 @@ async function runPipeline(args) {
     args.assertCurrentPass?.();
     return tagTranscript(args.sessionId, { ...transcript, messages: taggingView }, args.tagger, args.db, {
       skipPrefixInjection: !ctxReduceCallable,
+      preserveTagOnlyAssistantText: true,
       entryFingerprintByMessageId,
       reuseMessageIds: textIdentityPlan.reusableMessageIds,
       textIdentityDriftMessageIds: textIdentityPlan.driftedMessageIds,
@@ -46205,6 +46906,62 @@ async function runPipeline(args) {
   const protectionWindowForPass = getProtectionWindowForSession(args.db, args.sessionId, protectionFloorResolution.floor);
   const protectedTagNumbersForPass = usesTokenProtection ? protectionWindowForPass.protectedTagNumbers : newestActiveTagNumbersByCount(getActiveTagsBySession2(args.db, args.sessionId), args.protectedTags);
   const pendingOperationTags = pendingOps.length > 0 ? getTagsForPendingOperations2(args.db, args.sessionId, pendingOps.map((operation) => operation.tagId), usesTokenProtection ? 0 : args.protectedTags, RECENT_TOOL_SKELETON_WINDOW) : [];
+  if (!args.sessionMeta.isSubagent && args.schedulerDecision === "execute") {
+    args.evaluateHistorianBeforeReclaim?.({
+      activeTags: getActiveTagsBySession2(args.db, args.sessionId),
+      eligiblePendingDropTagIds,
+      strictThinkingKept: protectedSignedPrefix
+    });
+  }
+  rideSignals.executeReclaim = originateExecuteReclaim({
+    db: args.db,
+    sessionId: args.sessionId,
+    primaryExecute: !args.sessionMeta.isSubagent && args.schedulerDecision === "execute" && args.contextUsage.percentage < forceMaterializationPercentage,
+    alreadyBusting: isCacheBustingPass || identityRebuild,
+    summaryCanCome: args.sessionMeta.compartmentInProgress || inFlightHistorian.has(args.sessionId) || (prefixPreflightContended || protectedSignedPrefix) && (deferredHistoryRefreshSessions.has(args.sessionId) || deferredMaterializationSessions.has(args.sessionId) || historyRefreshSessions.has(args.sessionId)) || readExecuteReclaimState(args.db, args.sessionId).floorOrdinal !== null,
+    reclaimableTokens: estimateExecuteReclaimTokens({
+      db: args.db,
+      sessionId: args.sessionId,
+      pendingOps,
+      tags: pendingOperationTags,
+      targets: newTargets,
+      protectedTagIds: new Set([
+        ...protectedTagNumbersForPass,
+        ...protectedToolTags
+      ]),
+      probePreparation: (targets) => {
+        const saved = nativeRemovalInputs;
+        const rollback = Symbol("execute removal probe");
+        const allowed = new Set;
+        try {
+          nativeRemovalInputs = saved && new Map(saved);
+          probingExecuteRemoval = true;
+          args.db.transaction(() => {
+            for (const [number, target] of targets) {
+              if (target.prepareDrop?.() !== false)
+                allowed.add(number);
+            }
+            throw rollback;
+          }).immediate();
+        } catch (error) {
+          if (error !== rollback)
+            allowed.clear();
+        } finally {
+          nativeRemovalInputs = saved;
+          probingExecuteRemoval = false;
+        }
+        return allowed;
+      }
+    }),
+    usableWindow: args.usableSoft ?? args.contextUsage.inputTokens / (args.contextUsage.percentage / 100)
+  });
+  if (rideSignals.executeReclaim) {
+    isCacheBustingPass = reclaimRidePermitted(rideSignals, ridePermissionGate);
+    publishedWorkDrainAllowed = isCacheBustingPass;
+    shouldRunHeuristics ||= isCacheBustingPass && args.heuristics !== undefined;
+    stripUnheldSignedTurnOnBust();
+    applyTemporalOnRide();
+  }
   const deferredMaterialize = canConsumeDeferredLate && deferredMaterializationWasPending;
   const deferredHistoryRefresh = canConsumeDeferredLate && deferredHistoryRefreshWasPending;
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
@@ -46937,6 +47694,8 @@ async function runPipeline(args) {
         servedTagNumbers.add(tag.tagNumber);
     }
   }
+  if (bustedThisPass)
+    clearExecuteReclaimState(args.db, args.sessionId);
   return {
     messages: outputMessages,
     recoveryNormalized,
@@ -50592,7 +51351,7 @@ function stripTagPrefixFromAssistantMessage(message) {
     const textPart = part;
     if (typeof textPart.text !== "string")
       continue;
-    const stripped = stripPersistedAssistantText(textPart.text);
+    const stripped = stripPersistedAssistantText(textPart.text, message.provider === "anthropic");
     if (stripped !== textPart.text) {
       textPart.text = stripped;
       mutated = true;
@@ -50600,7 +51359,7 @@ function stripTagPrefixFromAssistantMessage(message) {
   }
   return mutated;
 }
-function strippedAssistantContent(content) {
+function strippedAssistantContent(content, provider = "anthropic") {
   if (!Array.isArray(content))
     return;
   let copy;
@@ -50611,7 +51370,7 @@ function strippedAssistantContent(content) {
     }
     if (typeof part.text !== "string")
       continue;
-    const stripped = stripPersistedAssistantText(part.text);
+    const stripped = stripPersistedAssistantText(part.text, provider === "anthropic");
     if (stripped === part.text)
       continue;
     copy ??= content.slice();
@@ -50628,7 +51387,7 @@ function registerOmpAssistantMessageStrip(pi, isActive) {
       const message = event?.message;
       if (message?.role !== "assistant")
         return;
-      const content = strippedAssistantContent(message.content);
+      const content = strippedAssistantContent(message.content, message.provider ?? "unknown");
       return content === undefined ? undefined : { content };
     } catch {
       return;
@@ -51097,6 +51856,7 @@ function resolveHistorianFromConfig(config, harness = PI_HARNESS_KIND, modelRegi
   return {
     runner: new PiSubagentRunner,
     model,
+    modelConfigKey: resolved.primary?.sourceConfigKey,
     fallbackModels,
     historianChunkTokens,
     historianContextLimit: resolveKnownHistorianContextLimit(model),
@@ -51174,7 +51934,7 @@ async function src_default(pi) {
   let openFailureCause = null;
   const openStorage = async () => {
     try {
-      return await openDatabaseAsync();
+      return await openDatabaseAsync({ nativeTurnDeadlines: true });
     } catch (error) {
       openFailureCause = error instanceof Error ? error.message : String(error);
       return null;
@@ -51575,6 +52335,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
   const todowriteOverlayEnabled = todowriteEnabled && bootProjectDeps.config.todowrite.overlay;
   registerMagicContextTools(pi, {
     rerankConnectionFile: config.subc?.connection_file,
+    rerankConfig: config.rerank,
     expandTools: config.historian?.expand_tools,
     db,
     ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,