@cortexkit/pi-magic-context 0.43.1 → 0.44.0

package/dist/index.js

@@ -9,7 +9,7 @@ import {
   log,
   sessionLog,
   flushLogger
-} from "./index-bfd52y8p.js";
+} from "./index-tfzybajk.js";
 import {
   COMPACTION_ENABLED_PATH,
   isDreamerRunnable,
@@ -100,7 +100,9 @@ import {
   escapeXmlContent,
   getModuleNoteEvaluationBridge,
   getContextStoreUuid,
+  getAuthorityManagedMarker,
   drainMirrorPages,
+  V2_MEMORY_CATEGORIES,
   parseCompartmentOutput,
   resolveWorkspaceShareCategories,
   resolveWorkspaceIdentitySet,
@@ -172,8 +174,8 @@ import {
   clearDetectedContextLimit,
   getStrippedPlaceholderIds,
   applyStrippedPlaceholderDelta,
-  NEWEST_REASONING_BEARING_ASSISTANT,
   THINKING_BINDING_RECOVERY_FROZEN_PREFIX,
+  THINKING_BINDING_STRIP_ORDER_END_MARKER,
   thinkingBindingRecoveryFrozenId,
   getThinkingBindingRecoveryTarget,
   armThinkingBindingRecovery,
@@ -402,7 +404,7 @@ import {
   registerTodoStateLifecycle,
   syncCtxMemoryToolEnabled,
   registerMagicContextTools
-} from "./index-kyrajahw.js";
+} from "./index-8ytss1hp.js";
 import {
   CTX_REDUCE_KEEP,
   newestCtxReduceTagNumbers,
@@ -497,6 +499,8 @@ import {
   localBudget,
   calibrationForModelKey,
   historyLocalBudget,
+  SKELETON_REAL_INPUT_MAX_BYTES,
+  toolInputStringBytes,
   setRawMessageProvider2,
   withRawMessageProvider2,
   cleanUserText2,
@@ -512,14 +516,14 @@ import {
   getRawSessionTagKeysThrough2,
   getLegacyProtectedTailStartOrdinal2,
   readSessionChunk2
-} from "./index-822b3fcs.js";
+} from "./index-2kj55q4e.js";
 import {
   pushNotification2
 } from "./index-b3eqj1g6.js";
-import"./index-5v60m046.js";
+import"./index-jscq7067.js";
 import {
   logSlowWriteTransaction
-} from "./index-17102c1m.js";
+} from "./index-mmkdxa5j.js";
 import {
   __toESM
 } from "./index-22jkk6wg.js";
@@ -527,7 +531,7 @@ import {
 // src/index.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join8, resolve as resolve3 } from "node:path";
+import { join as join8, resolve as resolve4 } from "node:path";
 
 // ../plugin/src/config/live-snapshot.ts
 import { createHash } from "node:crypto";
@@ -1141,7 +1145,9 @@ var OVERFLOW_PATTERNS = [
   /prompt too long; exceeded (?:max )?context length/i,
   /too large for model with \d+ maximum context length/i,
   /model_context_window_exceeded/i,
-  /context size has been exceeded/i
+  /context size has been exceeded/i,
+  /prepared prompt exceeds engine max_context/i,
+  /prompt exceeds (?:the )?.{0,32}\bmax_context\b/i
 ];
 var LIMIT_EXTRACTION_PATTERNS = [
   { pattern: /maximum prompt length is (\d+)/i, provenance: "prompt_only" },
@@ -1162,11 +1168,15 @@ var LIMIT_EXTRACTION_PATTERNS = [
     pattern: />\s*(\d+)\s*(?:tokens?\s*)?(?:maximum|max|limit)\b/i,
     provenance: "prompt_only"
   },
+  { pattern: /prepared prompt exceeds engine max_context\s+(\d+)/i, provenance: "unknown" },
+  { pattern: /prompt exceeds (?:the )?.{0,32}\bmax_context\s+(\d+)/i, provenance: "unknown" },
   { pattern: /max(?:imum)?.*context.*?(\d+)/i, provenance: "unknown" }
 ];
 var MIN_PLAUSIBLE_LIMIT = 1024;
 var MAX_PLAUSIBLE_LIMIT = 1e7;
 var THINKING_BINDING_MISMATCH_PATTERN = /bound to a different conversation/i;
+var THINKING_BINDING_FAILING_PATH_PATTERN = /^\s*(messages\.\d+\.content\.\d+):/;
+var THINKING_BINDING_FIRST_CHANGED_PATTERN = /first at `?(messages\.\d+\.content\.\d+)`?/;
 function extractErrorMessage(error) {
   if (!error)
     return "";
@@ -1195,29 +1205,6 @@ function extractErrorMessage(error) {
   }
   return String(error);
 }
-function extractThinkingBindingMessageId(error) {
-  if (!error || typeof error !== "object")
-    return;
-  const seen = new Set;
-  const queue = [error];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current || seen.has(current))
-      continue;
-    seen.add(current);
-    const record = current;
-    for (const key of ["message_id", "messageID", "messageId"]) {
-      const value = record[key];
-      if (typeof value === "string" && value.length > 0)
-        return value;
-    }
-    for (const value of Object.values(record)) {
-      if (value && typeof value === "object")
-        queue.push(value);
-    }
-  }
-  return;
-}
 function extractExplicitHttpStatus(error) {
   if (!error || typeof error !== "object")
     return;
@@ -1247,13 +1234,20 @@ function detectThinkingBindingMismatch(error) {
   if (explicitStatus !== undefined && explicitStatus !== 400 || !THINKING_BINDING_MISMATCH_PATTERN.test(message)) {
     return { isBindingMismatch: false };
   }
-  const messageId = extractThinkingBindingMessageId(error);
+  const failingBlockPath = THINKING_BINDING_FAILING_PATH_PATTERN.exec(message)?.[1];
+  const firstChangedPath = THINKING_BINDING_FIRST_CHANGED_PATTERN.exec(message)?.[1];
   return {
     isBindingMismatch: true,
     matchedPattern: "bound to a different conversation",
-    ...messageId ? { messageId } : {}
+    ...failingBlockPath ? { failingBlockPath } : {},
+    ...firstChangedPath ? { firstChangedPath } : {}
   };
 }
+function isPrefixBoundThinkingModel(providerID, modelID) {
+  if (providerID?.toLowerCase() !== "anthropic" || !modelID)
+    return false;
+  return isFable51ThinkingBindingModel(providerID, modelID) || /(?:^|[-_.])opus[-_.]?5[-_.]5(?:$|[-_.])/i.test(modelID);
+}
 function isFable51ThinkingBindingModel(providerID, modelID) {
   if (providerID?.toLowerCase() !== "anthropic" || !modelID)
     return false;
@@ -1586,6 +1580,31 @@ async function runSessionProjectBackfill(db, source, options = {}) {
   return result;
 }
 
+// ../plugin/src/features/magic-context/storage-unavailable-reason.ts
+function describeStorageUnavailability(fallbackCause) {
+  const migration = getMigrationOnOpenRefusal();
+  const blockingProcesses = migration?.blockingProcesses ?? migration?.serverPids.map((pid) => ({ kind: "process", pid })) ?? [];
+  if (migration && (blockingProcesses.length > 0 || migration.unreadableFile)) {
+    return {
+      kind: "migration_guard",
+      persistedVersion: migration.persistedVersion,
+      supportedVersion: migration.supportedVersion,
+      blockingProcesses,
+      ...migration.unreadableFile ? { unreadableFile: migration.unreadableFile } : {},
+      ...migration.unreadableArm ? { unreadableArm: migration.unreadableArm } : {}
+    };
+  }
+  const fence = getSchemaFenceRejection();
+  if (fence) {
+    return {
+      kind: "schema_fence",
+      persistedVersion: fence.persistedVersion,
+      supportedVersion: fence.supportedVersion
+    };
+  }
+  return { kind: "storage_failure", cause: fallbackCause };
+}
+
 // ../plugin/src/features/magic-context/v22-deferred-backfill.ts
 import { createHash as createHash2 } from "node:crypto";
 import { realpathSync } from "node:fs";
@@ -1824,6 +1843,8 @@ function setCtxReduceRegisteredGlobally(registered) {
 var availabilityBySession = new BoundedSessionMap(1000);
 var permissionDeniedBySession = new BoundedSessionMap(2000);
 var ctxReducePermissionDenyLogged = new BoundedSessionMap(1000);
+var ctxReduceSpawnPermissionDenied = new BoundedSessionMap(1000);
+var ctxReduceSpawnPermissionReads = new Map;
 
 // ../plugin/src/hooks/magic-context/derive-budgets.ts
 var TRIGGER_BUDGET_PERCENTAGE = 0.05;
@@ -2780,6 +2801,11 @@ var USER_FACING_FAILURES = {
     sentence: "Some finished background sessions could not be removed from this host.",
     action: "They are removed automatically the next time Magic Context runs inside a registered OpenCode service."
   },
+  historian_saved_history_misaligned: {
+    code: "MC-H03",
+    sentence: "History compression is paused because this session's saved summaries no longer line up with its messages.",
+    action: "Run /ctx-recomp to rebuild them."
+  },
   recomp_unavailable: {
     code: "MC-R01",
     sentence: "History compression could not be rebuilt.",
@@ -2795,6 +2821,11 @@ var USER_FACING_FAILURES = {
     sentence: "Memory maintenance could not reach its model.",
     action: "Check the model connection, then run /ctx-dream again."
   },
+  dream_step_limit: {
+    code: "MC-D10",
+    sentence: "Memory maintenance stopped at its hidden agent step limit.",
+    action: "This task needs less work per run; changing the model connection will not help."
+  },
   dream_empty_completion: {
     code: "MC-D03",
     sentence: "Memory maintenance received no usable response.",
@@ -2950,11 +2981,21 @@ var USER_FACING_FAILURES = {
     sentence: "History compression is paused while the engine syncs.",
     action: "Retry in a moment."
   },
+  history_compression_needs_message: {
+    code: "MC-C12",
+    sentence: "History compression has not seen this session since Magic Context reconnected.",
+    action: "Send a message in this session first, then run /ctx-wrapup again."
+  },
   context_service_unavailable: {
     code: "MC-C10",
     sentence: "Magic Context is temporarily unavailable.",
     action: "Retry in a moment."
   },
+  store_ahead_of_binary: {
+    code: "MC-C13",
+    sentence: "Magic Context refused to start: its store (store.db) was migrated by a newer ck-mc build than the one running.",
+    action: "Update ck-mc, or roll back by restoring ck-mc together with context.db and store.db from the same backup."
+  },
   compaction_marker_missing: {
     code: "MC-C11",
     sentence: "The history boundary marker is missing from the OpenCode store, so requests carry the full session.",
@@ -2970,11 +3011,6 @@ var USER_FACING_FAILURES = {
     sentence: "Memory authority is inconsistent between the host and module.",
     action: "Run `ck doctor drain-authority` before changing Rust mode."
   },
-  rust_mode_unsupported: {
-    code: "MC-S06",
-    sentence: "Experimental Rust transform mode is not available on this OpenCode host.",
-    action: 'Magic Context is running its TypeScript mode instead; set `transform_mode` to "ts" to stop requesting Rust.'
-  },
   dreamer_task_failing: {
     code: "MC-S05",
     sentence: "A background maintenance task keeps failing on its schedule.",
@@ -3006,6 +3042,7 @@ function renderCapabilityRefusal(capability) {
 var DREAM_FAILURE_KEYS = {
   provider_timeout: "dream_provider_timeout",
   provider_error: "dream_provider_error",
+  step_limit: "dream_step_limit",
   empty_completion: "dream_empty_completion",
   no_models: "dream_no_models",
   child_aborted: "dream_child_aborted",
@@ -3035,6 +3072,10 @@ function renderEmbeddingFailure(failureClass, style = "markdown") {
   return renderUserFacingFailure(EMBEDDING_FAILURE_KEYS[failureClass], style);
 }
 
+// src/dreamer/index.ts
+import { homedir as homedir2 } from "node:os";
+import { parse, resolve as resolve3 } from "node:path";
+
 // ../plugin/src/features/magic-context/dreamer/open-opencode-db.ts
 function openOpenCodeDb() {
   const resolution = resolveOpenCodeDbPath();
@@ -3192,6 +3233,37 @@ class HiddenCompletionRefusal extends Error {
     this.name = "HiddenCompletionRefusal";
   }
 }
+// ../plugin/src/v2/hooks/hidden-child.ts
+var HIDDEN_HISTORIAN_AGENT = "historian";
+var HIDDEN_DREAMER_AGENT = "dreamer-classifier";
+var HIDDEN_CURATE_AGENT = DREAMER_AGENT;
+var READ_TOOLS = ["read", "grep", "glob"];
+var AGENT_TOOLS = {
+  [HIDDEN_HISTORIAN_AGENT]: [],
+  [HIDDEN_DREAMER_AGENT]: [],
+  [HIDDEN_CURATE_AGENT]: ["ctx_memory", "ctx_memory_list"],
+  [DREAMER_MEMORY_MAPPER_AGENT]: READ_TOOLS,
+  [DREAMER_PRIMER_INVESTIGATOR_AGENT]: [...READ_TOOLS, "ctx_search"],
+  [DREAMER_RETROSPECTIVE_AGENT]: ["ctx_search"]
+};
+var AGENT_STEPS = {
+  [HIDDEN_CURATE_AGENT]: 150,
+  [DREAMER_MEMORY_MAPPER_AGENT]: 60,
+  [DREAMER_DOCS_AGENT]: 60,
+  [DREAMER_PRIMER_INVESTIGATOR_AGENT]: 40,
+  [DREAMER_RETROSPECTIVE_AGENT]: 40
+};
+class HiddenAgentStepLimit extends Error {
+  agent;
+  cap;
+  constructor(agent, cap) {
+    super(`Hidden agent ${agent} exceeded its ${cap}-step limit`);
+    this.name = "HiddenAgentStepLimit";
+    this.agent = agent;
+    this.cap = cap;
+  }
+}
+
 // ../plugin/src/shared/assistant-message-extractor.ts
 function asSessionMessage(value) {
   if (!isRecord(value))
@@ -3290,6 +3362,14 @@ function copyPromptArgs(args, body) {
   return { ...args, body: { ...body } };
 }
 var promptFailureDetails = new WeakMap;
+function isHostTimeoutError(error) {
+  return error !== null && typeof error === "object" && error.name === "TimeoutError";
+}
+function isPromptTimeoutError(error) {
+  if (isHostTimeoutError(error))
+    return true;
+  return error instanceof Error && /^prompt timed out after \d+ms$/.test(error.message);
+}
 function getPromptFailureDetail(error) {
   return error !== null && typeof error === "object" ? promptFailureDetails.get(error) ?? null : null;
 }
@@ -3346,9 +3426,13 @@ function parseModelSuggestion(error) {
     suggestion: suggestionMatch[1].trim()
   };
 }
+function externalAbortMessage(signal) {
+  const reason = signal.reason;
+  return `prompt aborted by external signal${reason instanceof Error && /^lease_(?:lost|expired):/.test(reason.message) ? `: ${reason.message}` : ""}`;
+}
 async function promptWithTimeout(client, args, timeoutMs, signal, transport) {
   if (signal?.aborted) {
-    throw new Error("prompt aborted by external signal");
+    throw new Error(externalAbortMessage(signal));
   }
   const controller = new AbortController;
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -3368,7 +3452,7 @@ async function promptWithTimeout(client, args, timeoutMs, signal, transport) {
       if (!transport || transport.childSessionId) {
         await abortChildRun(client, transport?.childSessionId ?? args.path.id);
       }
-      throw new Error("prompt aborted by external signal");
+      throw new Error(externalAbortMessage(signal));
     }
     if (controller.signal.aborted) {
       if (!transport || transport.childSessionId) {
@@ -3376,6 +3460,11 @@ async function promptWithTimeout(client, args, timeoutMs, signal, transport) {
       }
       throw new Error(`prompt timed out after ${timeoutMs}ms`);
     }
+    if (isHostTimeoutError(error)) {
+      if (!transport || transport.childSessionId) {
+        await abortChildRun(client, transport?.childSessionId ?? args.path.id);
+      }
+    }
     throw error;
   } finally {
     clearTimeout(timeout);
@@ -3385,7 +3474,7 @@ async function promptWithTimeout(client, args, timeoutMs, signal, transport) {
     if (!transport || transport.childSessionId) {
       await abortChildRun(client, transport?.childSessionId ?? args.path.id);
     }
-    throw new Error(signal?.aborted ? "prompt aborted by external signal" : `prompt timed out after ${timeoutMs}ms`);
+    throw new Error(signal?.aborted ? externalAbortMessage(signal) : `prompt timed out after ${timeoutMs}ms`);
   }
 }
 async function abortChildRun(client, sessionId) {
@@ -3401,7 +3490,7 @@ async function abortChildRun(client, sessionId) {
   }
 }
 function isNonRetryable(error, externalSignal) {
-  if (externalSignal?.aborted)
+  if (externalSignal?.aborted || error instanceof HiddenAgentStepLimit)
     return true;
   if (error instanceof Error) {
     if (error.name === "AbortError")
@@ -3411,6 +3500,8 @@ function isNonRetryable(error, externalSignal) {
     if (/^prompt timed out after \d+ms$/.test(error.message))
       return true;
   }
+  if (isHostTimeoutError(error))
+    return true;
   if (detectOverflow(error).isOverflow)
     return true;
   return false;
@@ -3423,11 +3514,14 @@ function shortErr(error) {
 }
 function classifyPromptFailure(error, phase, externalSignal) {
   const message = extractMessage(error);
+  if (error instanceof HiddenAgentStepLimit)
+    return "step_limit";
   if (externalSignal?.aborted || message === "prompt aborted by external signal") {
     return "child_aborted";
   }
-  if (/^prompt timed out after \d+ms$/.test(message))
+  if (/^prompt timed out after \d+ms$/.test(message) || isHostTimeoutError(error)) {
     return "provider_timeout";
+  }
   if (phase === "validation") {
     if (/returned no (?:assistant )?output|no assistant output/i.test(message)) {
       return "empty_completion";
@@ -3644,7 +3738,10 @@ async function promptSyncWithValidatedOutputRetry(client, args, options) {
     }
   }
   log(`[${callContext}] all models exhausted; tried: ${failedAttempts.map((failure) => failure.attempt.label).join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`);
-  throwWithPromptFailure(firstError ?? lastError ?? new Error("All fallback models failed validation"), failedAttempts, args, timeoutMs, options.transport);
+  const cause = lastError ?? firstError;
+  const exhausted = cause instanceof Error ? cause : new Error(String(cause ?? "All fallback models failed validation"));
+  exhausted.message = `All models exhausted (${failedAttempts.map((failure) => failure.attempt.label).join(", ")}): ${exhausted.message}`;
+  throwWithPromptFailure(exhausted, failedAttempts, args, timeoutMs, options.transport);
 }
 // ../plugin/src/shared/normalize-sdk-response.ts
 function normalizeSDKResponse(response, fallback, options) {
@@ -3669,6 +3766,149 @@ function normalizeSDKResponse(response, fallback, options) {
   }
   return fallback;
 }
+// ../plugin/src/shared/prompt-async-transport.ts
+var DEFAULT_POLL_INTERVAL_MS = 1000;
+var DEFAULT_START_GRACE_MS = 30000;
+var MESSAGE_WINDOW = 20;
+function sessionApi(client) {
+  return client?.session;
+}
+function supportsPromptAsync(client) {
+  const session = sessionApi(client);
+  return typeof session?.promptAsync === "function" && typeof session?.status === "function" && typeof session?.messages === "function";
+}
+function createPromptAsyncTransport(client, childSessionId, options = {}) {
+  if (!supportsPromptAsync(client))
+    return;
+  return Object.assign((request) => promptAsyncAndWaitForIdle(client, request, options), { childSessionId });
+}
+function infoOf(message) {
+  const info = message?.info;
+  return info && typeof info === "object" ? info : {};
+}
+function messageId(message) {
+  const id = infoOf(message).id;
+  return typeof id === "string" ? id : null;
+}
+function isSettledAssistant(message) {
+  const info = infoOf(message);
+  if (info.role !== "assistant")
+    return false;
+  return info.time?.completed != null || info.error != null || info.finish != null;
+}
+function unwrapData(response) {
+  if (response && typeof response === "object" && "data" in response) {
+    return response.data;
+  }
+  return response;
+}
+function describeRejection(error) {
+  if (error instanceof Error)
+    return error.message;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function abortError(signal) {
+  return signal.reason ?? new Error("prompt_async wait aborted");
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortError(signal));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError(signal));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function readMessages(session, sessionId, directory, signal) {
+  const response = await session.messages?.({
+    path: { id: sessionId },
+    query: { ...directory ? { directory } : {}, limit: MESSAGE_WINDOW },
+    ...signal ? { signal } : {}
+  });
+  const data = unwrapData(response);
+  return Array.isArray(data) ? data : [];
+}
+async function readStatus(session, sessionId, directory, signal) {
+  try {
+    const response = await session.status?.({
+      ...directory ? { query: { directory } } : {},
+      ...signal ? { signal } : {}
+    });
+    if (response && typeof response === "object" && "error" in response) {
+      if (response.error)
+        return null;
+    }
+    const data = unwrapData(response);
+    if (!data || typeof data !== "object")
+      return null;
+    const entry = data[sessionId];
+    const type = entry?.type;
+    return typeof type === "string" ? type : "idle";
+  } catch (error) {
+    if (signal?.aborted)
+      throw error;
+    return null;
+  }
+}
+async function promptAsyncAndWaitForIdle(client, request, options = {}) {
+  const session = sessionApi(client);
+  if (!session || !supportsPromptAsync(client)) {
+    throw new Error("prompt_async transport is unavailable on this client");
+  }
+  const sessionId = request.path.id;
+  const directory = request.query?.directory;
+  const dir = typeof directory === "string" ? directory : undefined;
+  const signal = request.signal;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const startGraceMs = options.startGraceMs ?? DEFAULT_START_GRACE_MS;
+  const baseline = new Set((await readMessages(session, sessionId, dir, signal)).map(messageId).filter((id) => id !== null));
+  const sent = await session.promptAsync?.(request);
+  if (sent && typeof sent === "object" && "error" in sent) {
+    const rejection = sent.error;
+    if (rejection)
+      throw new Error(`prompt_async was rejected: ${describeRejection(rejection)}`);
+  }
+  const sentAt = Date.now();
+  let sawBusy = false;
+  for (;; ) {
+    await sleep(pollIntervalMs, signal);
+    const status = await readStatus(session, sessionId, dir, signal);
+    if (status === "busy" || status === "retry") {
+      sawBusy = true;
+      continue;
+    }
+    if (status === null)
+      continue;
+    const messages = await readMessages(session, sessionId, dir, signal);
+    const last = messages.at(-1);
+    const lastId = messageId(last);
+    if (last && lastId !== null && !baseline.has(lastId) && isSettledAssistant(last))
+      return;
+    const fresh = messages.some((message) => {
+      const id = messageId(message);
+      return id !== null && !baseline.has(id);
+    });
+    if (sawBusy && fresh)
+      return;
+    if (Date.now() - sentAt >= startGraceMs) {
+      if (fresh)
+        return;
+      throw new Error(`prompt_async did not start a run in child session ${sessionId} within ${startGraceMs}ms`);
+    }
+  }
+}
 // ../plugin/src/shared/summarize-child-stderr.ts
 var MAX_CHILD_STDERR_SUMMARY_LENGTH = 500;
 var CHILD_ERROR_LINE_PATTERN = /^(?:[A-Za-z]*Error|SqliteError|Error)\b[^\n]*/;
@@ -3808,6 +4048,9 @@ function failedInvocationStatus(error) {
   const message = describeError(error).brief;
   if (/timed out after \d+ms|prompt timed out/i.test(message))
     return "timed_out";
+  if (error !== null && typeof error === "object" && error.name === "TimeoutError") {
+    return "timed_out";
+  }
   if (/length-capped|no (?:assistant )?output|empty (?:assistant )?(?:output|text)/i.test(message)) {
     return "empty";
   }
@@ -4869,7 +5112,7 @@ function shouldDiscardLastHistorianCompartment(compartments, chunk) {
 function validateHistorianOutput(text, sessionId, chunk, _priorCompartments, sequenceOffset) {
   const parseStarted = startHistorianPublishStage(sessionId, "parse", `response_chars=${text.length}`);
   const parsed = parseCompartmentOutput(text);
-  finishHistorianPublishStage(sessionId, "parse", parseStarted, "completed", `compartments=${parsed.compartments.length}`);
+  finishHistorianPublishStage(sessionId, "parse", parseStarted, "completed", `compartments=${parsed.compartments.length} dropped_fact_blocks=${parsed.droppedFactBlocks} dropped_facts=${parsed.droppedFacts}`);
   const validationStarted = startHistorianPublishStage(sessionId, "validate");
   const finish = (result) => {
     finishHistorianPublishStage(sessionId, "validate", validationStarted, result.ok ? "completed" : "failed", result.ok ? `compartments=${result.compartments.length}` : `reason=${JSON.stringify(result.error)}`);
@@ -4908,6 +5151,7 @@ function validateHistorianOutput(text, sessionId, chunk, _priorCompartments, seq
     ok: true,
     compartments: mapped.compartments,
     facts: parsed.facts,
+    ...parsed.droppedFactBlocks > 0 ? { droppedFactBlocks: parsed.droppedFactBlocks, droppedFacts: parsed.droppedFacts } : {},
     userObservations: parsed.userObservations.length > 0 ? parsed.userObservations : undefined,
     primerCandidates: parsed.primerCandidates.length > 0 ? parsed.primerCandidates.slice(0, 1) : undefined,
     events: parsed.events.length > 0 ? parsed.events : undefined
@@ -5160,6 +5404,7 @@ function resolveHiddenCompletionExecutor(executor, client, db, directory, entryP
   return createV1HiddenCompletionExecutor(client, db, directory);
 }
 function createV1HiddenCompletionExecutor(client, db, directory) {
+  const asyncChildren = new Set;
   return {
     capabilities: { tools: true, harness: "opencode" },
     async open(run) {
@@ -5176,11 +5421,17 @@ function createV1HiddenCompletionExecutor(client, db, directory) {
         preferResponseOnMissingData: true
       });
       const id = typeof created?.id === "string" ? created.id : "";
+      if (id && run.kind === "dreamer-task")
+        asyncChildren.add(id);
       return { id, childSessionId: id || undefined };
     },
-    async attempt(_handle, request) {
+    async attempt(handle, request) {
       if (!client)
         throw new Error("Hidden completion client is unavailable");
+      if (asyncChildren.has(handle.id) && supportsPromptAsync(client)) {
+        await promptAsyncAndWaitForIdle(client, request);
+        return;
+      }
       await client.session.prompt(request);
     },
     async collect(handle, limit) {
@@ -5208,6 +5459,8 @@ function createV1HiddenCompletionExecutor(client, db, directory) {
       };
     },
     async close(handle, settlement) {
+      if (handle?.id)
+        asyncChildren.delete(handle.id);
       if (!client)
         return;
       await teardownChildSession({
@@ -5219,6 +5472,9 @@ function createV1HiddenCompletionExecutor(client, db, directory) {
     }
   };
 }
+function historianReasoningBudgetDiagnostic(outputTokens) {
+  return `historian ran out of output budget while reasoning (length-capped at ${outputTokens} tokens, no text) — set historian.maxTokens or route historian.model to a low-reasoning lane/variant`;
+}
 async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
     ...args,
@@ -5445,14 +5701,14 @@ async function runHistorianPrompt(args) {
         }
         const backoffMs = getHistorianRetryBackoffMs(retryIndex);
         sessionLog(parentSessionId, `historian retry ${retryIndex + 1}/${MAX_HISTORIAN_RETRIES} after ${backoffMs}ms: ${errorMsg}`);
-        await sleep(backoffMs);
+        await sleep2(backoffMs);
       }
     }
     completion = await executor.collect(handle, 50);
     const lengthCapped = completion.lengthCapped;
     const textResult = completion.text;
     const reasoningResult = textResult ? null : completion.reasoning;
-    const emptyError = !textResult && reasoningResult && lengthCapped ? `historian output length-capped at ${completion.usage.output} tokens (all reasoning, no text) — set historian.maxTokens or route historian.model to a low-reasoning lane/variant` : !textResult && !reasoningResult ? "Historian returned no assistant output." : !textResult ? "Historian returned reasoning but no assistant text." : lengthCapped ? "Historian returned length-capped output." : null;
+    const emptyError = !textResult && reasoningResult && lengthCapped ? historianReasoningBudgetDiagnostic(completion.usage.output) : !textResult && !reasoningResult ? "Historian returned no assistant output." : !textResult ? "Historian returned reasoning but no assistant text." : lengthCapped ? "Historian returned length-capped output." : null;
     const invocationId = recordInvocation({
       status: emptyError ? "empty" : "completed",
       messages: completion.messages,
@@ -5582,7 +5838,7 @@ function isTransientHistorianPromptError(message) {
     "overloaded"
   ].some((token) => normalized.includes(token));
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -5779,13 +6035,25 @@ function runLeaseGuardedWrite(db, holderId, leaseKey, fn, slowWriteThresholdMs)
     return fn();
   }, `lease-guarded-write:${leaseKey}`, slowWriteThresholdMs);
 }
-var LEASE_HEARTBEAT_INTERVAL_MS = 60 * 1000;
+var LEASE_HEARTBEAT_INTERVAL_MS = 40 * 1000;
+function reacquireOwnedLease(db, holderId, leaseKey, generation) {
+  const keys = rowKeys(leaseKey);
+  return runImmediate(db, () => {
+    if (getLeaseHolder(db, leaseKey) !== holderId || getLeaseGeneration(db, leaseKey) !== generation) {
+      return false;
+    }
+    const now = Date.now();
+    setDreamState(db, keys.heartbeat, String(now));
+    setDreamState(db, keys.expiry, String(now + LEASE_DURATION_MS));
+    return true;
+  });
+}
 function startLeaseHeartbeat(db, holderId, leaseKey, onLost, intervalOrAcquisition = LEASE_HEARTBEAT_INTERVAL_MS) {
   const intervalMs = typeof intervalOrAcquisition === "number" ? intervalOrAcquisition : LEASE_HEARTBEAT_INTERVAL_MS;
   const acquisition = typeof intervalOrAcquisition === "number" ? undefined : intervalOrAcquisition;
   let lost = false;
-  let expectedGeneration = acquisition?.generation ?? getLeaseGeneration(db, leaseKey);
-  let lastConfirmedAt = acquisition?.acquiredAt ?? Date.now();
+  const expectedGeneration = acquisition?.generation ?? getLeaseGeneration(db, leaseKey);
+  let renewalFailures = 0;
   const declareLost = (reason) => {
     if (lost)
       return;
@@ -5797,32 +6065,20 @@ function startLeaseHeartbeat(db, holderId, leaseKey, onLost, intervalOrAcquisiti
       return;
     try {
       if (renewLease(db, holderId, leaseKey, expectedGeneration === null ? undefined : expectedGeneration)) {
-        lastConfirmedAt = Date.now();
         return;
       }
-      if (expectedGeneration !== null && getLeaseGeneration(db, leaseKey) !== expectedGeneration) {
-        declareLost("lease generation changed — another holder acquired it");
-        return;
-      }
-      if (Date.now() - lastConfirmedAt > LEASE_DURATION_MS) {
-        declareLost("lease lapsed past TTL — another holder may have run");
-        return;
-      }
-      const reacquired = acquireLeaseWithAcquisition(db, holderId, leaseKey);
-      if (reacquired) {
-        if (expectedGeneration !== null && reacquired.generation !== expectedGeneration) {
-          declareLost("lease generation changed during reacquisition");
-          return;
-        }
-        expectedGeneration = reacquired.generation;
-        lastConfirmedAt = Date.now();
+      if (expectedGeneration !== null && reacquireOwnedLease(db, holderId, leaseKey, expectedGeneration))
         return;
+      const holder = getLeaseHolder(db, leaseKey);
+      if (holder !== null && holder !== holderId) {
+        declareLost(`lease_lost: taken by ${holder}`);
+      } else if (getLeaseGeneration(db, leaseKey) !== expectedGeneration) {
+        declareLost("lease_lost: generation changed");
+      } else {
+        declareLost("lease_expired: reacquire failed (holder missing)");
       }
-      declareLost("lease acquired by another holder");
     } catch {
-      if (Date.now() - lastConfirmedAt > LEASE_DURATION_MS) {
-        declareLost("lease renewal unconfirmed past TTL");
-      }
+      renewalFailures += 1;
     }
   };
   beat();
@@ -5834,6 +6090,9 @@ function startLeaseHeartbeat(db, holderId, leaseKey, onLost, intervalOrAcquisiti
     },
     get lost() {
       return lost;
+    },
+    get renewalFailures() {
+      return renewalFailures;
     }
   };
 }
@@ -5911,6 +6170,14 @@ function assertParsedManifestNonEmpty(parsedCount, expectedCount, text, expected
 }
 
 // ../plugin/src/features/magic-context/dreamer/module-apply.ts
+var loggedNotOwnerProjects = new Set;
+function logDreamerNotOwnerOnce(projectIdentity) {
+  if (loggedNotOwnerProjects.has(projectIdentity))
+    return;
+  loggedNotOwnerProjects.add(projectIdentity);
+  log(`[dreamer] ${projectIdentity}: module-managed project; skipping TS writes without an owner route`);
+}
+
 class DreamerModuleBusyError extends Error {
   state;
   transient = true;
@@ -6535,7 +6802,7 @@ async function runHiddenSingleShotPrompt(args) {
       fetchOutput: () => args.executor.collect(handle, 50),
       validateOutput: (completion) => {
         if (completion.lengthCapped) {
-          throw new Error(`${args.callContext} returned length-capped output`);
+          throw new Error(completion.reasoning && !completion.text ? `${args.callContext} ran out of output budget while reasoning (length-capped at ${completion.usage.output} tokens, no text) — set dreamer.maxTokens or use a low-reasoning model` : `${args.callContext} returned length-capped output`);
         }
         const text = completion.text;
         if (!text && !args.allowEmpty)
@@ -7108,12 +7375,45 @@ function validateClassifyManifest(text, expectedIds) {
   return parsed;
 }
 
+// ../plugin/src/features/magic-context/dreamer/failed-invocation-evidence.ts
+var FAILED_CHILD_READ_TIMEOUT_MS = 5000;
+var FAILED_CHILD_MESSAGE_LIMIT = 200;
+async function readFailedChildMessages(client, sessionId, directory) {
+  if (!client || !sessionId)
+    return;
+  let timer;
+  try {
+    const response = await Promise.race([
+      client.session.messages({
+        path: { id: sessionId },
+        query: { directory, limit: FAILED_CHILD_MESSAGE_LIMIT }
+      }),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), FAILED_CHILD_READ_TIMEOUT_MS);
+      })
+    ]);
+    if (response === null)
+      return;
+    const messages = normalizeSDKResponse(response, [], {
+      preferResponseOnMissingData: true
+    });
+    return Array.isArray(messages) ? messages : undefined;
+  } catch (error) {
+    log(`[dreamer] failed-child evidence read failed for ${sessionId}: ${String(error)}`);
+    return;
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+
 // ../plugin/src/features/magic-context/dreamer/classify.ts
 var MIN_POOL_TO_CLASSIFY = 10;
 var FULL_POOL_CEILING = 100;
 var STAGE3_ANCHOR_COUNT = 30;
 var CLASSIFY_CHUNK_SIZE = 100;
 var CLASSIFY_MODULE_RUN_TIMEOUT_MS = 660000;
+var HOST_COMPLETION_REQUIRED = "host_completion_required";
 
 class ClassifyModuleFailureError extends Error {
   transient = true;
@@ -7197,13 +7497,12 @@ async function runClassify(args) {
   let stage;
   let toClassify;
   let anchors = [];
+  const unclassifiedIds = new Set(getUnclassifiedMemoryIds(args.db, active.map((candidate) => candidate.contextMemory.id)));
+  toClassify = active.filter((candidate) => unclassifiedIds.has(candidate.contextMemory.id));
   if (active.length <= FULL_POOL_CEILING) {
     stage = 2;
-    toClassify = active;
   } else {
     stage = 3;
-    const unclassifiedIds = new Set(getUnclassifiedMemoryIds(args.db, active.map((candidate) => candidate.contextMemory.id)));
-    toClassify = active.filter((candidate) => unclassifiedIds.has(candidate.contextMemory.id));
     const classified = active.filter((candidate) => !unclassifiedIds.has(candidate.contextMemory.id));
     anchors = stratifiedAnchors(classified, STAGE3_ANCHOR_COUNT);
   }
@@ -7224,7 +7523,7 @@ async function runClassify(args) {
     chunks.push(toClassify.slice(i, i + CLASSIFY_CHUNK_SIZE));
   }
   const abortController = new AbortController;
-  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort(), args.leaseAcquisition);
+  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, (reason) => abortController.abort(new Error(reason)), args.leaseAcquisition);
   try {
     for (let i = 0;i < chunks.length; i += 1) {
       const remainingMs = Math.max(0, args.deadline - Date.now());
@@ -7259,65 +7558,89 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
       memories: chunk.map(toPromptMemory2),
       anchors
     });
-    if (moduleRoute) {
-      const run = await runClassifyThroughModule(args, chunk, anchors, signal);
-      recordInvocation(args, startedAt, { status: "completed" });
-      return run;
-    }
-    const executor = resolveHiddenCompletionExecutor(args.hiddenCompletionExecutor, args.client, args.db, args.sessionDirectory, "classify-memories");
-    closeExecutor = executor;
-    handle = await executor.open({
-      parentSessionId: args.parentSessionId,
-      agent: DREAMER_CLASSIFIER_AGENT,
-      kind: "dreamer-task",
-      system: withContentLanguageDirective(CLASSIFY_SYSTEM_PROMPT, args.language),
-      model: args.model,
-      configuredModels: [...args.model ? [args.model] : [], ...args.fallbackModels ?? []],
-      timeoutMs: sliceMs,
-      title: "magic-context-dream-classify",
-      directory: args.sessionDirectory,
-      metadata: { task: "classify-memories" }
-    });
-    agentSessionId = handle.id || null;
-    if (!agentSessionId)
-      throw new Error("Could not create classify session.");
-    const opened = handle;
-    const run = await promptSyncWithValidatedOutputRetry(args.client, {
-      path: { id: agentSessionId },
-      query: { directory: args.sessionDirectory },
-      body: {
+    const runOnHostCarrier = async (system) => {
+      const executor = resolveHiddenCompletionExecutor(args.hiddenCompletionExecutor, args.client, args.db, args.sessionDirectory, "classify-memories");
+      closeExecutor = executor;
+      handle = await executor.open({
+        parentSessionId: args.parentSessionId,
         agent: DREAMER_CLASSIFIER_AGENT,
-        system: withContentLanguageDirective(CLASSIFY_SYSTEM_PROMPT, args.language),
-        ...modelBodyField(args.model),
-        parts: [{ type: "text", text: prompt, synthetic: true }]
-      }
-    }, {
-      transport: Object.assign((request) => executor.attempt(opened, request), { childSessionId: opened.childSessionId }),
-      timeoutMs: sliceMs,
-      signal,
-      fallbackModels: args.fallbackModels,
-      callContext: "dreamer:classify-memories",
-      fetchOutput: () => executor.collect(opened, 50),
-      validateOutput: (completion) => {
-        const messages = completion.messages ?? [];
-        if (completion.lengthCapped) {
-          throw new Error("classify returned length-capped output");
+        kind: "dreamer-task",
+        system,
+        model: args.model,
+        configuredModels: [
+          ...args.model ? [args.model] : [],
+          ...args.fallbackModels ?? []
+        ],
+        timeoutMs: sliceMs,
+        title: "magic-context-dream-classify",
+        directory: args.sessionDirectory,
+        metadata: { task: "classify-memories" }
+      });
+      agentSessionId = handle.id || null;
+      if (!agentSessionId)
+        throw new Error("Could not create classify session.");
+      const opened = handle;
+      const run = await promptSyncWithValidatedOutputRetry(args.client, {
+        path: { id: agentSessionId },
+        query: { directory: args.sessionDirectory },
+        body: {
+          agent: DREAMER_CLASSIFIER_AGENT,
+          system,
+          ...modelBodyField(args.model),
+          parts: [{ type: "text", text: prompt, synthetic: true }]
         }
-        const text = completion.text;
-        if (!text)
-          throw new Error("classify returned no output");
-        try {
-          validateClassifyManifest(text, new Set(chunk.map((candidate) => candidate.id)));
-        } catch (error) {
-          const providerFailure = providerOutputFailureFromInvalidManifest(messages, text);
-          if (providerFailure)
-            throw providerFailure;
-          throw error;
+      }, {
+        transport: Object.assign((request) => executor.attempt(opened, request), { childSessionId: opened.childSessionId }),
+        timeoutMs: sliceMs,
+        signal,
+        fallbackModels: args.fallbackModels,
+        callContext: "dreamer:classify-memories",
+        fetchOutput: () => executor.collect(opened, 50),
+        validateOutput: (completion) => {
+          const messages = completion.messages ?? [];
+          if (completion.lengthCapped) {
+            throw new Error(completion.reasoning && !completion.text ? `classify ran out of output budget while reasoning (length-capped at ${completion.usage.output} tokens, no text) — set dreamer.maxTokens or use a low-reasoning model` : "classify returned length-capped output");
+          }
+          const text = completion.text;
+          if (!text)
+            throw new Error("classify returned no output");
+          try {
+            validateClassifyManifest(text, new Set(chunk.map((candidate) => candidate.id)));
+          } catch (error) {
+            const providerFailure = providerOutputFailureFromInvalidManifest(messages, text);
+            if (providerFailure)
+              throw providerFailure;
+            throw error;
+          }
+          return text;
         }
-        return text;
-      }
-    });
-    promptSettled = true;
+      });
+      promptSettled = true;
+      return run;
+    };
+    if (moduleRoute) {
+      const { accounting, ...run } = await runClassifyThroughModule(args, chunk, anchors, signal, async (system) => {
+        const run = await runOnHostCarrier(system);
+        const output = run.output;
+        return {
+          text: run.validated,
+          model: output.providerId && output.modelId ? `${output.providerId}/${output.modelId}` : run.attempt.label,
+          length_capped: output.lengthCapped === true,
+          usage: {
+            input: output.usage?.input ?? 0,
+            output: output.usage?.output ?? 0,
+            cache_read: output.usage?.cacheRead ?? 0,
+            cache_write: output.usage?.cacheWrite ?? 0
+          }
+        };
+      });
+      recordInvocation(args, startedAt, {
+        status: "completed",
+        moduleAccounting: accounting
+      });
+      return run;
+    }
+    const run = await runOnHostCarrier(withContentLanguageDirective(CLASSIFY_SYSTEM_PROMPT, args.language));
     recordInvocation(args, startedAt, {
       status: "completed",
       messages: run.output.messages,
@@ -7330,7 +7653,8 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
     log(`[dreamer] classify chunk failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
     recordInvocation(args, startedAt, {
       status: failedInvocationStatus(failure),
-      error: failure
+      error: failure,
+      messages: args.hiddenCompletionExecutor ? undefined : await readFailedChildMessages(args.client, agentSessionId, args.sessionDirectory)
     });
     if (moduleRoute || failure instanceof HiddenCompletionRefusal || signal.aborted || failure instanceof DreamerProviderOutputFailureError || getPromptFailureDetail(failure)?.failureClass !== "parse_failed" && getPromptFailureDetail(failure) !== null)
       throw failure;
@@ -7344,7 +7668,7 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
     });
   }
 }
-async function runClassifyThroughModule(args, chunk, anchors, signal) {
+async function runClassifyThroughModule(args, chunk, anchors, signal, runOnHost) {
   const prompt = buildClassifyPrompt({
     projectPath: args.projectIdentity,
     memories: chunk.map(toPromptMemory2),
@@ -7352,7 +7676,8 @@ async function runClassifyThroughModule(args, chunk, anchors, signal) {
   });
   const modelChain = [args.model, ...args.fallbackModels ?? []].map(toModelEntry).filter((entry) => entry !== undefined).map((entry) => entry.model);
   const resolvedModelChain = [...new Set(modelChain)];
-  const response = await args.moduleClient?.call({
+  const commandId = `classify:${args.moduleCommandId ?? Date.now()}:${createHash5("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`;
+  const runTask = (hostCompletion) => args.moduleClient?.call({
     sessionId: args.moduleSessionId,
     projectRoot: args.moduleProjectRoot,
     method: "dreamer.run_task",
@@ -7361,21 +7686,29 @@ async function runClassifyThroughModule(args, chunk, anchors, signal) {
       v: 1,
       session_id: args.moduleSessionId,
       task: "classify",
-      command_id: `classify:${args.moduleCommandId ?? Date.now()}:${createHash5("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`,
+      command_id: commandId,
       authority_generation: args.moduleAuthorityGeneration,
-      ...resolvedModelChain.length > 0 ? { model_chain: resolvedModelChain } : {},
+      model_chain: resolvedModelChain,
       payload: {
         prompt_body: prompt,
         items: chunk.map((candidate) => ({
           memory_id: candidate.id,
           content_hash: candidate.normalizedHash
         }))
-      }
+      },
+      ...hostCompletion ? { host_completion: hostCompletion } : {}
     },
     signal,
-    timeoutMs: CLASSIFY_MODULE_RUN_TIMEOUT_MS
+    timeoutMs: Math.max(1, resolvedModelChain.length) * CLASSIFY_MODULE_RUN_TIMEOUT_MS + 30000
   });
-  const result = response?.result ?? response;
+  const unwrap = (response) => response?.result ?? response;
+  let result = unwrap(await runTask());
+  const asked = result;
+  if (asked?.code === HOST_COMPLETION_REQUIRED) {
+    if (typeof asked.system_prompt !== "string")
+      throw new Error("module asked for a host classify completion without a system prompt");
+    result = unwrap(await runTask(await runOnHost(asked.system_prompt)));
+  }
   if (!result || typeof result !== "object")
     throw new Error("module returned invalid classify result");
   const manifestText = result.manifest_text;
@@ -7384,6 +7717,7 @@ async function runClassifyThroughModule(args, chunk, anchors, signal) {
   if (result.truncated === true) {
     throw new Error("classify returned length-capped output");
   }
+  const accounting = moduleClassifyAccounting(result);
   const parsed = validateClassifyManifest(manifestText, new Set(chunk.map((candidate) => candidate.id)));
   const rows = parsed.map((entry) => {
     const candidate = chunk.find((item) => item.id === entry.id);
@@ -7456,7 +7790,39 @@ async function runClassifyThroughModule(args, chunk, anchors, signal) {
       throw new Error(`module accepted unknown memory ${moduleId}`);
     return candidate.contextMemory.id;
   });
-  return { classified: acceptedContextIds.length, changed: acceptedContextIds.length };
+  return {
+    classified: acceptedContextIds.length,
+    changed: acceptedContextIds.length,
+    accounting
+  };
+}
+function nonNegativeCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function moduleClassifyAccounting(result) {
+  const accounting = {};
+  const usage = result.usage;
+  if (usage && typeof usage === "object") {
+    const record = usage;
+    accounting.tokens = {
+      input: nonNegativeCount(record.input),
+      output: nonNegativeCount(record.output),
+      cacheRead: nonNegativeCount(record.cache_read),
+      cacheWrite: nonNegativeCount(record.cache_write)
+    };
+  }
+  const diagnostics = result.diagnostics;
+  const model = diagnostics && typeof diagnostics === "object" ? diagnostics.model : undefined;
+  if (typeof model === "string") {
+    const parsed = parseProviderModel(model);
+    if (parsed) {
+      accounting.providerId = parsed.providerID;
+      accounting.modelId = parsed.modelID;
+    } else if (model.trim()) {
+      accounting.modelId = model.trim();
+    }
+  }
+  return accounting;
 }
 function applyClassifications(args, chunk, manifestText) {
   const byId = new Map(chunk.map((m) => [m.id, m]));
@@ -7501,6 +7867,11 @@ function recordInvocation(args, startedAt, params) {
       providerId: params.completion.providerId,
       modelId: params.completion.modelId
     } : {},
+    ...params.moduleAccounting ? {
+      tokens: params.moduleAccounting.tokens,
+      providerId: params.moduleAccounting.providerId,
+      modelId: params.moduleAccounting.modelId
+    } : {},
     error: params.error
   });
 }
@@ -8099,7 +8470,7 @@ async function guardedReadFile(projectRoot, repoRelativePath, signal, fileLimitB
   const body = guardedReadFileBody(projectRoot, repoRelativePath, signal, fileLimitBytes);
   let onAbort;
   const abort = new Promise((_, reject) => {
-    onAbort = () => reject(abortError(signal));
+    onAbort = () => reject(abortError2(signal));
     if (signal.aborted)
       onAbort();
     else
@@ -8169,9 +8540,9 @@ async function closeLateOpenOnAbort(openPromise, signal) {
     return handle;
   if (handle)
     handle.close().catch(() => {});
-  throw abortError(signal);
+  throw abortError2(signal);
 }
-function abortError(signal) {
+function abortError2(signal) {
   return signal.reason instanceof SmartNoteNetworkError ? signal.reason : new SmartNoteNetworkError("SMART_NOTE_NETWORK: aborted");
 }
 function isPathInside(root, target) {
@@ -8990,9 +9361,9 @@ async function evaluateSmartNotes(args) {
       throw new Error(`Dream lease lost during smart-notes ${phase}`);
     }
   };
-  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => {
+  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, (reason) => {
     leaseLost = true;
-    leaseAbortController.abort(new Error("Dream lease lost during smart notes"));
+    leaseAbortController.abort(new Error(reason));
     log("[dreamer] smart notes: lease lost — aborting");
     args.onLeaseLost?.("smart notes");
   }, args.leaseAcquisition);
@@ -9307,6 +9678,7 @@ async function confirmReadOnly(args, noteId, content, surfaceCondition, leaseSig
           parts: [{ type: "text", text: prompt, synthetic: true }]
         }
       }, {
+        transport: createPromptAsyncTransport(client, childSessionId),
         timeoutMs: Math.max(1000, args.deadline - Date.now()),
         signal: promptSignal.signal,
         fallbackModels: args.fallbackModels,
@@ -9614,7 +9986,7 @@ function computeMapBatchSliceMs(remainingMs, batchesRemaining) {
   return Math.min(remainingMs, Math.max(MAP_BATCH_FLOOR_MS, Math.floor(remainingMs / batchesRemaining)));
 }
 function isTimeoutClassError2(error) {
-  return error instanceof Error && /^prompt timed out after \d+ms$/.test(error.message);
+  return isPromptTimeoutError(error);
 }
 function shouldRequeueIndependentMapping(state, content, repoDir) {
   if (!state.hasSentinel || state.files.length > 0)
@@ -9669,7 +10041,7 @@ async function mapMemories(args) {
   }
   result.remaining = inputs.length;
   const abortController = new AbortController;
-  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort(), args.leaseAcquisition);
+  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, (reason) => abortController.abort(new Error(reason)), args.leaseAcquisition);
   try {
     let consecutiveTimeouts = 0;
     let timeoutStreakElapsedMs = [];
@@ -9784,6 +10156,7 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
         parts: [{ type: "text", text: prompt, synthetic: true }]
       }
     }, {
+      transport: createPromptAsyncTransport(client, agentSessionId),
       timeoutMs: sliceMs,
       signal,
       fallbackModels: args.fallbackModels,
@@ -9818,7 +10191,11 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
   } catch (error) {
     const desc = describeError(error);
     log(`[dreamer] map-memories batch failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
-    recordInvocation2(args, startedAt, { status: failedInvocationStatus(error), error });
+    recordInvocation2(args, startedAt, {
+      status: failedInvocationStatus(error),
+      error,
+      messages: await readFailedChildMessages(args.client, agentSessionId, args.sessionDirectory)
+    });
     if (error instanceof DreamerModuleFailureError)
       throw error;
     if (signal.aborted)
@@ -10143,7 +10520,7 @@ function pruneExpiredPrimerCandidatesForProject(db, projectIdentity, now = Date.
   db.transaction(() => {
     for (const id of toDelete)
       stmt.run(id, projectIdentity);
-  })();
+  }).immediate();
   return toDelete.length;
 }
 async function promotePrimers(args) {
@@ -10562,13 +10939,7 @@ var FRUSTRATION_MARKER_REGEX = /\b(?:not what i asked|i already (?:said|told you
 var LEARNINGS_BLOCK_REGEX = /<learnings\b[^>]*>(.*?)<\/learnings>/is;
 var LEARNING_REGEX = /<learning\b([^>]*)>(.*?)<\/learning>/gis;
 var ATTR_REGEX = /([a-zA-Z_:-]+)\s*=\s*"([^"]*)"/g;
-var VALID_MEMORY_CATEGORIES = new Set([
-  "PROJECT_RULES",
-  "ARCHITECTURE",
-  "CONSTRAINTS",
-  "CONFIG_VALUES",
-  "NAMING"
-]);
+var VALID_MEMORY_CATEGORIES = new Set(V2_MEMORY_CATEGORIES);
 var RAW_QUOTE_REGEX = /["“”][^"“”]{4,}["“”]|'[^']{4,}'/;
 var DATE_REGEX = /\b(?:20\d{2}[-/]\d{1,2}[-/]\d{1,2}|\d{1,2}\/\d{1,2}\/20\d{2}|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\s+\d{1,2},?\s+20\d{2})\b/i;
 function parseRetrospectiveLearnings(text) {
@@ -11327,6 +11698,10 @@ function validateVerifyManifest(text, expectedIds) {
 // ../plugin/src/features/magic-context/dreamer/verify.ts
 var VERIFY_BATCH_SIZE = 50;
 var IDENTICAL_PROVIDER_FAILURE_BATCH_LIMIT = 2;
+var VERIFY_BATCH_FLOOR_MS = 240000;
+function computeVerifyBatchSliceMs(remainingMs, batchesRemaining) {
+  return Math.min(remainingMs, Math.max(VERIFY_BATCH_FLOOR_MS, Math.floor(remainingMs / batchesRemaining)));
+}
 function closeBroadCycle(args, cycleStartAt) {
   if (!args.forceBroad || cycleStartAt === undefined)
     return;
@@ -11381,17 +11756,19 @@ async function runVerify(args) {
     batches.push(gate.inScope.slice(i, i + VERIFY_BATCH_SIZE));
   }
   const abortController = new AbortController;
-  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort(), args.leaseAcquisition);
+  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, (reason) => abortController.abort(new Error(reason)), args.leaseAcquisition);
   let consecutiveProviderFailures = 0;
   let priorProviderFailureFingerprint = null;
   let lastProviderFailure = null;
   try {
     for (let i = 0;i < batches.length; i += 1) {
       const remainingMs = Math.max(0, args.deadline - Date.now());
-      if (remainingMs <= 0)
+      if (remainingMs < VERIFY_BATCH_FLOOR_MS) {
+        result.stopReason = "deadline";
+        log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: stopping before batch ${i + 1}/${batches.length} — remaining budget ${remainingMs}ms is below the ${VERIFY_BATCH_FLOOR_MS}ms batch floor`);
         break;
-      const batchesRemaining = batches.length - i;
-      const sliceMs = Math.max(1, Math.floor(remainingMs / batchesRemaining));
+      }
+      const sliceMs = computeVerifyBatchSliceMs(remainingMs, batches.length - i);
       const counts = await verifyOneBatch(args, batches[i], sliceMs, abortController.signal);
       result.verified += counts.verified;
       result.updated += counts.updated;
@@ -11402,6 +11779,11 @@ async function runVerify(args) {
       result.remaining -= batchProcessed;
       result.batches += 1;
       args.onProgress?.(result.verified + result.updated + result.archived + result.skipped + result.refused, result.refused);
+      if (counts.timedOut) {
+        result.stopReason = "batch-timeout";
+        log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: batch ${i + 1}/${batches.length} timed out after its ${sliceMs}ms slice; stopping with ${result.remaining} remaining`);
+        break;
+      }
       if (counts.providerFailure) {
         lastProviderFailure = counts.providerFailure;
         if (counts.providerFailure.fingerprint === priorProviderFailureFingerprint) {
@@ -11490,6 +11872,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         parts: [{ type: "text", text: prompt, synthetic: true }]
       }
     }, {
+      transport: createPromptAsyncTransport(client, agentSessionId),
       timeoutMs: sliceMs,
       signal,
       fallbackModels: args.fallbackModels,
@@ -11524,8 +11907,24 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     const providerFailure = error instanceof DreamerProviderOutputFailureError ? error : undefined;
     const promptFailure = getPromptFailureDetail(error);
     log(`[dreamer] verify batch ${providerFailure ? "provider failure" : "failed"}: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
-    recordInvocation4(args, startedAt, { status: failedInvocationStatus(error), error });
-    if (error instanceof DreamerModuleFailureError || signal.aborted || promptFailure !== null && promptFailure.failureClass !== "parse_failed" && !providerFailure)
+    recordInvocation4(args, startedAt, {
+      status: failedInvocationStatus(error),
+      error,
+      messages: await readFailedChildMessages(args.client, agentSessionId, args.sessionDirectory)
+    });
+    if (error instanceof DreamerModuleFailureError || signal.aborted)
+      throw error;
+    if (promptFailure?.failureClass === "provider_timeout" || isPromptTimeoutError(error)) {
+      return {
+        verified: 0,
+        updated: 0,
+        archived: 0,
+        skipped: 0,
+        refused: 0,
+        timedOut: true
+      };
+    }
+    if (promptFailure !== null && promptFailure.failureClass !== "parse_failed" && !providerFailure)
       throw error;
     return {
       verified: 0,
@@ -11767,6 +12166,16 @@ function dreamRunFailureDetail(error) {
   }
   const described = describeError(error);
   const message = described.brief;
+  if (error instanceof Error && error.name === "HiddenAgentStepLimit") {
+    return {
+      failure_class: "step_limit",
+      model_attempted: null,
+      models_tried: [],
+      provider_error: null,
+      timeout_ms: null,
+      child_session_id: null
+    };
+  }
   const providerFailure = error instanceof HiddenCompletionRefusal || error instanceof Error && error.name === "DreamerProviderOutputFailureError";
   return {
     failure_class: providerFailure ? "provider_error" : /no models?|model chain is empty/i.test(message) ? "no_models" : "unknown",
@@ -11906,11 +12315,16 @@ function createDreamTaskExecutor(deps) {
       });
     };
     reportProgress(0);
+    if (config.modelChainUnavailable) {
+      return {
+        status: "completed",
+        detail: "skipped: Pi model chain is empty (no configured model resolves in Pi)"
+      };
+    }
     const incompleteMessage = (remaining) => {
       const processed = processedDreamTaskItems(backlogAtStart.pending, remaining);
       return `${config.task} incomplete: ${remaining} remain (was ${backlogAtStart.pending} at run start; processed ${processed} this run)`;
     };
-    const parent = await resolveParentSessionId();
     let moduleRoute;
     if (config.task === "curate" || config.task === "map-memories" || config.task === "compress-cues" || config.task === "classify-memories" || config.task === "verify" || config.task === "verify-broad" || config.task === "retrospective") {
       try {
@@ -11926,6 +12340,19 @@ function createDreamTaskExecutor(deps) {
         throw new DreamerModuleFailureError("authority.status", error);
       }
     }
+    if (!moduleRoute && getAuthorityManagedMarker(db, projectIdentity) && [
+      "curate",
+      "map-memories",
+      "compress-cues",
+      "classify-memories",
+      "verify",
+      "verify-broad",
+      "retrospective"
+    ].includes(config.task)) {
+      logDreamerNotOwnerOnce(projectIdentity);
+      return { status: "completed", detail: "skipped: module-managed memory; not owner" };
+    }
+    const parent = await resolveParentSessionId();
     if (!leaseOwnershipMatches(db, holderId, leaseAcquisition.generation, leaseKey)) {
       throw new Error("Dream lease lost during executor setup");
     }
@@ -12115,13 +12542,14 @@ function createDreamTaskExecutor(deps) {
             });
             return { status: "completed" };
           }
-          const error = incompleteMessage(result.remaining);
+          const batchTimedOut = result.stopReason === "batch-timeout";
+          const error = batchTimedOut ? `${config.task}: a batch timed out within its time slice; ${result.remaining} remain` : incompleteMessage(result.remaining);
           recordRun("failed", error, {
             progress: verificationProgress,
             memoryChanges: computeMemoryDelta(memoryBefore),
             backlogAfter
           });
-          return { status: "failed", transient: true, error };
+          return { status: "failed", transient: !batchTimedOut, error };
         }
         recordRun("completed", null, {
           progress: verificationProgress,
@@ -12947,25 +13375,45 @@ function ensureSeeded(db, projectIdentity, config, now) {
   const nextDueAt = nextDueAtMs(config.schedule, now);
   seedTaskScheduleState(db, projectIdentity, config.task, nextDueAt, lastRunAt, config.schedule);
 }
+function firstRepeatedCivilMinute(candidateMs) {
+  const date = new Date(candidateMs);
+  const first = new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes()).getTime();
+  return first < candidateMs ? first : null;
+}
 function reconcileSchedule(db, projectIdentity, config, now) {
   ensureSeeded(db, projectIdentity, config, now);
-  const stored = getTaskScheduleState(db, projectIdentity, config.task);
-  if (!stored || stored.schedule === config.schedule)
-    return;
-  if (config.schedule.trim() === "") {
-    writeTaskScheduleState(db, { ...stored, schedule: config.schedule, nextDueAt: null });
-    return;
-  }
-  if (stored.schedule === null && stored.nextDueAt !== null) {
-    writeTaskScheduleState(db, { ...stored, schedule: config.schedule });
+  if (getTaskScheduleState(db, projectIdentity, config.task)?.schedule === config.schedule)
     return;
+  const candidate = nextDueAtMs(config.schedule, now);
+  const repeatedFirst = candidate === null ? null : firstRepeatedCivilMinute(candidate);
+  const afterRepeatedFirst = repeatedFirst === null ? candidate : nextDueAtMs(config.schedule, now, repeatedFirst);
+  db.exec("BEGIN IMMEDIATE");
+  let committed = false;
+  try {
+    const stored = getTaskScheduleState(db, projectIdentity, config.task);
+    if (stored && stored.schedule !== config.schedule) {
+      if (stored.schedule === null && stored.nextDueAt !== null) {
+        writeTaskScheduleState(db, { ...stored, schedule: config.schedule });
+      } else {
+        const nextDueAt = repeatedFirst !== null && candidate !== null && stored.nextDueAt !== null && stored.nextDueAt > candidate && stored.lastStatus !== null ? afterRepeatedFirst : candidate;
+        const reconciledNextDueAt = stored.nextDueAt === null ? nextDueAt : nextDueAt === null ? stored.nextDueAt : Math.min(stored.nextDueAt, nextDueAt);
+        writeTaskScheduleState(db, {
+          ...stored,
+          schedule: config.schedule,
+          nextDueAt: reconciledNextDueAt,
+          retryCount: reconciledNextDueAt === stored.nextDueAt ? stored.retryCount : 0
+        });
+      }
+    }
+    db.exec("COMMIT");
+    committed = true;
+  } finally {
+    if (!committed) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
   }
-  writeTaskScheduleState(db, {
-    ...stored,
-    schedule: config.schedule,
-    nextDueAt: nextDueAtMs(config.schedule, now),
-    retryCount: 0
-  });
 }
 function planDueTasks(db, projectIdentity, tasks, now) {
   const pruned = pruneNonCanonicalTaskRows(db, projectIdentity, CANONICAL_DREAM_TASKS);
@@ -12974,6 +13422,8 @@ function planDueTasks(db, projectIdentity, tasks, now) {
   }
   const due = [];
   for (const config of tasks) {
+    if (config.schedule.trim() === "")
+      continue;
     reconcileSchedule(db, projectIdentity, config, now);
     const state = getTaskScheduleState(db, projectIdentity, config.task);
     if (!state || state.nextDueAt === null)
@@ -13059,10 +13509,11 @@ async function runDomainGroup(deps, group, cb) {
   }
   try {
     for (const due of [...group].sort((a, b) => compareTaskOrder(a.config.task, b.config.task))) {
-      if (!leaseOwnershipMatches(db, holderId, acquisition.generation, leaseKey)) {
+      if (!reacquireOwnedLease(db, holderId, leaseKey, acquisition.generation)) {
         log(`[dreamer] domain lease lost (${leaseKey}) — stopping remaining task(s)`);
         break;
       }
+      acquisition = { acquiredAt: Date.now(), generation: acquisition.generation };
       if (!cb?.forceGate) {
         const gatePass = evaluateTaskGate(due.config.task, {
           db,
@@ -13651,7 +14102,8 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
   }
   const dreamerConfig = reg.dreamerConfig;
   const dreamingEnabled = Boolean(dreamerConfig && dreamerConfig.disable !== true);
-  const runtimeConfigs = dreamingEnabled && dreamerConfig ? buildDreamTaskRuntimeConfigs(dreamerConfig, reg.harness, reg.language, reg.mural?.model) : [];
+  const configuredTasks = dreamingEnabled && dreamerConfig ? buildDreamTaskRuntimeConfigs(dreamerConfig, reg.harness, reg.language, reg.mural?.model) : [];
+  const runtimeConfigs = reg.validateTaskModels?.(configuredTasks) ?? configuredTasks;
   await sweepOrphanedInternalChildren(reg, runtimeConfigs.filter((config) => PRIVACY_SENSITIVE_CHILD_TASKS.includes(config.task)).map((config) => config.timeoutMinutes));
   if (commitIndexingEnabled && reg.gitCommitIndexing) {
     await sweepGitCommits({
@@ -13666,6 +14118,10 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
   }
   try {
     await runCompiledSmartNoteSweep(reg, db);
+  } catch (error) {
+    log(`[dreamer] compiled smart-note sweep failed for ${reg.projectIdentity}:`, error);
+  }
+  try {
     const executor = createDreamTaskExecutor({
       client: reg.client,
       sessionDirectory: reg.directory,
@@ -13720,6 +14176,10 @@ async function sweepOrphanedInternalChildren(reg, privacyTimeoutMinutes) {
   }
 }
 async function runCompiledSmartNoteSweep(reg, db) {
+  if (getAuthorityManagedMarker(db, reg.projectIdentity)) {
+    logDreamerNotOwnerOnce(reg.projectIdentity);
+    return;
+  }
   const leaseKey = leaseKeyFor("evaluate-smart-notes", reg.projectIdentity);
   const holderId = crypto.randomUUID();
   if (!acquireLease(db, holderId, leaseKey))
@@ -15365,6 +15825,40 @@ function extractPiTextContent(content) {
 }
 
 // src/dreamer/index.ts
+var warnedUnknownModels = new Set;
+var modelAvailability = new WeakMap;
+function validatePiDreamerModels(tasks, registry) {
+  let resolved = modelAvailability.get(registry);
+  if (!resolved) {
+    resolved = new Map;
+    modelAvailability.set(registry, resolved);
+  }
+  return tasks.map((task) => {
+    const entries = [task.model, ...task.fallbackModels ?? []].filter((entry) => entry !== undefined);
+    const valid = entries.filter((entry) => {
+      const model = typeof entry === "string" ? entry : entry.model;
+      let available = resolved.get(model);
+      if (available === undefined) {
+        const separator = model.indexOf("/");
+        available = separator > 0 && Boolean(registry.find(model.slice(0, separator), model.slice(separator + 1)));
+        resolved.set(model, available);
+      }
+      if (available)
+        return true;
+      if (!warnedUnknownModels.has(model)) {
+        log(`[dreamer] WARNING: dropping Pi model not found: ${model}`);
+        warnedUnknownModels.add(model);
+      }
+      return false;
+    });
+    return {
+      ...task,
+      model: valid[0],
+      fallbackModels: valid.slice(1),
+      modelChainUnavailable: entries.length > 0 && valid.length === 0
+    };
+  });
+}
 var PI_DREAMER_PROJECTS = Symbol.for("magic-context.pi.dreamer-registered-projects");
 function getRegisteredProjects() {
   const globals = globalThis;
@@ -15393,7 +15887,8 @@ var sessionCounter = 0;
 var piSubagentRunnerFactory = () => new PiSubagentRunner;
 var startDreamScheduleTimerFn = startDreamScheduleTimer;
 function registerPiDreamerProject(opts) {
-  if (opts.config.disable === true) {
+  const directory = resolve3(opts.projectDir);
+  if (opts.config.disable === true || directory === parse(directory).root || directory === homedir2()) {
     return;
   }
   const existing = registeredProjects2.get(opts.projectIdentity);
@@ -15406,7 +15901,7 @@ function registerPiDreamerProject(opts) {
       callback(projectIdentity);
   };
   if (existing) {
-    if (existing.generation && existing.projectDir === opts.projectDir) {
+    if (existing.generation && existing.projectDir === opts.projectDir && (!opts.modelRegistry || existing.modelRegistry)) {
       return;
     }
     existing.cleanup();
@@ -15419,12 +15914,14 @@ function registerPiDreamerProject(opts) {
   });
   let cleanup;
   let cancelled = false;
+  const modelRegistry = opts.modelRegistry;
   startDreamScheduleTimerFn({
     directory: opts.projectDir,
     projectIdentity: opts.projectIdentity,
     harness: opts.harness,
     client,
     dreamerConfig: opts.config,
+    validateTaskModels: modelRegistry ? (tasks) => validatePiDreamerModels(tasks, modelRegistry) : undefined,
     sampleDreamRun: opts.sampleDreamRun,
     language: opts.language,
     gitCommitIndexing: opts.gitCommitIndexing,
@@ -15456,7 +15953,7 @@ function registerPiDreamerProject(opts) {
     const manualRun = runManualDream({
       db: manualOpts.db,
       projectIdentity: manualOpts.projectIdentity,
-      tasks: buildDreamTaskRuntimeConfigs(dreamerConfig, manualOpts.harness, manualOpts.language, mural?.model),
+      tasks: manualOpts.modelRegistry ? validatePiDreamerModels(buildDreamTaskRuntimeConfigs(dreamerConfig, manualOpts.harness, manualOpts.language, mural?.model), manualOpts.modelRegistry) : buildDreamTaskRuntimeConfigs(dreamerConfig, manualOpts.harness, manualOpts.language, mural?.model),
       executor: createDreamTaskExecutor({
         client: manualClient,
         sessionDirectory: manualOpts.projectDir,
@@ -15489,7 +15986,8 @@ function registerPiDreamerProject(opts) {
       cleanup?.();
     },
     runManual,
-    projectDir: opts.projectDir
+    projectDir: opts.projectDir,
+    modelRegistry: opts.modelRegistry
   });
 }
 async function runPiDreamForProject(projectIdentity, task, registrationOwner) {
@@ -16001,7 +16499,7 @@ function formatEmbedStatusText(coverage, drain) {
     lines.push(`Synapse — ${formatSynapseLaneDescriptor(coverage.synapseDescriptor)}`);
   }
   lines.push(`This session:  ${coverage.session.embedded} / ${coverage.session.total} compartments embedded`);
-  lines.push(`Project memories:  ${coverage.memories.embedded} / ${coverage.memories.total} embedded`);
+  lines.push(coverage.memories.memoryEnabled === false ? "Project memories:  off (memory disabled)" : `Project memories:  ${coverage.memories.embedded} / ${coverage.memories.total} embedded`);
   if (coverage.commits.gitEnabled) {
     lines.push(`Git commits:  ${coverage.commits.embedded} / ${coverage.commits.total}`);
   } else {
@@ -16177,7 +16675,6 @@ No active Pi session is available.`,
         projectDir: deps.projectDir,
         projectIdentity: deps.projectIdentity
       };
-      const memoryEnabled = deps.resolveMemoryEnabled?.(ctx) ?? deps.memoryEnabled;
       const sub = args.trim().toLowerCase();
       if (sub === "pause") {
         embedPauseBySession.add(sessionId);
@@ -16194,16 +16691,6 @@ Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`,
         });
         return;
       }
-      if (memoryEnabled === false) {
-        sendStatus({
-          title: "/ctx-embed",
-          text: `## /ctx-embed
-
-Memory is disabled for this project, so there is no semantic embedding to backfill.`,
-          level: "info"
-        });
-        return;
-      }
       await ensureProjectRegisteredFromPiDirectory(project.projectDir, deps.db);
       if (sub === "start") {
         const { text, level } = await runEmbedDrain(deps.db, project.projectIdentity, sessionId, {
@@ -16236,13 +16723,11 @@ ${statusText}`,
     }
   });
 }
-function maybeAutoEmbedPiSession(deps, sessionId, projectDir, projectIdentity, _notify) {
+function maybeAutoEmbedPiSession(deps, sessionId, projectDir, projectIdentity) {
   if (autoEmbedAttemptedBySession.has(sessionId))
     return;
   if (embedPauseBySession.has(sessionId))
     return;
-  if (deps.memoryEnabled === false)
-    return;
   autoEmbedAttemptedBySession.add(sessionId);
   (async () => {
     let drainReachedTerminal = false;
@@ -16278,7 +16763,7 @@ function executeFlush(db, sessionId) {
         removePendingOp(db, sessionId, op.tagId);
         dropped++;
       }
-    })();
+    }).immediate();
     const parts = [];
     if (dropped > 0)
       parts.push(`${dropped} dropped`);
@@ -16577,7 +17062,7 @@ function createTagger() {
         db.transaction(() => {
           getUpsertCounterStatement(db).run(sessionId, next, getHarness());
           insertTag(db, sessionId, messageId, type, byteSize, next, reasoningByteSize, toolName, inputByteSize, toolOwnerMessageId, entryFingerprint, tokenCounts);
-        })();
+        }).immediate();
       } catch (error) {
         if (!isUniqueConstraintError(error)) {
           throw error;
@@ -16813,7 +17298,8 @@ var canonicalReasons = new Set([
   "ttl_expiry",
   "epoch_change",
   "coverage_fold",
-  "profile_transition"
+  "profile_transition",
+  "host_compaction"
 ]);
 var piReasonAliases = {
   project_memory_change: "project_memory_epoch",
@@ -17047,6 +17533,72 @@ var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
   return `[dropped §${tagId}§]`;
 }
+function applyNewToolDrop(target, options) {
+  if (!target)
+    return { result: "absent", mode: "full" };
+  if (options.inWindow && hasSmallToolInput(target) || options.keepSkeleton === true || target.cannotRemove?.() === true) {
+    const strip = target.hasAttachments?.() === true;
+    return {
+      result: (strip ? target.skeletonStripped?.() : target.skeletonReal?.()) ?? "absent",
+      mode: strip ? "skeleton_stripped" : "skeleton_real"
+    };
+  }
+  const result = target.drop?.() ?? "absent";
+  if (result === "truncated" && target.hasAttachments?.() === true) {
+    return { result: target.skeletonStripped?.() ?? "absent", mode: "skeleton_stripped" };
+  }
+  return { result, mode: result === "truncated" ? "skeleton_real" : "full" };
+}
+function hasSmallToolInput(target) {
+  const bytes = target?.inputStringBytes?.() ?? null;
+  return bytes !== null && bytes <= SKELETON_REAL_INPUT_MAX_BYTES;
+}
+var CACHE_LOSING_FOLD_REASONS = new Set([
+  "model_change",
+  "system_hash",
+  "ttl_idle",
+  "host_compaction"
+]);
+function sameBytes(left, right) {
+  if (left === null || right === null)
+    return left === right;
+  return Buffer.compare(Buffer.from(left), Buffer.from(right)) === 0;
+}
+function foldChangesServedPrefix(before, after) {
+  if (!sameBytes(before.m0Bytes, after.m0Bytes))
+    return true;
+  if (!sameBytes(before.m1Bytes, after.m1Bytes))
+    return true;
+  return before.muralDataUrl !== after.muralDataUrl;
+}
+function foldBustsServedPrefix(reason, before, after) {
+  return CACHE_LOSING_FOLD_REASONS.has(reason ?? "") || foldChangesServedPrefix(before, after);
+}
+function convertLegacyToolSkeletons(db, sessionId, targets) {
+  const rows = db.prepare(`SELECT tag_number AS tagNumber, drop_mode AS dropMode
+               FROM tags
+              WHERE session_id = ? AND type = 'tool' AND status = 'dropped'
+                AND drop_mode IN ('truncated', 'full')
+              ORDER BY tag_number`).all(sessionId);
+  const converted = new Map;
+  for (const row of rows) {
+    const target = targets.get(row.tagNumber);
+    if (target?.canDrop?.() !== true)
+      continue;
+    const cannotRemove = target.cannotRemove?.() === true || target.requiresToolArcSkeleton === true || target.wouldStrandConversationEnd?.() === true;
+    let mode;
+    if (row.dropMode === "full") {
+      if (target.cannotRemove?.() !== true)
+        continue;
+      mode = "skeleton_real";
+    } else {
+      mode = hasSmallToolInput(target) || cannotRemove ? "skeleton_real" : "full";
+    }
+    updateTagDropMode(db, sessionId, row.tagNumber, mode);
+    converted.set(row.tagNumber, mode);
+  }
+  return converted;
+}
 function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete) {
   let didMutateMessage = false;
   let diagnostics;
@@ -17106,7 +17658,8 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
         let shouldPersistDrop = false;
         if (isToolTag) {
           if (editMarkerTagIds.has(pendingOp.tagId)) {
-            const markResult = target?.editMarker?.() ?? "absent";
+            const strip = target?.hasAttachments?.() === true;
+            const markResult = (strip ? target?.editMarkerStripped?.() : target?.editMarker?.()) ?? "absent";
             if (markResult === "incomplete" || markResult === "absent") {
               reject(`edit_marker_${markResult}`);
               continue;
@@ -17114,34 +17667,23 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
             didMutateMessage = true;
             operationMutated = true;
             onTagReduced?.({ tagNumber: pendingOp.tagId, mode: "edit_marker" });
-            updateTagDropMode(db, sessionId, pendingOp.tagId, "edit_marker");
-            shouldPersistDrop = true;
-          } else if (skeletonWindow.has(pendingOp.tagId)) {
-            const truncResult = target?.truncate?.() ?? "absent";
-            if (truncResult === "incomplete" || synthetic && truncResult !== "truncated") {
-              reject(`truncate_${truncResult}`);
-              continue;
-            }
-            if (truncResult === "truncated") {
-              didMutateMessage = true;
-              operationMutated = true;
-              onTagReduced?.({ tagNumber: pendingOp.tagId, mode: "truncated" });
-            } else {
-              reject(`truncate_${truncResult}`);
-            }
-            updateTagDropMode(db, sessionId, pendingOp.tagId, "truncated");
+            updateTagDropMode(db, sessionId, pendingOp.tagId, strip ? "edit_marker_stripped" : "edit_marker");
             shouldPersistDrop = true;
           } else {
-            const dropResult = target?.drop?.() ?? "absent";
+            const { result: dropResult, mode: appliedMode } = applyNewToolDrop(target, {
+              inWindow: skeletonWindow.has(pendingOp.tagId)
+            });
             if (dropResult === "incomplete" || synthetic && dropResult !== "removed" && dropResult !== "truncated") {
               reject(`drop_${dropResult}`);
               continue;
             }
-            const appliedMode = dropResult === "truncated" ? "truncated" : "full";
             if (dropResult === "removed" || dropResult === "truncated") {
               didMutateMessage = true;
               operationMutated = true;
-              onTagReduced?.({ tagNumber: pendingOp.tagId, mode: appliedMode });
+              onTagReduced?.({
+                tagNumber: pendingOp.tagId,
+                mode: appliedMode === "full" ? "full" : "truncated"
+              });
             } else {
               reject(`drop_${dropResult}`);
             }
@@ -17208,11 +17750,24 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
     if (tag.status === "dropped") {
       const target = targets.get(tag.tagNumber);
       if (tag.type === "tool") {
-        if (tag.dropMode === "edit_marker") {
+        if (tag.dropMode === "edit_marker_stripped") {
+          const result = target?.editMarkerStripped?.() ?? "absent";
+          if (result === "truncated")
+            didMutateMessage = true;
+        } else if (tag.dropMode === "edit_marker") {
           const markResult = target?.editMarker?.() ?? "absent";
           if (markResult === "truncated") {
             didMutateMessage = true;
           }
+        } else if (tag.dropMode === "skeleton_stripped") {
+          const result = target?.skeletonStripped?.() ?? "absent";
+          if (result === "truncated")
+            didMutateMessage = true;
+        } else if (tag.dropMode === "skeleton_real") {
+          const result = target?.skeletonReal?.() ?? "absent";
+          if (result === "truncated") {
+            didMutateMessage = true;
+          }
         } else if (tag.dropMode === "truncated") {
           const truncResult = target?.truncate?.() ?? "absent";
           if (truncResult === "truncated") {
@@ -17558,7 +18113,7 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config) {
       else if (targetDepth === DEPTH_ULTRA)
         result.compressedToUltra += 1;
     }
-  })();
+  }).immediate();
   const total = result.compressedToLite + result.compressedToFull + result.compressedToUltra;
   if (total > 0) {
     sessionLog(sessionId, `caveman cleanup: compressed ${total} text tags (lite=${result.compressedToLite}, full=${result.compressedToFull}, ultra=${result.compressedToUltra})`);
@@ -19480,6 +20035,7 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton, conve
     let any = false;
     for (const occ of occurrences) {
       if (occ.kind === "tool_use" && occ.part.setToolInput) {
+        occ.originalInput ??= occ.part.getToolInput?.() ?? undefined;
         if (occ.part.setToolInput(droppedInputMarker(tagId)))
           any = true;
       } else if (setToolContentOrText(occ.part, sentinel)) {
@@ -19488,6 +20044,28 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton, conve
     }
     return any ? "truncated" : "absent";
   };
+  const complete = () => occurrences.some((occ) => occ.kind === "tool_use") && occurrences.some((occ) => occ.kind === "tool_result");
+  const skeletonReal = () => {
+    if (!complete())
+      return "incomplete";
+    const sentinel = `[dropped §${tagId}§]`;
+    let any = false;
+    for (const occ of occurrences) {
+      if (occ.kind === "tool_use") {
+        if (occ.originalInput && occ.part.setToolInput?.(occ.originalInput))
+          any = true;
+      } else if (setToolContentOrText(occ.part, sentinel)) {
+        any = true;
+      }
+    }
+    return any ? "truncated" : "absent";
+  };
+  const cannotRemove = () => {
+    if (requiresToolArcSkeleton)
+      return true;
+    const authorization = occurrences.map((occ) => occ.part.canRemove?.());
+    return !occurrences.every((occ, index) => occ.part.remove && authorization[index] !== false);
+  };
   return {
     measureReclaim(skeleton) {
       let beforeTools = 0;
@@ -19498,7 +20076,7 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton, conve
         const before = occ.kind === "tool_use" ? JSON.stringify(occ.part.getToolInput?.() ?? {}) : occ.part.getText() ?? "";
         beforeTools += estimateTokens(before);
         if (skeleton || !removable) {
-          const after = occ.kind === "tool_use" ? JSON.stringify(droppedInputMarker(tagId)) : `[dropped §${tagId}§]`;
+          const after = occ.kind === "tool_use" ? before : `[dropped §${tagId}§]`;
           afterTools += estimateTokens(after);
         }
       }
@@ -19527,8 +20105,7 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton, conve
       return occurrences[0]?.part.getText() ?? null;
     },
     drop() {
-      const complete = occurrences.some((occ) => occ.kind === "tool_use") && occurrences.some((occ) => occ.kind === "tool_result");
-      if (!complete)
+      if (!complete())
         return "incomplete";
       if (!requiresToolArcSkeleton) {
         const authorization = occurrences.map((occ) => occ.part.canRemove?.());
@@ -19536,7 +20113,7 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton, conve
           return "incomplete";
         if (occurrences.every((occ, index) => occ.part.remove && authorization[index] !== false)) {
           if (conversationEnd?.wouldStrand(occurrences))
-            return truncate();
+            return skeletonReal();
           let removed = false;
           for (const occ of occurrences)
             removed = occ.part.remove?.() || removed;
@@ -19554,6 +20131,19 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton, conve
       return any ? "removed" : "absent";
     },
     truncate,
+    skeletonReal,
+    cannotRemove,
+    inputStringBytes() {
+      for (const occ of occurrences) {
+        if (occ.kind !== "tool_use")
+          continue;
+        return toolInputStringBytes(occ.originalInput ?? occ.part.getToolInput?.() ?? null);
+      }
+      return null;
+    },
+    wouldStrandConversationEnd() {
+      return conversationEnd?.wouldStrand(occurrences) ?? false;
+    },
     editMarker() {
       const sentinel = `[dropped §${tagId}§]`;
       let any = false;
@@ -19572,9 +20162,7 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton, conve
       }
       return any ? "truncated" : "absent";
     },
-    canDrop() {
-      return occurrences.some((occ) => occ.kind === "tool_use") && occurrences.some((occ) => occ.kind === "tool_result");
-    },
+    canDrop: complete,
     requiresToolArcSkeleton,
     readInput() {
       for (const occ of occurrences) {
@@ -19620,6 +20208,15 @@ function buildToolTarget(part, message, tagId) {
       const changed = part.setToolInput ? part.setToolInput(droppedInputMarker(tagId)) : setToolContentOrText(part, `[dropped §${tagId}§]`);
       return changed ? "truncated" : "absent";
     },
+    skeletonReal() {
+      if (part.setToolInput)
+        return "truncated";
+      return setToolContentOrText(part, `[dropped §${tagId}§]`) ? "truncated" : "absent";
+    },
+    cannotRemove: () => part.setToolInput !== undefined,
+    inputStringBytes() {
+      return part.setToolInput ? toolInputStringBytes(part.getToolInput?.() ?? null) : 0;
+    },
     message: {
       info: { id: message.info.id, role: message.info.role },
       parts: []
@@ -19893,7 +20490,7 @@ async function runAutoSearchHintForPi(args) {
   try {
     const snapshot = getProjectEmbeddingSnapshot(options.projectPath);
     const memoryEnabled = snapshot?.features.memoryEnabled ?? true;
-    const embeddingEnabled = snapshot ? snapshot.enabled || snapshot.gitCommitEnabled : true;
+    const embeddingEnabled = snapshot ? snapshot.historyEnabled : true;
     const gitCommitsEnabled = snapshot?.gitCommitEnabled ?? false;
     const searchOptions = {
       limit: 10,
@@ -19957,6 +20554,8 @@ import * as crypto2 from "node:crypto";
 async function embedAndStoreCompartmentChunks(db, sessionId, projectPath, compartments) {
   if (compartments.length === 0)
     return;
+  if (getProjectChunkEmbeddingModelId(projectPath) === "off")
+    return;
   const maxInputTokens = getProjectEmbeddingMaxInputTokens(projectPath);
   for (const compartment of compartments) {
     try {
@@ -20113,7 +20712,7 @@ function persistFilteredNoise(db, sessionId, chunk, eligibleEnd) {
       }
     ]);
     return true;
-  })();
+  }).immediate();
   if (saved)
     sessionLog(sessionId, `historian skipped ordinals ${start}-${eligibleEnd - 1}: all ${rows.length} raw rows excluded by chunk filters (no-content boundary marker)`);
   return saved;
@@ -22710,8 +23309,7 @@ ${chunkText}`,
       const discardedLast = newCompartments.length < emittedCompartments.length;
       const weakLookaheadFinalCompartment = forceKeepLastCompartmentForChunk;
       const skipUnanchoredPromotion = discardedLast || weakLookaheadFinalCompartment;
-      const embeddingActive = memoryEnabled !== false;
-      const promotionActive = embeddingActive && autoPromote !== false;
+      const promotionActive = memoryEnabled !== false && autoPromote !== false;
       const publishableEvents = (validatedPass.events ?? []).filter((e) => {
         if (typeof e.atCompartment !== "number")
           return !weakLookaheadFinalCompartment;
@@ -22844,7 +23442,7 @@ ${chunkText}`,
           sessionLog(sessionId, "failed to store primer candidates:", error);
         }
       }
-      if (embeddingActive) {
+      if (newCompartments.length > 0) {
         const chunksToEmbed = newCompartments.map((c, i) => ({
           id: persistedIds[i],
           startMessage: c.startMessage,
@@ -23227,7 +23825,7 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
     const candidateTags = tags.filter((t) => t.status === "active" && t.type === "tool" && targets.get(t.tagNumber)?.canDrop?.());
     const recentTags = new Set(candidateTags.slice().sort((a, b) => b.tagNumber - a.tagNumber).slice(0, 20).map((tag) => tag.tagNumber));
     const calibration = sessionDecisionCalibration(db, sessionId);
-    const activeTags = tags.filter((t) => t.status === "active").map((tag) => measureEmergencyTag(tag, targets.get(tag.tagNumber), calibration, targets.get(tag.tagNumber)?.requiresToolArcSkeleton === true || (emergency.usagePercentage ?? 0) < 95 && recentTags.has(tag.tagNumber)));
+    const activeTags = tags.filter((t) => t.status === "active").map((tag) => measureEmergencyTag(tag, targets.get(tag.tagNumber), calibration, targets.get(tag.tagNumber)?.requiresToolArcSkeleton === true || (emergency.usagePercentage ?? 0) < 95 && recentTags.has(tag.tagNumber) && hasSmallToolInput(targets.get(tag.tagNumber))));
     const byTag = new Map(activeTags.map((tag) => [tag.tagNumber, tag]));
     const droppableTags = candidateTags.flatMap((tag) => {
       const measured = byTag.get(tag.tagNumber);
@@ -23256,18 +23854,18 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
             continue;
           const target = targets.get(tag.tagNumber);
           const recent = (emergency.usagePercentage ?? 0) < 95 && newestEmergencyTags.has(tag.tagNumber);
-          const reasoningSafeSkeleton = target?.requiresToolArcSkeleton === true;
-          const skeleton = recent || reasoningSafeSkeleton;
-          const result = reasoningSafeSkeleton ? target?.truncate?.() ?? "absent" : recent ? target?.truncate?.() ?? target?.drop?.() ?? "absent" : target?.drop?.() ?? "absent";
+          const { result, mode } = applyNewToolDrop(target, {
+            inWindow: recent,
+            keepSkeleton: target?.requiresToolArcSkeleton === true
+          });
           if (result === "removed" || result === "truncated") {
-            const appliedMode = skeleton || result === "truncated" ? "truncated" : "full";
             updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
-            updateTagDropMode(db, sessionId, tag.tagNumber, appliedMode);
+            updateTagDropMode(db, sessionId, tag.tagNumber, mode);
             droppedTools++;
             emergencyDroppedTools++;
             droppedTokenReductions.push({
               tagNumber: tag.tagNumber,
-              mode: appliedMode
+              mode: mode === "full" ? "full" : "truncated"
             });
           }
         }
@@ -23291,10 +23889,10 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
         if (!matched)
           continue;
         const target = targets.get(tag.tagNumber);
-        const result = target?.drop?.() ?? "absent";
+        const { result, mode } = applyNewToolDrop(target, { inWindow: false });
         if (result === "incomplete")
           continue;
-        updateTagDropMode(db, sessionId, tag.tagNumber, result === "truncated" ? "truncated" : "full");
+        updateTagDropMode(db, sessionId, tag.tagNumber, mode);
         updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
         if (result === "removed" || result === "truncated") {
           droppedStaleReduceCalls++;
@@ -23375,17 +23973,18 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
         for (let i = 0;i < group.length - 1; i++) {
           const tag = group[i];
           const target = targets.get(tag.tagNumber);
-          const result = target?.drop?.() ?? "absent";
+          const { result, mode } = applyNewToolDrop(target, {
+            inWindow: false
+          });
           if (result === "incomplete")
             continue;
-          const appliedMode = result === "truncated" ? "truncated" : "full";
-          updateTagDropMode(db, sessionId, tag.tagNumber, appliedMode);
+          updateTagDropMode(db, sessionId, tag.tagNumber, mode);
           updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
           if (result === "removed" || result === "truncated") {
             deduplicatedTools++;
             droppedTokenReductions.push({
               tagNumber: tag.tagNumber,
-              mode: appliedMode
+              mode: mode === "full" ? "full" : "truncated"
             });
           }
         }
@@ -26151,7 +26750,7 @@ function messageRole(message) {
   const role = recordValue(message, "role");
   return typeof role === "string" ? role : undefined;
 }
-function messageId(message) {
+function messageId2(message) {
   const id = recordValue(messageInfo(message), "id") ?? recordValue(message, "id");
   return typeof id === "string" && id.length > 0 ? id : null;
 }
@@ -26284,7 +26883,7 @@ function validateLkgSeam(prefix, tail, providerKey) {
   const calls = new Set;
   const results = new Set;
   for (const message of all) {
-    const id = messageId(message);
+    const id = messageId2(message);
     if (id !== null) {
       if (ids.has(id))
         return false;
@@ -26827,6 +27426,56 @@ function resolvePiPressureSnapshot(args) {
     ...validInferredLimit ? { contextLimit: inferredLimit } : {}
   };
 }
+var estimateSetAsideLogged = new Set;
+function notePiUsageReadingUsed(sessionId) {
+  estimateSetAsideLogged.delete(sessionId);
+}
+function entryUsageTokens(usage) {
+  if (!usage || typeof usage !== "object")
+    return 0;
+  const u = usage;
+  const n = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+  return n(u.totalTokens) || n(u.input) + n(u.output) + n(u.cacheRead) + n(u.cacheWrite);
+}
+function isPiLiveUsageRawBranchEstimate(branchEntries) {
+  if (!branchEntries)
+    return false;
+  for (let index = branchEntries.length - 1;index >= 0; index -= 1) {
+    const entry = branchEntries[index];
+    if (!entry || typeof entry !== "object")
+      continue;
+    if (entry.type === "context_edit" || entry.type === "compaction")
+      return true;
+    if (entry.type !== "message")
+      continue;
+    const message = entry.message;
+    if (message?.role === "assistant" && message.stopReason !== "aborted" && message.stopReason !== "error" && entryUsageTokens(message.usage) > 0) {
+      return false;
+    }
+  }
+  return false;
+}
+function noteRawBranchEstimateSetAside(sessionId, reading, source) {
+  if (estimateSetAsideLogged.has(sessionId))
+    return;
+  estimateSetAsideLogged.add(sessionId);
+  sessionLog(sessionId, `usage reading ${reading} set aside (${source}): Pi re-estimated its whole unreduced session branch because a context edit or compaction follows the last recorded usage (for example after a retried request); keeping the previous reading until provider usage arrives`);
+}
+function resolvePiPressureSnapshotWithEstimateGuard(args) {
+  const live = typeof args.liveInputTokens === "number" && Number.isFinite(args.liveInputTokens) ? args.liveInputTokens : 0;
+  const setAsideEstimate = args.liveIsRawBranchEstimate === true && live > 0;
+  const snapshot = resolvePiPressureSnapshot(setAsideEstimate ? {
+    ...args,
+    liveInputTokens: undefined,
+    ...args.persistedFromLive ? { persistedInputTokens: 0, persistedPercentage: 0 } : {}
+  } : args);
+  if (setAsideEstimate) {
+    noteRawBranchEstimateSetAside(args.sessionId, live, args.source);
+  } else if (snapshot.inputTokens > 0) {
+    notePiUsageReadingUsed(args.sessionId);
+  }
+  return snapshot;
+}
 function formatPiPressureForLog(snapshot) {
   return `usage=${snapshot.percentage.toFixed(1)}% (${snapshot.inputTokens} tokens, limit=${snapshot.contextLimit ?? "?"})`;
 }
@@ -27283,12 +27932,12 @@ function handlePiProviderFailure(args) {
   const model = typeof message.model === "string" ? message.model : undefined;
   const binding = detectThinkingBindingMismatch(message.errorMessage);
   if (binding.isBindingMismatch) {
-    const enabled = args.thinkingBindingRecoveryEnabled !== false && !args.compactionOff && isFable51ThinkingBindingModel(provider, model);
+    const enabled = args.thinkingBindingRecoveryEnabled !== false && !args.compactionOff && isPrefixBoundThinkingModel(provider, model);
     if (enabled) {
       armThinkingBindingRecovery(args.db, args.sessionId);
       clearPiLkgSessionState(args.sessionId);
       dropSlot(args.sessionId, "thinking-binding-recovery-arm");
-      reportBindingRecovery(args.sessionId, args.report, `Fable thinking-binding recovery armed from message_end target=${NEWEST_REASONING_BEARING_ASSISTANT}`);
+      reportBindingRecovery(args.sessionId, args.report, `thinking-binding recovery armed from message_end (provider paths: failing=${binding.failingBlockPath ?? "?"} firstChanged=${binding.firstChangedPath ?? "?"})`);
     }
     return { kind: "thinking_binding", armed: enabled };
   }
@@ -27337,36 +27986,25 @@ function stripThinkingParts(message) {
 function applyPiThinkingBindingRecovery(args) {
   if (args.provider?.toLowerCase() !== "anthropic")
     return null;
-  const frozenEntryIds = new Set;
-  for (const frozenId of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
-    if (!frozenId.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX))
-      continue;
-    const entryId = frozenId.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length);
-    if (entryId.length > 0)
-      frozenEntryIds.add(entryId);
-  }
-  const flagTarget = isFable51ThinkingBindingModel(args.provider, args.model) ? getThinkingBindingRecoveryTarget(args.db, args.sessionId) : null;
+  const frozenEntryIds = frozenBindingEntryIds(args.db, args.sessionId);
+  const flagTarget = isPrefixBoundThinkingModel(args.provider, args.model) ? getThinkingBindingRecoveryTarget(args.db, args.sessionId) : null;
   let applied = null;
   if (flagTarget) {
-    let messageIndex = -1;
-    if (flagTarget === NEWEST_REASONING_BEARING_ASSISTANT) {
-      for (let index = args.messages.length - 1;index >= 0; index -= 1) {
-        if (hasThinkingPart(args.messages[index]) && args.entryIds[index]) {
-          messageIndex = index;
-          break;
-        }
-      }
-    } else {
-      messageIndex = args.entryIds.findIndex((entryId, index) => entryId === flagTarget && hasThinkingPart(args.messages[index]));
-    }
-    const entryId = messageIndex >= 0 ? args.entryIds[messageIndex] : undefined;
-    if (entryId) {
-      const frozenId = thinkingBindingRecoveryFrozenId(entryId);
-      if (frozenEntryIds.has(entryId) || addMergedReasoningStrippedIds(args.db, args.sessionId, [frozenId])) {
-        frozenEntryIds.add(entryId);
-        applied = { flagTarget, entryId };
-        reportBindingRecovery(args.sessionId, args.report, `Fable thinking-binding recovery consumed on context pass target=${flagTarget} entry=${entryId}`);
-      }
+    const entryIds = new Set;
+    for (let index = 0;index < args.messages.length; index += 1) {
+      const entryId = args.entryIds[index];
+      if (entryId && hasThinkingPart(args.messages[index]))
+        entryIds.add(entryId);
+    }
+    const newEntryIds = [...entryIds].filter((id) => !frozenEntryIds.has(id));
+    if (newEntryIds.length === 0 || addMergedReasoningStrippedIds(args.db, args.sessionId, [
+      ...newEntryIds.map(thinkingBindingRecoveryFrozenId),
+      ...args.endOfPassOrder ? [THINKING_BINDING_STRIP_ORDER_END_MARKER] : []
+    ])) {
+      for (const id of newEntryIds)
+        frozenEntryIds.add(id);
+      applied = { flagTarget, entryIds: [...entryIds] };
+      reportBindingRecovery(args.sessionId, args.report, `thinking-binding recovery consumed on context pass target=${flagTarget} entries=${applied.entryIds.length} [${applied.entryIds.join(",")}]`);
     }
   }
   for (let index = 0;index < args.messages.length; index += 1) {
@@ -27376,6 +28014,76 @@ function applyPiThinkingBindingRecovery(args) {
   }
   return applied;
 }
+function applyPiProactiveThinkingStrip(args) {
+  if (!args.cacheBustingPass)
+    return null;
+  if (!isPrefixBoundThinkingModel(args.provider, args.model))
+    return null;
+  const entryIds = [];
+  const indices = [];
+  for (let index = 0;index < args.messages.length; index += 1) {
+    const entryId = args.entryIds[index];
+    if (!entryId || !hasThinkingPart(args.messages[index]))
+      continue;
+    entryIds.push(entryId);
+    indices.push(index);
+  }
+  if (entryIds.length === 0)
+    return null;
+  let persisted = false;
+  try {
+    persisted = addMergedReasoningStrippedIds(args.db, args.sessionId, [
+      ...entryIds.map(thinkingBindingRecoveryFrozenId),
+      THINKING_BINDING_STRIP_ORDER_END_MARKER
+    ]);
+  } catch {
+    persisted = false;
+  }
+  if (!persisted) {
+    reportBindingRecovery(args.sessionId, args.report, "proactive thinking strip: persistence failed; serving the thinking unchanged");
+    return null;
+  }
+  for (const index of indices)
+    stripThinkingParts(args.messages[index]);
+  reportBindingRecovery(args.sessionId, args.report, `proactive thinking strip: busting pass froze thinking of ${entryIds.length} entr${entryIds.length === 1 ? "y" : "ies"} [${entryIds.join(",")}]`);
+  return { entryIds };
+}
+function frozenBindingEntryIds(db, sessionId) {
+  const ids = new Set;
+  for (const entry of getMergedReasoningStrippedIds(db, sessionId)) {
+    if (!entry.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX))
+      continue;
+    const entryId = entry.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length);
+    if (entryId.length > 0)
+      ids.add(entryId);
+  }
+  return ids;
+}
+function resolvePiBindingStripOrder(args) {
+  const ledger = getMergedReasoningStrippedIds(args.db, args.sessionId);
+  if (ledger.has(THINKING_BINDING_STRIP_ORDER_END_MARKER))
+    return "end";
+  const frozen = frozenBindingEntryIds(args.db, args.sessionId);
+  if (frozen.size === 0)
+    return "end";
+  let onBranch = false;
+  let carriesThinking = false;
+  for (let index = 0;index < args.messages.length; index += 1) {
+    const entryId = args.entryIds[index];
+    if (!entryId || !frozen.has(entryId))
+      continue;
+    onBranch = true;
+    if (hasThinkingPart(args.messages[index]))
+      carriesThinking = true;
+  }
+  const mayChangeOrder = onBranch && carriesThinking && args.bustPermittedAtStart;
+  if (mayChangeOrder && addMergedReasoningStrippedIds(args.db, args.sessionId, [
+    THINKING_BINDING_STRIP_ORDER_END_MARKER
+  ])) {
+    return "end";
+  }
+  return "start";
+}
 
 // src/reasoning-replay-pi.ts
 var INLINE_THINKING_PATTERNS = [
@@ -27923,9 +28631,9 @@ var BASE_INTRO = (memoryEnabled, dreamerEnabled, temporalAwarenessEnabled) => `#
 
 Think of your context as a desk. Every message and every tool output lands on it, and each item arrives with a §N§ tag (§1§, §42§) — the tag is the item's handle.
 
-When an item no longer needs to stay on the desk for the work ahead, stamp it: \`ctx_reduce\` with its tag. Stamping does not remove anything — the item stays on the desk, fully readable. From time to time, when stamped items have piled up and the desk needs room, Magic Context clears them all in one sweep; you don't pick the moment, you only stamp. Stamp as soon as an item has served its purpose, not at the end of the turn, and do it silently: nobody wants to read "I'll drop these outputs". Never stamp a user message for what it asks of you; a large paste inside one is fine once you have used it.
+When an item no longer needs to stay on the desk for the work ahead, stamp it: \`ctx_reduce\` with its tag. Stamping does not remove anything — the item stays on the desk, fully readable. From time to time, when stamped items have piled up and the desk needs room, Magic Context clears them all in one sweep; you don't pick the moment, you only stamp. Stamp as soon as an item has served its purpose, not at the end of the turn, and do it silently: nobody wants to read "I'll drop these outputs". An output is used once you've taken what you need from it into your reasoning or your answer. Never stamp a user message for what it asks of you; a large paste inside one is fine once you have used it.
 
-Nothing stamped is ever lost. A cleared item goes to the archive — a recent one leaves a \`[dropped §N§]\` placeholder on the desk, an older one leaves nothing — and \`ctx_expand(message=N)\` brings it back whole: text, tool input, tool output. Now and then Magic Context leaves a short reminder on the desk saying how much unstamped material is lying around; that is housekeeping, not a warning, and the desk never gets smaller for it.
+Nothing stamped is ever lost. A cleared item goes to the archive — a recent one leaves a \`[dropped §N§]\` placeholder on the desk, an older one leaves nothing — and \`ctx_expand(message=N)\` brings it back whole: text, tool input, tool output. Now and then Magic Context leaves a short reminder on the desk saying how much unstamped material is lying around. A reminder means stamping is overdue: act on it in your next step. It isn't a warning about the desk's size. The desk never gets smaller for it.
 
 ${TOOL_HISTORY_GUIDANCE}
 
@@ -27954,7 +28662,7 @@ var SMART_NOTE_GUIDANCE_LIGHT = `; a \`surface_condition\` leaves the note with
 var TEMPORAL_AWARENESS_GUIDANCE_LIGHT = `, \`<!-- +Xm -->\` (time since your last reply)`;
 var BASE_INTRO_LIGHT = (memoryEnabled, dreamerEnabled, temporalAwarenessEnabled) => `### Your desk
 
-Your context is a desk. Every message and tool output lands on it with a §N§ tag as its handle. When an item no longer needs to stay for the work ahead, stamp it: \`ctx_reduce\` with its tag. Stamping removes nothing — the item stays readable; from time to time, when stamped items have piled up and the desk needs room, Magic Context clears them in one sweep (you only stamp, you don't pick the moment). Stamp as soon as an item has served its purpose, silently; never stamp a user message for what it asks (a used paste inside one is fine). Nothing is lost: a cleared item goes to the archive (a recent one leaves \`[dropped §N§]\`, an older one nothing) and \`ctx_expand(message=N)\` brings it back whole. Occasional reminders about unstamped material are housekeeping, not warnings; the desk never gets smaller.
+Your context is a desk. Every message and tool output lands on it with a §N§ tag as its handle. When an item no longer needs to stay for the work ahead, stamp it: \`ctx_reduce\` with its tag. Stamping removes nothing — the item stays readable; from time to time, when stamped items have piled up and the desk needs room, Magic Context clears them in one sweep (you only stamp, you don't pick the moment). Stamp as soon as an item has served its purpose, silently; never stamp a user message for what it asks (a used paste inside one is fine). An output is used once you've taken what you need from it into your reasoning or your answer. Nothing is lost: a cleared item goes to the archive (a recent one leaves \`[dropped §N§]\`, an older one nothing) and \`ctx_expand(message=N)\` brings it back whole. Occasional reminders about unstamped material may appear. A reminder means stamping is overdue: act on it in your next step. It isn't a warning about the desk's size. The desk never gets smaller.
 
 ${TOOL_HISTORY_GUIDANCE_LIGHT}
 
@@ -29437,7 +30145,7 @@ function databaseIsInTransaction(db) {
 }
 function runImmediateTransaction(db, fn) {
   if (databaseIsInTransaction(db)) {
-    return db.transaction(fn)();
+    return db.transaction(fn).immediate();
   }
   const transactionStartedAt = performance.now();
   db.exec("BEGIN IMMEDIATE");
@@ -29619,6 +30327,7 @@ function registerPiContextHandler(pi, baseOptions) {
       logTransformTiming(sessionId, "findSessionId", tFindSession, `messages=${event.messages.length}`);
       const tEntryBranch = performance.now();
       const branchEntries = readPiBranchEntriesForContext(ctx, sessionId);
+      const piLiveUsageIsRawBranchEstimate = isPiLiveUsageRawBranchEstimate(branchEntries);
       schedulePiTransformDecisionResolve({
         db: options.db,
         sessionId,
@@ -29651,14 +30360,29 @@ function registerPiContextHandler(pi, baseOptions) {
       const lkgInputIdByRef = new Map;
       for (const input of lkgPassSnapshot.inputs)
         lkgInputIdByRef.set(event.messages[input.messageIndex], input.id);
-      const thinkingBindingRecoveryApplied = applyPiThinkingBindingRecovery({
+      const bindingStripOrder = resolvePiBindingStripOrder({
+        db: options.db,
+        sessionId,
+        messages: event.messages,
+        entryIds: lkgEntryIds ?? [],
+        bustPermittedAtStart: hasPendingMaterialization(sessionId)
+      });
+      const startOfPassBindingRecovery = bindingStripOrder === "start" ? applyPiThinkingBindingRecovery({
         db: options.db,
         sessionId,
         messages: event.messages,
         entryIds: lkgEntryIds ?? [],
         provider: lkgProviderKey ?? undefined,
         model: ctx.model?.id
-      });
+      }) : null;
+      const bindingEntryIdByRef = new Map;
+      if (lkgEntryIds) {
+        for (let index = 0;index < event.messages.length; index += 1) {
+          const entryId = lkgEntryIds[index];
+          if (entryId)
+            bindingEntryIdByRef.set(event.messages[index], entryId);
+        }
+      }
       const tMeta = performance.now();
       const sessionMetaForUsage = getOrCreateSessionMeta(options.db, sessionId);
       sessionMetaForPass = sessionMetaForUsage;
@@ -29868,7 +30592,11 @@ function registerPiContextHandler(pi, baseOptions) {
       if (!usedPersistedUsage && isSaneLimit(usageContextLimit) && usageInputTokens > 0) {
         usagePercentage = usageInputTokens / usageContextLimit * 100;
       }
-      ({ percentage: usagePercentage, inputTokens: usageInputTokens } = resolvePiPressureSnapshot({
+      ({ percentage: usagePercentage, inputTokens: usageInputTokens } = resolvePiPressureSnapshotWithEstimateGuard({
+        sessionId,
+        source: "transform",
+        liveIsRawBranchEstimate: piLiveUsageIsRawBranchEstimate,
+        persistedFromLive: !usedPersistedUsage,
         persistedPercentage: usagePercentage,
         persistedInputTokens: usageInputTokens,
         liveInputTokens: piUsage?.tokens,
@@ -30046,6 +30774,7 @@ function registerPiContextHandler(pi, baseOptions) {
           sessionMeta,
           piUsage,
           minimumPercentage: usagePercentage,
+          liveIsRawBranchEstimate: piLiveUsageIsRawBranchEstimate,
           historianStateSnapshot: historianStateForPass,
           publishedHistoryRide: isCacheBusting
         });
@@ -30123,6 +30852,34 @@ function registerPiContextHandler(pi, baseOptions) {
         sessionLog(sessionId, `synthetic todowrite injection failed: ${err instanceof Error ? err.message : String(err)}`);
       }
       logTransformTiming(sessionId, "todoCapture", tTodoCapture);
+      const tThinkingBinding = performance.now();
+      const outputEntryIds = resolvePiLkgOutputEntryIds(outputMessages, result.syntheticLeadingCount, (message) => result.lkgEntryIdByRef.get(message) ?? result.postCommitEntryIdByRef.get(message) ?? bindingEntryIdByRef.get(message)).map((entryId) => entryId ?? undefined);
+      const thinkingBindingRecoveryApplied = bindingStripOrder === "end" ? applyPiThinkingBindingRecovery({
+        db: options.db,
+        sessionId,
+        messages: outputMessages,
+        entryIds: outputEntryIds,
+        provider: lkgProviderKey ?? undefined,
+        model: ctx.model?.id,
+        endOfPassOrder: true
+      }) : startOfPassBindingRecovery;
+      if (!options.compactionOff && !sessionMeta.isSubagent && bindingStripOrder === "end") {
+        try {
+          applyPiProactiveThinkingStrip({
+            db: options.db,
+            sessionId,
+            messages: outputMessages,
+            entryIds: outputEntryIds,
+            provider: lkgProviderKey ?? undefined,
+            model: ctx.model?.id,
+            cacheBustingPass: isCacheBusting || result.executedWorkThisPass,
+            report: (line) => sessionLog(sessionId, line)
+          });
+        } catch (err) {
+          sessionLog(sessionId, `proactive thinking strip failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      logTransformTiming(sessionId, "thinkingBinding", tThinkingBinding);
       const tChannelAccounting = performance.now();
       try {
         const sessionMetaForCh1 = sessionMeta;
@@ -30602,7 +31359,11 @@ function maybeFireHistorian(args) {
       };
       usageSource = "piUsage fallback";
     }
-    usage = resolvePiPressureSnapshot({
+    usage = resolvePiPressureSnapshotWithEstimateGuard({
+      sessionId,
+      source: "historian trigger",
+      liveIsRawBranchEstimate: args.liveIsRawBranchEstimate,
+      persistedFromLive: usageSource === "piUsage fallback",
       persistedPercentage: usage.percentage,
       persistedInputTokens: usage.inputTokens,
       liveInputTokens: piUsage?.tokens,
@@ -30925,6 +31686,7 @@ async function runPipeline(args) {
   const foldDueDecision = piM0State ? mustMaterializePi(piM0State, args.db, injectionPassSnapshot?.compartments, injectionPassSnapshot) : { value: false, reason: null };
   const firstRenderBust = piM0State !== undefined && !(injectionPassSnapshot?.cachedRow?.cached_m0_bytes && injectionPassSnapshot.cachedRow.cached_m1_bytes);
   let foldExecutedThisPass = false;
+  let foldBustsServedPrefixThisPass = false;
   let publishedM1RefreshedThisPass = false;
   let prefixPreflightContended = false;
   const softRefreshOpportunity = args.schedulerDecision === "execute";
@@ -30938,6 +31700,18 @@ async function runPipeline(args) {
       prefixPreflightContended = preFoldInjectionResult.contentionExhausted === true;
       publishedM1RefreshedThisPass = !prefixPreflightContended && persistedM0BeforeFold.cachedM1Bytes?.toString("utf8") !== getOrCreateSessionMeta(args.db, args.sessionId).cachedM1Bytes?.toString("utf8");
       foldExecutedThisPass = foldExecutesThisPass(foldDueDecision.value || softRefreshOpportunity, preFoldInjectionResult.m0Materialized === true);
+      if (foldExecutedThisPass) {
+        const afterFold = getOrCreateSessionMeta(args.db, args.sessionId);
+        foldBustsServedPrefixThisPass = foldBustsServedPrefix(foldDueDecision.reason, {
+          m0Bytes: persistedM0BeforeFold.cachedM0Bytes ?? null,
+          m1Bytes: persistedM0BeforeFold.cachedM1Bytes ?? null,
+          muralDataUrl: persistedM0BeforeFold.cachedM0MuralDataUrl ?? null
+        }, {
+          m0Bytes: afterFold.cachedM0Bytes ?? null,
+          m1Bytes: afterFold.cachedM1Bytes ?? null,
+          muralDataUrl: afterFold.cachedM0MuralDataUrl ?? null
+        });
+      }
       if (preFoldInjectionResult.m0Materialized) {
         injectionPassSnapshot = createPiM0M1PassSnapshot({
           db: args.db,
@@ -30965,7 +31739,7 @@ async function runPipeline(args) {
       sessionLog(args.sessionId, `pi m[0] HARD fold pre-execution failed: ${error instanceof Error ? error.message : String(error)}`);
     }
     const mismatch = foldDueDecision.mismatch ? ` mismatch=${JSON.stringify(foldDueDecision.mismatch)}` : "";
-    sessionLog(args.sessionId, `pi m[0] HARD fold decision: reason=${foldDueDecision.reason ?? "unknown"}${mismatch} executed=${foldExecutedThisPass}`);
+    sessionLog(args.sessionId, `pi m[0] HARD fold decision: reason=${foldDueDecision.reason ?? "unknown"}${mismatch} executed=${foldExecutedThisPass} bustsServedPrefix=${foldBustsServedPrefixThisPass}`);
   }
   const executePressureEligible = args.schedulerDecision === "execute" || emergencyDropEligible;
   if (!executePressureEligible) {
@@ -30976,7 +31750,7 @@ async function runPipeline(args) {
   const routinePressureAlreadyApplied = !args.sessionMeta.isSubagent && executePressureEligible && routinePressureAppliedBySession.get(args.sessionId) === true;
   const hasPendingMaterializeSignal = hasPendingMaterialization(args.sessionId);
   const rideSignals = {
-    hardFold: foldExecutedThisPass || firstRenderBust,
+    hardFold: foldBustsServedPrefixThisPass || firstRenderBust,
     force: (args.forceMaterialization === true || emergencyDropEligible) && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
     explicitFlush: hasPendingMaterializeSignal || deferredMaterializeEligible && !prefixPreflightContended,
     publishedHistory: !prefixPreflightContended && (args.isCacheBusting || publishedM1RefreshedThisPass || canConsumeDeferredLate && deferredHistoryWasPendingAtPassStart)
@@ -30992,7 +31766,7 @@ async function runPipeline(args) {
     onRejectedProjectOverride: (warning) => sessionLog(args.sessionId, warning)
   });
   let protectionFloorResolution = resolveProtectionFloor();
-  const shouldRunHeuristics = args.heuristics !== undefined && isCacheBustingPass && (rideSignals.publishedHistory || args.forceMaterialization === true || hasPendingMaterializeSignal || deferredMaterializeEligible || foldExecutedThisPass || firstRenderBust || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
+  const shouldRunHeuristics = args.heuristics !== undefined && isCacheBustingPass && (rideSignals.publishedHistory || args.forceMaterialization === true || hasPendingMaterializeSignal || deferredMaterializeEligible || foldBustsServedPrefixThisPass || firstRenderBust || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
   const tFallbackIdentity = performance.now();
   const hasFallbackMessageTags = hasPiFallbackMessageTags(args.db, args.sessionId);
   const entryFingerprintByMessageId = buildEntryFingerprintMap(args.messages, stableIdResolver, args.reusableMessageIds, hasFallbackMessageTags);
@@ -31032,6 +31806,19 @@ async function runPipeline(args) {
     } : undefined
   });
   logTransformTiming(args.sessionId, "tagMessages", tTag);
+  if (foldBustsServedPrefixThisPass) {
+    try {
+      let converted = 0;
+      args.db.transaction(() => {
+        converted = convertLegacyToolSkeletons(args.db, args.sessionId, targets).size;
+      }).immediate();
+      if (converted > 0) {
+        sessionLog(args.sessionId, `pi HARD fold converted ${converted} legacy dropped-tool skeleton(s) to real-or-absent`);
+      }
+    } catch (error) {
+      sessionLog(args.sessionId, `pi legacy dropped-tool skeleton conversion failed (kept legacy bytes): ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
   try {
     if (!args.sessionMeta.isSubagent) {
       const hasRecentCommit = detectRecentCommit(args.messages);
@@ -31058,12 +31845,13 @@ async function runPipeline(args) {
   mutationGateObserverForTests?.({
     foldDue: foldDueDecision.value,
     foldExecuted: foldExecutedThisPass,
+    foldBustsServedPrefix: foldBustsServedPrefixThisPass,
     shouldApplyPendingOps,
     shouldRunHeuristics,
     shouldRunReasoningCleanup: args.reasoningClearing !== undefined && shouldRunHeuristics
   });
   if (shouldApplyPendingOps) {
-    const applyReason = hasPendingMaterializeSignal ? "explicit_flush" : deferredMaterialize ? "deferred_publication" : args.forceMaterialization ? "force_materialization" : foldExecutedThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (scheduler=${args.schedulerDecision})`;
+    const applyReason = hasPendingMaterializeSignal ? "explicit_flush" : deferredMaterialize ? "deferred_publication" : args.forceMaterialization ? "force_materialization" : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (scheduler=${args.schedulerDecision})`;
     const pendingOpsDepth = getPendingOpsCount(args.db, args.sessionId);
     const pendingDecisionLog = `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOpsDepth === null ? "not loaded (deferred pass)" : pendingOpsDepth} context=${args.contextUsage.percentage.toFixed(1)}%`;
     sessionLog(args.sessionId, pendingDecisionLog);
@@ -31150,7 +31938,7 @@ async function runPipeline(args) {
   const activeTags = allTagsForPass.filter((tag) => tag.status === "active");
   logTransformTiming(args.sessionId, "getTagsBySessionSnapshot", tActiveTags, `all=${allTagsForPass.length} active=${activeTags.length}`);
   if (shouldRunHeuristics) {
-    const reason = args.forceMaterialization ? "force_materialization" : foldExecutedThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
+    const reason = args.forceMaterialization ? "force_materialization" : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     const heuristicsDecisionLog = `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=n/a`;
     sessionLog(args.sessionId, heuristicsDecisionLog);
     pendingDecisionLogObserverForTests?.(heuristicsDecisionLog);
@@ -31163,7 +31951,7 @@ async function runPipeline(args) {
   if (shouldRunHeuristics && args.heuristics) {
     try {
       const tHeuristic = performance.now();
-      const independentMutationBeforeHeuristics = pendingOpsDidMutate || foldExecutedThisPass;
+      const independentMutationBeforeHeuristics = pendingOpsDidMutate || foldBustsServedPrefixThisPass;
       if (args.forceMaterialization === true && independentMutationBeforeHeuristics && getEmergencyInputSample(args.db, args.sessionId) > 0) {
         clearEmergencyDropSample(args.db, args.sessionId);
       }
@@ -31937,6 +32725,10 @@ ${result}`;
   });
 }
 
+// ../plugin/src/features/magic-context/store-generation-rebase.ts
+var rebasesInFlight = new WeakMap;
+var repairCheckedSessions = new WeakMap;
+
 // ../plugin/src/hooks/magic-context/historian-state-file.ts
 import { mkdirSync as mkdirSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "node:fs";
 function cleanupHistorianStateFile(path) {
@@ -32000,6 +32792,7 @@ async function sendStatusNotification(_client, sessionId, text, params) {
 var inconsistentProducerWindows = new Set;
 var HISTORIAN_ALERT_COOLDOWN_MS2 = 60 * 1000;
 var lastHistorianAlertBySession2 = new Map;
+var STORED_COMPARTMENT_FAILURE_BACKOFF_MS = 30 * 60 * 1000;
 
 // ../plugin/src/hooks/magic-context/compartment-runner-recomp.ts
 function insertRecompCompartmentRows(db, sessionId, compartments, now) {
@@ -32138,7 +32931,7 @@ Found ${existingStaging.compartments.length} staged compartment(s) from ${existi
         clearInjectionCache(sessionId);
       }
       promoted.facts;
-      if (deps.memoryEnabled !== false) {
+      {
         const projectIdentity = resolveProjectIdentity(sessionDirectory);
         await deps.ensureProjectRegistered?.(sessionDirectory, db);
         const liveCompartments = getCompartments(db, sessionId);
@@ -32355,7 +33148,7 @@ Another process acquired the compartment-state lease before recomp could publish
       queueDropsForCompartmentalizedMessages(db, sessionId, lastCompartmentEnd, compartmentTagKeys);
     }
     deps.onCompartmentStatePublished?.(sessionId);
-    if (deps.memoryEnabled !== false) {
+    {
       const projectIdentity = resolveProjectIdentity(sessionDirectory);
       await deps.ensureProjectRegistered?.(sessionDirectory, db);
       const liveCompartments = getCompartments(db, sessionId);
@@ -32517,7 +33310,7 @@ Could not acquire the compartment-state lease for this session.`;
         clearInjectionCache(sessionId);
       }
       deps.onCompartmentStatePublished?.(sessionId);
-      if (deps.memoryEnabled !== false) {
+      {
         const projectIdentity = resolveProjectIdentity(sessionDirectory);
         const liveCompartments = getCompartments(db, sessionId);
         const chunksToEmbed = liveCompartments.map((c) => ({
@@ -33544,6 +34337,11 @@ function compressionText(summary) {
       return "Waiting for enough conversation history";
   }
 }
+function runnerText(status) {
+  const why = status.source === "configured" ? "configured" : `default for harness ${status.harness || "unknown"}`;
+  const observed = status.observed === "last_completion" ? "" : " · no completion yet";
+  return `${status.runner} (${why})${observed}`;
+}
 function reclaimableText(summary) {
   const count = Math.max(0, Math.floor(summary.reclaimable.toolOutputCount));
   if (count === 0)
@@ -33585,6 +34383,12 @@ function renderUserStatusSummary(summary, style) {
     ],
     ["Search indexing", embeddingText(summary)]
   ];
+  if (summary.historianRunner) {
+    values.push(["Historian runner", runnerText(summary.historianRunner)]);
+  }
+  if (summary.dreamerRunner) {
+    values.push(["Dreamer runner", runnerText(summary.dreamerRunner)]);
+  }
   if (summary.historianRefusal) {
     values.push([
       "Historian refusal",
@@ -34063,7 +34867,7 @@ function buildStatusView(source, options) {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.43.1",
+  version: "0.44.0",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -34090,6 +34894,7 @@ var package_default = {
     "dist",
     "README.md"
   ],
+  "//": "The build intentionally bundles typebox (no --external typebox) and keeps it a regular dependency. OMP's extension loader rewrites every bare `typebox` import to its own omptype-based shim, whose schemas are callable objects rather than JSON Schema; they fail structuredClone during tool registration, so an external typebox import stops Magic Context loading on OMP. src/typebox-bundling.test.ts guards this.",
   scripts: {
     build: "bun ../../scripts/check-bun.mjs && tsc -p ../retina-local-fs/tsconfig.build.json && rm -f dist/index.js dist/subagent-entry.js dist/historian-calibration-extension.js dist/transformers-web.js dist/transformers-node-wasm.js dist/*-*.js && bun build ../plugin/src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun ../plugin/scripts/build-transformers-node-wasm.ts dist && bun build src/index.ts src/subagent-entry.ts src/historian-calibration-extension.ts --outdir dist --target node --format esm --splitting --external @earendil-works/pi-coding-agent --external @earendil-works/pi-tui --external onnxruntime-node --external onnxruntime-web --external sharp --external node:sqlite",
     "build:e2e-argv": "bun build src/subagent-runner.ts --outfile ../../tests/docker/.generated/subagent-runner-e2e.mjs --target node --format esm --external node:sqlite",
@@ -34104,7 +34909,7 @@ var package_default = {
     prepublishOnly: "bun run build"
   },
   dependencies: {
-    "@cortexkit/subc-client": "0.4.1",
+    "@cortexkit/subc-client": "0.11.1",
     "@jitl/quickjs-singlefile-cjs-release-asyncify": "0.32.0",
     "ai-tokenizer": "^1.0.6",
     "comment-json": "^5.0.0",
@@ -34126,6 +34931,7 @@ var package_default = {
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "^1.3.10",
     "@types/node": "^22.20.0",
+    "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-coding-agent-086": "npm:@earendil-works/pi-coding-agent@0.86.0",
     "pi-coding-agent-087": "npm:@earendil-works/pi-coding-agent@0.87.1",
@@ -34666,11 +35472,14 @@ No active Pi session is available.`,
       }
       try {
         if (ctx.hasUI) {
+          if (currentDeps.modelChainWarning)
+            ctx.ui.notify(currentDeps.modelChainWarning, "error");
           await showStatusDialog(pi, ctx, currentDeps);
           return;
         }
         const statusDetail = buildPiStatusDetail(pi, ctx, currentDeps, sessionId);
-        const statusText = formatPiStatusSummary(statusDetail);
+        const statusText = `${formatPiStatusSummary(statusDetail)}${currentDeps.modelChainWarning ? `
+WARNING: ${currentDeps.modelChainWarning}` : ""}`;
         const details = buildStatusDetails(currentDeps, statusDetail);
         sendStatus({
           title: "/ctx-status",
@@ -35457,7 +36266,7 @@ function ensureConfigLocationsMigrated(dir) {
   });
 }
 function logPiConfigLoad(args) {
-  const key = resolve3(args.dir);
+  const key = resolve4(args.dir);
   if (args.dedupe && loggedPiConfigDirs.has(key))
     return;
   if (args.dedupe) {
@@ -35518,6 +36327,13 @@ function logPiUsageBoundOnce(sessionId, reading, absoluteWall, reason) {
   piUsageBoundLogSeen.add(key);
   info(`message_end: session=${sessionId} bounded ${reason} ${reading} at trusted absolute wall ${absoluteWall}; pressure_proof_not_capacity`);
 }
+function logPiUsageAboveWindowOnce(sessionId, reading, absoluteWall) {
+  const key = `${sessionId}|accepted above window`;
+  if (piUsageBoundLogSeen.has(key))
+    return;
+  piUsageBoundLogSeen.add(key);
+  info(`message_end: session=${sessionId} provider usage ${reading} exceeds configured window ${absoluteWall}; counted as real pressure against the configured limit`);
+}
 function resolvePiPressureContextLimit(args) {
   let detectedContextLimit;
   try {
@@ -35549,24 +36365,32 @@ async function persistPiPressureFromMessageEnd(args) {
   });
   const trustedAbsoluteWall = reportedGeometry && hasTrustedAbsoluteWall(reportedGeometry) ? reportedGeometry.derivation.absoluteWall : undefined;
   const unboundedPressure = computePiPressure(usage, args.piContextWindow);
-  const rawPressure = computePiPressure(usage, args.piContextWindow, trustedAbsoluteWall);
-  if (unboundedPressure && trustedAbsoluteWall !== undefined && unboundedPressure.inputTokens > trustedAbsoluteWall) {
-    logPiUsageBoundOnce(args.sessionId, unboundedPressure.inputTokens, trustedAbsoluteWall, "current reading");
-  }
   const msg = args.message && typeof args.message === "object" ? args.message : undefined;
   const messageHadOverflowError = typeof msg?.errorMessage === "string" && detectOverflow(msg.errorMessage).isOverflow;
-  const requestSucceeded = !messageHadOverflowError && !(unboundedPressure && trustedAbsoluteWall !== undefined && unboundedPressure.inputTokens > trustedAbsoluteWall);
-  if (requestSucceeded && rawPressure) {
+  const readingAboveTrustedWall = unboundedPressure !== null && trustedAbsoluteWall !== undefined && unboundedPressure.inputTokens > trustedAbsoluteWall;
+  const requestAccepted = !messageHadOverflowError;
+  if (readingAboveTrustedWall && unboundedPressure && trustedAbsoluteWall) {
+    if (requestAccepted) {
+      logPiUsageAboveWindowOnce(args.sessionId, unboundedPressure.inputTokens, trustedAbsoluteWall);
+    } else {
+      logPiUsageBoundOnce(args.sessionId, unboundedPressure.inputTokens, trustedAbsoluteWall, "current reading");
+    }
+  }
+  const requestSucceeded = requestAccepted && !readingAboveTrustedWall;
+  if (requestAccepted && unboundedPressure) {
     const rawOverflow = getOverflowState(args.db, args.sessionId);
     const detectedLimitMatchesModel = rawOverflow.detectedContextLimitModelKey === null || modelKey !== undefined && rawOverflow.detectedContextLimitModelKey === modelKey;
-    if (rawOverflow.detectedContextLimit > 0 && detectedLimitMatchesModel && rawPressure.inputTokens > rawOverflow.detectedContextLimit) {
+    if (rawOverflow.detectedContextLimit > 0 && detectedLimitMatchesModel && unboundedPressure.inputTokens > rawOverflow.detectedContextLimit) {
       clearDetectedContextLimit(args.db, args.sessionId);
-      info(`message_end: detected limit ${rawOverflow.detectedContextLimit} invalidated by a successful ${rawPressure.inputTokens}-token request; using Pi contextWindow`);
+      info(`message_end: detected limit ${rawOverflow.detectedContextLimit} invalidated by a successful ${unboundedPressure.inputTokens}-token request; using Pi contextWindow`);
     }
   }
   const meta = getOrCreateSessionMeta(args.db, args.sessionId);
   let observedSafeInputTokens = meta.observedSafeInputTokens ?? 0;
-  const updates = { lastResponseTime: Date.now() };
+  const updates = {};
+  if (unboundedPressure !== null) {
+    updates.lastResponseTime = Date.now();
+  }
   if (trustedAbsoluteWall !== undefined && observedSafeInputTokens > trustedAbsoluteWall) {
     logPiUsageBoundOnce(args.sessionId, observedSafeInputTokens, trustedAbsoluteWall, "persisted floor");
     observedSafeInputTokens = 0;
@@ -35587,8 +36411,10 @@ async function persistPiPressureFromMessageEnd(args) {
     provenInputTokens: observedSafeInputTokens
   });
   const reportedContextLimit = reportedGeometry?.usableSoft ?? 0;
-  const pressure = computePiPressure(usage, effectiveContextLimit, trustedAbsoluteWall);
+  const pressure = computePiPressure(usage, effectiveContextLimit, requestAccepted ? undefined : trustedAbsoluteWall);
+  let cacheAlert;
   if (pressure) {
+    notePiUsageReadingUsed(args.sessionId);
     const provenSafeInputTokens = requestSucceeded ? Math.max(observedSafeInputTokens, pressure.inputTokens) : observedSafeInputTokens;
     const contextLimit = requestSucceeded ? resolvePiPressureContextLimit({
       db: args.db,
@@ -35602,7 +36428,7 @@ async function persistPiPressureFromMessageEnd(args) {
     if (requestSucceeded && reportedContextLimit > 0 && reportedContextLimit < provenSafeInputTokens && !meta.cacheAlertSent) {
       updates.cacheAlertSent = true;
       const modelLabel = activeModel.provider && activeModel.id ? `${activeModel.provider}/${activeModel.id}` : "the active model";
-      await args.notifyIssue?.(`⚠️ Magic Context: Pi reports a context limit of ${formatTokens(reportedContextLimit)} tokens for ${modelLabel}, but this session has sent ${formatTokens(provenSafeInputTokens)} tokens successfully. Magic Context will keep using the larger proven value for its pressure math. If Pi's model metadata is wrong for your provider, set contextWindow for that model in Pi's model configuration.`);
+      cacheAlert = `⚠️ Magic Context: Pi reports a context limit of ${formatTokens(reportedContextLimit)} tokens for ${modelLabel}, but this session has sent ${formatTokens(provenSafeInputTokens)} tokens successfully. Magic Context will keep using the larger proven value for its pressure math. If Pi's model metadata is wrong for your provider, set contextWindow for that model in Pi's model configuration.`;
     }
     updates.lastContextPercentage = percentage;
     updates.lastInputTokens = pressure.inputTokens;
@@ -35611,13 +36437,21 @@ async function persistPiPressureFromMessageEnd(args) {
       updates.observedSafeInputTokens = provenSafeInputTokens;
     }
   } else if (usage === null && typeof args.piTokens === "number" && (trustedAbsoluteWall === undefined || args.piTokens <= trustedAbsoluteWall)) {
-    updates.lastInputTokens = args.piTokens;
-    if (effectiveContextLimit > 0) {
-      updates.lastContextPercentage = args.piTokens / effectiveContextLimit * 100;
-      updates.lastUsageContextLimit = effectiveContextLimit;
+    if (args.piTokensIsRawBranchEstimate === true) {
+      noteRawBranchEstimateSetAside(args.sessionId, args.piTokens, "message_end estimate");
+    } else {
+      notePiUsageReadingUsed(args.sessionId);
+      updates.lastInputTokens = args.piTokens;
+      if (effectiveContextLimit > 0) {
+        updates.lastContextPercentage = args.piTokens / effectiveContextLimit * 100;
+        updates.lastUsageContextLimit = effectiveContextLimit;
+      }
     }
   }
   updateSessionMeta(args.db, args.sessionId, updates);
+  if (cacheAlert !== undefined) {
+    await args.notifyIssue?.(cacheAlert);
+  }
 }
 var PLUGIN_VERSION = (() => {
   try {
@@ -35628,17 +36462,27 @@ var PLUGIN_VERSION = (() => {
   }
 })();
 setHarness(PI_HARNESS_KIND);
-function resolveHistorianFromConfig(config, harness = PI_HARNESS_KIND) {
+function resolveHistorianFromConfig(config, harness = PI_HARNESS_KIND, modelRegistry) {
   const historian = config.historian;
   if (historian?.disable === true)
     return;
   const resolved = resolveHistorianModel(config, harness);
-  const model = resolved.primary?.model;
+  const validated = modelRegistry && resolved.primary ? validatePiDreamerModels([
+    {
+      task: "classify-memories",
+      schedule: "",
+      timeoutMinutes: 20,
+      model: resolved.primary,
+      fallbackModels: resolved.fallbacks
+    }
+  ], modelRegistry)[0] : undefined;
+  const primary = validated ? typeof validated.model === "string" ? { model: validated.model } : validated.model : resolved.primary;
+  const model = primary?.model;
   if (!model)
     return;
   const historianContextLimit = resolveHistorianContextLimit(model);
   const historianChunkTokens = deriveHistorianChunkTokens(historianContextLimit);
-  const fallbackModels = resolved.fallbacks;
+  const fallbackModels = validated?.fallbackModels ?? resolved.fallbacks;
   return {
     runner: new PiSubagentRunner,
     model,
@@ -35649,7 +36493,7 @@ function resolveHistorianFromConfig(config, harness = PI_HARNESS_KIND) {
     temperature: historian?.temperature,
     maxOutputTokens: historian?.maxTokens,
     twoPass: historian?.two_pass === true,
-    thinkingLevel: resolved.primary?.qualifier,
+    thinkingLevel: primary?.qualifier,
     executeThresholdPercentage: config.execute_threshold_percentage,
     executeThresholdTokens: config.execute_threshold_tokens,
     commitClusterTrigger: config.commit_cluster_trigger,
@@ -35713,30 +36557,7 @@ async function src_default(pi) {
       return null;
     }
   };
-  const unavailableReason = () => {
-    const migration = getMigrationOnOpenRefusal();
-    const blockingProcesses = migration?.blockingProcesses ?? migration?.serverPids.map((pid) => ({ kind: "process", pid })) ?? [];
-    const fence = getSchemaFenceRejection();
-    if (migration && blockingProcesses.length > 0) {
-      return {
-        kind: "migration_guard",
-        persistedVersion: migration.persistedVersion,
-        supportedVersion: migration.supportedVersion,
-        blockingProcesses
-      };
-    }
-    if (fence) {
-      return {
-        kind: "schema_fence",
-        persistedVersion: fence.persistedVersion,
-        supportedVersion: fence.supportedVersion
-      };
-    }
-    return {
-      kind: "storage_failure",
-      cause: migration?.unreadableFile ? `migration guard could not read RPC discovery file ${migration.unreadableFile}` : openFailureCause ?? `storage unavailable at ${dbPath} (cache schema newer than this binary, or open failed)`
-    };
-  };
+  const unavailableReason = () => describeStorageUnavailability(openFailureCause ?? `storage unavailable at ${dbPath} (cache schema newer than this binary, or open failed)`);
   const bootResult = await bootPiRuntimeWithDeadline({
     deadlineMs: PI_BOOT_DEADLINE_MS,
     openStorage,
@@ -35922,15 +36743,8 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       maybeAutoEmbedPiSession({
         db: database,
         projectDir: dir,
-        projectIdentity: identity,
-        memoryEnabled: cfg.memory.enabled
-      }, sessionId, dir, identity, (text) => {
-        sendCtxStatusMessage(pi, {
-          title: "/ctx-embed",
-          text,
-          level: "info"
-        });
-      });
+        projectIdentity: identity
+      }, sessionId, dir, identity);
     }
   });
   function buildProjectDeps(dir, identity, cfg, loadMetadata) {
@@ -35984,10 +36798,11 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
   function resolveCurrentProjectDeps(ctx) {
     return resolveProjectDepsForDir(ctx.cwd);
   }
+  let activeModelRegistry;
   function resolveContextOptionsForProject(dir) {
     const project = resolveProjectDepsForDir(dir);
     const sampled = historianRunConfig(project.config, liveReaderFor(dir, project.config).poll().effective);
-    const historian = resolveHistorianFromConfig(sampled);
+    const historian = resolveHistorianFromConfig(sampled, PI_HARNESS_KIND, activeModelRegistry);
     return { ...project.contextOptions, historian };
   }
   const bootProjectDeps = buildProjectDeps(projectDir, projectIdentity, config, {
@@ -35996,7 +36811,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     hasDeprecatedProtectedTags
   });
   projectDepsByDir.set(projectDir, bootProjectDeps);
-  function syncDreamerProjectRegistration(current) {
+  function syncDreamerProjectRegistration(current, modelRegistry) {
     if (sessionShuttingDown)
       return;
     seenDreamerProjectIdentities.add(current.projectIdentity);
@@ -36013,6 +36828,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       projectIdentity: current.projectIdentity,
       registrationOwner: dreamerRegistrationOwner,
       config: current.dreamerConfig,
+      modelRegistry,
       sampleDreamRun: () => {
         const fresh = liveReaderFor(current.projectDir, current.config).poll().effective;
         const sampled = dreamerRunConfig(current.config, fresh);
@@ -36054,6 +36870,8 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
   pi.on("session_start", async (event, ctx) => {
     projectDepsByDir.delete(ctx.cwd);
     const current = resolveCurrentProjectDeps(ctx);
+    activeModelRegistry = ctx.modelRegistry;
+    syncDreamerProjectRegistration(current, ctx.modelRegistry);
     syncCtxMemoryToolEnabled(pi, current.config.memory.enabled);
     const failuresToShow = claimConfigParseFailuresOnce("pi", current.configParseFailures);
     if (ctx.hasUI && failuresToShow.length > 0) {
@@ -36132,6 +36950,16 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
           runnable: current.dreamerEnabled,
           scheduleSummary: summarizeDreamSchedule(current.config.dreamer)
         },
+        modelChainWarning: (() => {
+          const registry = activeModelRegistry;
+          if (!registry)
+            return;
+          const tasks = validatePiDreamerModels(buildDreamTaskRuntimeConfigs(current.config.dreamer, PI_HARNESS_KIND, current.config.language, current.config.mural.model), registry);
+          const empty = tasks.filter((task) => task.modelChainUnavailable).map((task) => task.task);
+          if (!resolveHistorianFromConfig(current.config, PI_HARNESS_KIND, registry) && current.historianConfig)
+            empty.push("historian");
+          return empty.length ? `Pi model chain empty (no model found): ${empty.join(", ")}` : undefined;
+        })(),
         activeProfile: current.config.profile,
         cacheTtlConfig: current.config.cache_ttl,
         cacheTtlConfigured: current.cacheTtlConfigured,
@@ -36161,7 +36989,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     resolveRuntimeDeps: (ctx) => {
       const current = resolveCurrentProjectDeps(ctx);
       const fresh = historianRunConfig(current.config, liveReaderFor(current.projectDir, current.config).poll().effective);
-      const historian = resolveHistorianFromConfig(fresh) ?? current.historianConfig;
+      const historian = resolveHistorianFromConfig(fresh, PI_HARNESS_KIND, activeModelRegistry);
       return {
         db,
         runner: recompRunner,
@@ -36196,7 +37024,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     resolveRuntimeDeps: (ctx) => {
       const current = resolveCurrentProjectDeps(ctx);
       const fresh = historianRunConfig(current.config, liveReaderFor(current.projectDir, current.config).poll().effective);
-      const historian = resolveHistorianFromConfig(fresh) ?? current.historianConfig;
+      const historian = resolveHistorianFromConfig(fresh, PI_HARNESS_KIND, activeModelRegistry);
       return {
         db,
         runner: wrapupRunner,
@@ -36230,7 +37058,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     dreamerEnabled: bootProjectDeps.dreamerEnabled,
     resolveDreamerEnabled: (ctx) => resolveCurrentProjectDeps(ctx).dreamerEnabled,
     onProjectSeen: (identity) => seenDreamerProjectIdentities.add(identity),
-    ensureRegistered: (ctx) => syncDreamerProjectRegistration(resolveCurrentProjectDeps(ctx)),
+    ensureRegistered: (ctx) => syncDreamerProjectRegistration(resolveCurrentProjectDeps(ctx), ctx.modelRegistry),
     registrationOwner: dreamerRegistrationOwner
   });
   info("registered /ctx-dream");
@@ -36238,8 +37066,6 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     db,
     projectDir,
     projectIdentity,
-    memoryEnabled: bootProjectDeps.config.memory.enabled,
-    resolveMemoryEnabled: (ctx) => resolveCurrentProjectDeps(ctx).config.memory.enabled,
     resolveProject: (ctx) => {
       const current = resolveCurrentProjectDeps(ctx);
       return {
@@ -36283,7 +37109,8 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       };
       const effectiveConfig = effectiveProjectDeps.config;
       try {
-        syncDreamerProjectRegistration(effectiveProjectDeps);
+        activeModelRegistry = ctx.modelRegistry;
+        syncDreamerProjectRegistration(effectiveProjectDeps, ctx.modelRegistry);
       } catch (err) {
         warn("before_agent_start: dreamer registration sync threw:", err);
       }
@@ -36483,6 +37310,14 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         piContextWindowSource: "catalog",
         piModel: ctx.model,
         piTokens: piUsage && typeof piUsage.tokens === "number" ? piUsage.tokens : undefined,
+        piTokensIsRawBranchEstimate: (() => {
+          try {
+            const branch = ctx.sessionManager.getBranch?.();
+            return isPiLiveUsageRawBranchEstimate(branch);
+          } catch {
+            return false;
+          }
+        })(),
         notifyIssue: async (message) => {
           const uiNotify = ctx.ui?.notify;
           if (typeof uiNotify === "function") {