@cortexkit/opencode-magic-context 0.35.1 → 0.36.1

package/dist/index.js

@@ -25,6 +25,14 @@ import {
   GLOBAL_USER_PROFILE_PROJECT_PATH,
   HISTORIAN_EDITOR_SYSTEM_PROMPT,
   LATEST_SUPPORTED_VERSION,
+  LKG_SNAPSHOT_ARRAY,
+  LKG_SNAPSHOT_BOOLEAN,
+  LKG_SNAPSHOT_KEY,
+  LKG_SNAPSHOT_NULL,
+  LKG_SNAPSHOT_NUMBER,
+  LKG_SNAPSHOT_OBJECT,
+  LKG_SNAPSHOT_STRING,
+  LKG_SNAPSHOT_UNDEFINED,
   MARKER_SUMMARY_TEXT,
   MAX_EXECUTE_THRESHOLD,
   MagicContextConfigSchema,
@@ -52,6 +60,7 @@ import {
   appendAutoSearchHintDecision,
   applyDeferredCompactionMarker,
   applyMirrorPage,
+  applyMirroredNoteCompileFields,
   applyStrippedPlaceholderDelta,
   archiveMemory,
   backfillTagTokenCounts,
@@ -72,6 +81,7 @@ import {
   clearEmergencyDropSample,
   clearEmergencyRecovery,
   clearHistorianFailureState,
+  clearHookInitFailure,
   clearInjectionCache,
   clearMemoryVerifications,
   clearNoteNudgeTriggerAndCooldown,
@@ -91,6 +101,7 @@ import {
   countEmbeddedCommits,
   countPrimerCandidatesForProject,
   createChildSessionWithFence,
+  createFailClosedController,
   createPrimer,
   createPromptSurfaceGuidanceEpochCache,
   createPromptSurfaceRuntime,
@@ -145,6 +156,7 @@ import {
   getHistorianFailureState,
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
+  getLastHookInitFailure,
   getLastNudgeLevel,
   getLastNudgeUndropped,
   getLatestIndexedCommitTimeMs,
@@ -227,9 +239,11 @@ import {
   isDatabasePersisted,
   isEmbeddingEnabled,
   isEmergencyRecoveryArmed,
+  isFailClosedBlockingError,
   isPidAlive,
   isProviderOverflowReconfirmed,
   lkgContentDigest,
+  lkgContentDigestFromFields,
   loadCompartmentChunkEmbeddingsForSearch,
   loadPersistedUsage,
   loadProjectCommitEmbeddings,
@@ -265,6 +279,7 @@ import {
   prepareCompartmentInjection,
   primerOccurrenceKey,
   primerOccurrenceUtcDay,
+  promptSurfaceConfigIdentity,
   promptSurfaceHashMaterial,
   promptSyncWithValidatedOutputRetry,
   pruneAutoSearchHintDecisions,
@@ -282,6 +297,7 @@ import {
   recordDetectedContextLimit,
   recordEmbeddingMeasurement,
   recordHighPressureNoEligibleHead,
+  recordHookInitFailure,
   recordMemoryMapping,
   recordMemoryVerifications,
   recordMuralCueRejection,
@@ -311,6 +327,7 @@ import {
   resetLastNudgeCycleIfTailShrank,
   resetNoteNudgeCooldownOnly,
   resetProtectedTailNoEligibleHead,
+  resolveAgentNameFromMessages,
   resolveCompactionModeRecord,
   resolveGitTopLevel,
   resolveLegacyConfigSources,
@@ -356,6 +373,7 @@ import {
   setRecompTerminal,
   setSessionWorkMetrics,
   setSqlitePragmaConfig,
+  shouldBypassFailClosedBlock,
   shouldKeepSubagents,
   snapRangeToCompartments,
   sourceNameForMemory,
@@ -382,7 +400,7 @@ import {
   upsertCommits,
   verificationFileExists,
   withContentLanguageDirective
-} from "./index-fkyamz2w.js";
+} from "./index-1skzp4dc.js";
 import {
   deriveHistorianChunkTokens,
   deriveTriggerBudget,
@@ -394,7 +412,7 @@ import {
   setOutputReserveConfig,
   setStoragePrivatePermissionEnforcement,
   shouldEnforcePrivateStoragePermissions
-} from "./index-ry8rh8cv.js";
+} from "./index-wgvxkqpx.js";
 import {
   modelBodyField,
   resolveFallbackChain
@@ -406,7 +424,7 @@ import {
   getErrorMessage,
   sendIgnoredMessage,
   sendUserPrompt
-} from "./index-h5zjfesc.js";
+} from "./index-nsx2n9eg.js";
 import {
   ToolMutationBatch,
   advanceToolReclaimWatermark,
@@ -446,6 +464,7 @@ import {
   markSessionCleanupPending,
   normalizeText,
   partHasCompletedResult,
+  preloadTokenizer,
   prependTag,
   primeInMemoryTailRawMessageCache,
   primeTailRawMessageCache,
@@ -463,7 +482,7 @@ import {
   textMentionsRecentCommit,
   updateSessionMeta,
   withRawSessionMessageCache
-} from "./index-dpdnjawy.js";
+} from "./index-3zqcdwqr.js";
 import {
   Database,
   closeQuietly,
@@ -472,17 +491,18 @@ import {
   isMidTurn,
   openCodeDbExists,
   withReadOnlySessionDb
-} from "./index-w0nygb4p.js";
+} from "./index-3tnkymva.js";
 import {
   cleanupConflictWarnings,
   detectConflicts,
   sendConflictWarning
-} from "./index-8aaadh98.js";
+} from "./index-zp6x6s6a.js";
 import {
   detectConfigFile,
+  isPrototypePollutionKey,
   parseJsonc,
   stripJsonComments
-} from "./index-0c9dmw9m.js";
+} from "./index-8mtsfhyg.js";
 import {
   ANNOUNCEMENT_FEATURES,
   ANNOUNCEMENT_FOOTER,
@@ -491,7 +511,7 @@ import {
   isValidSemver,
   markAnnouncementSeen,
   shouldShowAnnouncement
-} from "./index-dmr999a2.js";
+} from "./index-qf20mv7e.js";
 import {
   acknowledgeNotifications,
   drainNotifications,
@@ -499,17 +519,17 @@ import {
   pushNotification,
   registerNotificationSink
 } from "./index-d62ypazr.js";
-import"./index-73xz0247.js";
+import"./index-tsgs7td8.js";
 import {
   log,
   sessionLog
-} from "./index-k1esqfwk.js";
+} from "./index-f1tnb3vm.js";
 import {
   getDataDir,
   getHarness,
   getMagicContextStorageDir,
   getOpenCodeStorageDir
-} from "./index-kvrcg31b.js";
+} from "./index-mmrhhk9a.js";
 import {
   resolvePromptContext
 } from "./index-szf8w1p5.js";
@@ -8370,6 +8390,49 @@ function buildAllowOnlyPermission(allowedTools, agentLabel) {
   }
   return permission;
 }
+function isPermissionAction(value) {
+  return value === "ask" || value === "allow" || value === "deny";
+}
+function isPermissionMap(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function denyTaskRoutingToAgents(permission, internalAgentIds) {
+  const configured = isPermissionAction(permission) ? { "*": permission } : isPermissionMap(permission) ? permission : {};
+  const { task, ...otherPermissions } = configured;
+  const configuredTask = isPermissionAction(task) ? { "*": task } : isPermissionMap(task) ? task : {};
+  const internalAgentIdSet = new Set(internalAgentIds);
+  const retainedTask = Object.fromEntries(Object.entries(configuredTask).filter(([agentId]) => !internalAgentIdSet.has(agentId)));
+  return {
+    ...otherPermissions,
+    task: {
+      ...retainedTask,
+      ...Object.fromEntries(internalAgentIds.map((agentId) => [agentId, "deny"]))
+    }
+  };
+}
+var BUILTIN_TASK_CALLER_IDS = ["build", "plan"];
+function isTaskRoutingCaller(agentId, config) {
+  const mode = config.mode;
+  if (mode === "primary")
+    return true;
+  if (mode === "subagent" || mode === "all")
+    return false;
+  return agentId === "build" || agentId === "plan";
+}
+function denyTaskRoutingToCallerAgents(agentConfigs, internalAgentIds) {
+  const result = { ...agentConfigs };
+  const candidateIds = new Set([...BUILTIN_TASK_CALLER_IDS, ...Object.keys(agentConfigs)]);
+  for (const agentId of candidateIds) {
+    const agentConfig = agentConfigs[agentId] ?? {};
+    if (!isTaskRoutingCaller(agentId, agentConfig))
+      continue;
+    result[agentId] = {
+      ...agentConfig,
+      permission: denyTaskRoutingToAgents(agentConfig.permission, internalAgentIds)
+    };
+  }
+  return result;
+}
 function applyDisallowedTools(defaults, disallowed) {
   if (disallowed.includes("*"))
     return [];
@@ -9463,10 +9526,15 @@ function loadConfigFileDetailed(configPath, source) {
       configPath,
       isProjectConfig: source === "project"
     });
+    const rejectedKeyPaths = [];
+    const config = parseJsonc(substituted.text, {
+      onRejectedKey: (path) => rejectedKeyPaths.push(path.join("."))
+    });
+    const unsafeKeyWarnings = rejectedKeyPaths.map((path) => `Ignored unsafe config key "${path}" (security: prototype-pollution keys are not allowed).`);
     return {
-      config: parseJsonc(substituted.text),
-      warnings: substituted.warnings.map((w) => `${configPath}: ${w}`),
-      outcome: substituted.warnings.length > 0 ? "substitution-failure" : "ok",
+      config,
+      warnings: [...substituted.warnings, ...unsafeKeyWarnings].map((warning) => `${configPath}: ${warning}`),
+      outcome: rejectedKeyPaths.length > 0 ? "schema-recovery" : substituted.warnings.length > 0 ? "substitution-failure" : "ok",
       source
     };
   } catch (error) {
@@ -9480,18 +9548,35 @@ function loadConfigFileDetailed(configPath, source) {
     };
   }
 }
+function defineOwnConfigValue(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
 function deepMergeRawConfig(base, override) {
-  const result = { ...base };
+  const result = {};
+  for (const key of Object.keys(base)) {
+    if (isPrototypePollutionKey(key))
+      continue;
+    defineOwnConfigValue(result, key, base[key]);
+  }
   for (const key of Object.keys(override)) {
-    const baseVal = base[key];
+    if (isPrototypePollutionKey(key))
+      continue;
+    const baseVal = Object.hasOwn(base, key) ? base[key] : undefined;
     const overrideVal = override[key];
+    let mergedValue;
     if (baseVal !== null && typeof baseVal === "object" && !Array.isArray(baseVal) && overrideVal !== null && typeof overrideVal === "object" && !Array.isArray(overrideVal)) {
-      result[key] = deepMergeRawConfig(baseVal, overrideVal);
+      mergedValue = deepMergeRawConfig(baseVal, overrideVal);
     } else if (key === "disabled_hooks" && Array.isArray(baseVal) && Array.isArray(overrideVal)) {
-      result[key] = [...new Set([...baseVal, ...overrideVal])];
+      mergedValue = [...new Set([...baseVal, ...overrideVal])];
     } else {
-      result[key] = overrideVal;
+      mergedValue = overrideVal;
     }
+    defineOwnConfigValue(result, key, mergedValue);
   }
   return result;
 }
@@ -10105,171 +10190,6 @@ function buildDreamTaskPrompt(task, args) {
   }
 }
 
-// src/features/magic-context/fail-closed-block.ts
-var FAIL_CLOSED_DOCTOR_COMMAND = "npx @cortexkit/magic-context@latest doctor";
-var FAIL_CLOSED_REPROBE_EVERY_N = 5;
-
-class FailClosedBlockingError extends Error {
-  code = "FAIL_CLOSED_BLOCKING";
-  reason;
-  constructor(message, reason, options) {
-    super(message, options);
-    this.name = "FailClosedBlockingError";
-    this.reason = reason;
-  }
-}
-var OPENCODE_INTERNAL_AGENT_NAMES = new Set(["title", "summary", "compaction"]);
-function isMagicContextHiddenAgentName(agent) {
-  if (agent === "sidekick" || agent === "smart-note-compiler" || agent.startsWith("smart-note-")) {
-    return true;
-  }
-  if (agent === "historian" || agent.startsWith("historian-"))
-    return true;
-  if (agent === "dreamer" || agent.startsWith("dreamer-"))
-    return true;
-  return false;
-}
-var MAX_FORMATTED_BLOCKING_PROCESSES = 8;
-function formatFailClosedBlockingProcesses(processes) {
-  const uniqueProcesses = new Map;
-  for (const process2 of processes) {
-    if (!process2.harness.trim() || !Number.isInteger(process2.pid) || process2.pid <= 0)
-      continue;
-    uniqueProcesses.set(`${process2.harness}\x00${process2.pid}`, {
-      harness: process2.harness.trim(),
-      pid: process2.pid
-    });
-  }
-  const entries = [...uniqueProcesses.values()];
-  const visible = entries.slice(0, MAX_FORMATTED_BLOCKING_PROCESSES);
-  const rendered = visible.map(({ harness, pid }) => `${harness} (PID ${pid})`);
-  const omitted = entries.length - visible.length;
-  if (omitted > 0)
-    rendered.push(`${omitted} more blocking process(es)`);
-  if (rendered.length === 0)
-    return "a live harness process";
-  if (rendered.length === 1)
-    return rendered[0];
-  const last = rendered.pop();
-  return `${rendered.join(", ")}, and ${last}`;
-}
-function formatFailClosedBlockingMessage(reason) {
-  if (reason.kind === "migration_guard") {
-    if (reason.unreadableFile) {
-      const arm = reason.unreadableArm ?? "io";
-      const recovery = arm === "io" ? `If no OpenCode server is running, it is safe to delete ${reason.unreadableFile} and retry.` : `The file may be a recent incomplete write; retry after the file is older than the ten-minute grace window, or stop OpenCode before deleting it.`;
-      return [
-        `Magic Context cannot migrate the shared database because RPC discovery file ${reason.unreadableFile} is uncertain (${arm} arm), so the absence of a live OpenCode server cannot be proven.`,
-        recovery,
-        `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-      ].join(" ");
-    }
-    return [
-      `Magic Context cannot migrate the shared database because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
-      "Restart the blocking process (it will pick up the new build and migrate on start), or shut it down and retry.",
-      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-    ].join(" ");
-  }
-  if (reason.kind === "schema_fence") {
-    return [
-      `Magic Context cannot operate: this Magic Context build is older than the database; upgrade/restart this harness (upstream migration lane v${reason.persistedVersion}, build supports through v${reason.supportedVersion}).`,
-      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-    ].join(" ");
-  }
-  const cause = reason.cause.trim().length > 0 ? reason.cause.trim() : "unknown storage error";
-  return [
-    `Magic Context cannot operate: persistent storage failed (${cause}).`,
-    "The plugin will not silently degrade to native compaction while enabled.",
-    `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-  ].join(" ");
-}
-function createFailClosedBlockingError(reason, options) {
-  return new FailClosedBlockingError(formatFailClosedBlockingMessage(reason), reason, options);
-}
-function isFailClosedBlockingError(error) {
-  return error instanceof FailClosedBlockingError || typeof error === "object" && error !== null && error.name === "FailClosedBlockingError" && error.code === "FAIL_CLOSED_BLOCKING";
-}
-function shouldBypassFailClosedBlock(input) {
-  if (input.isPiSubagentEnv === true)
-    return true;
-  if (input.isInternalChildSession === true)
-    return true;
-  const agent = typeof input.agent === "string" ? input.agent.trim() : "";
-  if (agent.length === 0)
-    return false;
-  if (OPENCODE_INTERNAL_AGENT_NAMES.has(agent))
-    return true;
-  if (isMagicContextHiddenAgentName(agent))
-    return true;
-  return false;
-}
-function resolveAgentNameFromMessages(messages) {
-  for (let i = messages.length - 1;i >= 0; i -= 1) {
-    const info = messages[i]?.info;
-    if (!info || typeof info !== "object")
-      continue;
-    const agent = info.agent;
-    if (typeof agent === "string" && agent.length > 0)
-      return agent;
-  }
-  return;
-}
-function createFailClosedController(options) {
-  const reprobeEveryN = Math.max(1, options?.reprobeEveryN ?? FAIL_CLOSED_REPROBE_EVERY_N);
-  let reason = null;
-  let blockedPassCount = 0;
-  return {
-    arm(next) {
-      reason = next;
-      blockedPassCount = 0;
-    },
-    clear() {
-      reason = null;
-      blockedPassCount = 0;
-    },
-    isArmed() {
-      return reason !== null;
-    },
-    getReason() {
-      return reason;
-    },
-    async enforce(input) {
-      if (!reason)
-        return;
-      if (!input.blockingEnabled)
-        return;
-      if (input.exempt)
-        return;
-      blockedPassCount += 1;
-      const shouldReprobe = typeof input.tryReopen === "function" && (blockedPassCount === 1 || blockedPassCount % reprobeEveryN === 0);
-      if (shouldReprobe) {
-        try {
-          const healed = await input.tryReopen?.();
-          if (healed) {
-            reason = null;
-            blockedPassCount = 0;
-            return;
-          }
-        } catch {}
-      }
-      const blockedReason = reason;
-      if (!blockedReason)
-        return;
-      throw createFailClosedBlockingError(blockedReason);
-    }
-  };
-}
-var lastHookInitFailure = null;
-function recordHookInitFailure(failure) {
-  lastHookInitFailure = failure;
-}
-function clearHookInitFailure() {
-  lastHookInitFailure = null;
-}
-function getLastHookInitFailure() {
-  return lastHookInitFailure;
-}
-
 // src/features/magic-context/session-project-backfill.ts
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync4 } from "node:fs";
@@ -11523,7 +11443,10 @@ var CONNECT_BACKOFF_INITIAL_MS = 1000;
 var CONNECT_BACKOFF_MAX_MS = 30000;
 var HANDSHAKE_TIMEOUT_MS = 2000;
 var MODULE_SEND_TIMEOUT_MS = 15000;
+var TRANSFORM_SEND_TIMEOUT_MS = 5000;
+var MAX_WRAPUP_REQUEST_BUDGET_MS = 3800000;
 var SERIAL_LANE_MAX_WAITERS = 16;
+var SERIAL_LANE_MAX_WAITERS_PER_SESSION = 8;
 var SERIAL_LANE_MIN_REMAINING_MS = 25;
 var CANONICAL_ROOT_CACHE_MAX_ENTRIES = 256;
 function getDefaultConnectionFile() {
@@ -11558,15 +11481,24 @@ function isConnectionFailure(error) {
   if (error instanceof SocketClosedError || error instanceof SocketTimeoutError || error instanceof StaleRouteHandleError || isConsumerReconnectTransient(error) || isStaleOrDeadRouteFailure(error)) {
     return true;
   }
-  return errorChainSome(error, (current) => [
-    "ENOENT",
-    "ECONNREFUSED",
-    "ECONNRESET",
-    "EPIPE",
-    "ETIMEDOUT",
-    "request_deadline",
-    "SUBC_CONNECTION_BACKOFF"
-  ].includes(typeof current.code === "string" ? current.code : ""));
+  return errorChainSome(error, (current) => {
+    const code = typeof current.code === "string" ? current.code : "";
+    const message = typeof current.message === "string" ? current.message : "";
+    return [
+      "ENOENT",
+      "ECONNREFUSED",
+      "ECONNRESET",
+      "EPIPE",
+      "ETIMEDOUT",
+      "request_deadline",
+      "deadline_exceeded_no_drop_observed",
+      "connection_dropped",
+      "SUBC_CONNECTION_BACKOFF"
+    ].includes(code) || /\bclient closed\b|\bconnection closed\b|\bclosed the connection\b/i.test(message);
+  });
+}
+function isModuleTransportGenerationChangedResult(value) {
+  return isRecord(value) && value.transport_status === "connection_generation_changed" && typeof value.previous_generation === "number" && typeof value.current_generation === "number";
 }
 
 class SubcModuleTransport {
@@ -11576,15 +11508,31 @@ class SubcModuleTransport {
   routeSessionPrefix;
   client = null;
   routes = new Map;
+  routeOpenings = new Map;
   canonicalRootCache = new Map;
-  activeSession = null;
+  sessionLanes = new Map;
+  queuedLaneWaiters = 0;
+  wrapupSessions = new Map;
   nextProbeMs = 0;
-  laneReleaseCallbacks = [];
+  connectionPromise = null;
   authorityProjectRoot = "";
   authorityBindRoot = "";
   backoffMs = CONNECT_BACKOFF_INITIAL_MS;
   connectionGeneration = 0;
+  stateSyncCapabilityCache = null;
+  getCachedStateSyncCapabilities() {
+    const cached = this.stateSyncCapabilityCache;
+    if (!cached || cached.generation !== this.connectionGeneration)
+      return;
+    return cached.capabilities;
+  }
+  invalidateStateSyncCapabilities() {
+    this.stateSyncCapabilityCache = null;
+  }
   async stateSyncCapabilities(args) {
+    const cached = this.getCachedStateSyncCapabilities();
+    if (cached)
+      return cached;
     const response = await this.call({
       sessionId: args.sessionId,
       projectRoot: args.projectRoot,
@@ -11594,7 +11542,9 @@ class SubcModuleTransport {
     const raw = isRecord(response) ? response : {};
     const value = isRecord(raw.result) ? raw.result : raw;
     const epochs = isRecord(value.epochs) ? value.epochs : {};
-    return { state_sync_deltas: epochs.state_sync_deltas === true };
+    const capabilities = { state_sync_deltas: epochs.state_sync_deltas === true };
+    this.stateSyncCapabilityCache = { generation: this.connectionGeneration, capabilities };
+    return capabilities;
   }
   constructor(connectionFile, moduleId = DEFAULT_MODULE_ID, requestTimeoutMs = MODULE_SEND_TIMEOUT_MS, routeSessionPrefix = "") {
     this.connectionFile = connectionFile ?? getDefaultConnectionFile();
@@ -11602,27 +11552,60 @@ class SubcModuleTransport {
     this.requestTimeoutMs = requestTimeoutMs;
     this.routeSessionPrefix = routeSessionPrefix;
   }
-  laneTimeoutError() {
-    const error = new Error("module transport deadline expired while queued");
+  deadlineError(detail) {
+    const error = new Error(`module transport deadline expired ${detail}`);
     error.code = "ETIMEDOUT";
     return error;
   }
-  laneRelease() {
+  laneTimeoutError() {
+    return this.deadlineError("while queued");
+  }
+  connectionChangedError(detail) {
+    const error = new Error(detail);
+    error.code = "ECONNRESET";
+    return error;
+  }
+  async beforeDeadline(operation, deadlineMs, detail) {
+    const remainingMs = deadlineMs - Date.now();
+    if (remainingMs <= 0)
+      throw this.deadlineError(detail);
+    let timer;
+    try {
+      return await Promise.race([
+        operation,
+        new Promise((_resolve, reject) => {
+          timer = setTimeout(() => reject(this.deadlineError(detail)), remainingMs);
+        })
+      ]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  cleanupLane(sessionId, lane) {
+    if (!lane.active && lane.waiters.length === 0 && this.sessionLanes.get(sessionId) === lane) {
+      this.sessionLanes.delete(sessionId);
+    }
+  }
+  laneRelease(sessionId, lane) {
     let released = false;
     return () => {
       if (released)
         return;
       released = true;
-      this.activeSession = null;
-      this.dispatchNextLaneWaiter();
+      lane.active = false;
+      this.dispatchNextLaneWaiter(sessionId, lane);
     };
   }
-  dispatchNextLaneWaiter() {
-    if (this.activeSession !== null)
+  dispatchNextLaneWaiter(sessionId, lane) {
+    if (lane.active)
       return;
-    while (this.laneReleaseCallbacks.length > 0) {
-      const waiter = this.laneReleaseCallbacks.shift();
-      if (!waiter || waiter.settled)
+    while (lane.waiters.length > 0) {
+      const waiter = lane.waiters.shift();
+      if (!waiter)
+        continue;
+      this.queuedLaneWaiters = Math.max(0, this.queuedLaneWaiters - 1);
+      if (waiter.settled)
         continue;
       waiter.settled = true;
       clearTimeout(waiter.timer);
@@ -11635,10 +11618,16 @@ class SubcModuleTransport {
         waiter.reject(this.laneTimeoutError());
         continue;
       }
-      this.activeSession = waiter.sessionId;
-      waiter.resolve(this.laneRelease());
+      lane.active = true;
+      waiter.resolve(this.laneRelease(sessionId, lane));
       return;
     }
+    this.cleanupLane(sessionId, lane);
+  }
+  queueFullError() {
+    const error = new Error("module transport queue is full");
+    error.code = "EBUSY";
+    return error;
   }
   acquireCorrectnessLane(sessionId, signal, deadlineMs) {
     if (signal?.aborted) {
@@ -11647,14 +11636,14 @@ class SubcModuleTransport {
     if (deadlineMs - Date.now() < SERIAL_LANE_MIN_REMAINING_MS) {
       return Promise.reject(this.laneTimeoutError());
     }
-    if (this.activeSession === null && this.laneReleaseCallbacks.length === 0) {
-      this.activeSession = sessionId;
-      return Promise.resolve(this.laneRelease());
+    const lane = this.sessionLanes.get(sessionId) ?? { active: false, waiters: [] };
+    this.sessionLanes.set(sessionId, lane);
+    if (!lane.active && lane.waiters.length === 0) {
+      lane.active = true;
+      return Promise.resolve(this.laneRelease(sessionId, lane));
     }
-    if (this.laneReleaseCallbacks.length >= SERIAL_LANE_MAX_WAITERS) {
-      const error = new Error("module transport queue is full");
-      error.code = "EBUSY";
-      return Promise.reject(error);
+    if (this.queuedLaneWaiters >= SERIAL_LANE_MAX_WAITERS || lane.waiters.length >= SERIAL_LANE_MAX_WAITERS_PER_SESSION) {
+      return Promise.reject(this.queueFullError());
     }
     return new Promise((resolve3, reject) => {
       const waiter = {};
@@ -11664,14 +11653,14 @@ class SubcModuleTransport {
         waiter.settled = true;
         clearTimeout(waiter.timer);
         signal?.removeEventListener("abort", waiter.onAbort);
-        const index = this.laneReleaseCallbacks.indexOf(waiter);
-        if (index >= 0)
-          this.laneReleaseCallbacks.splice(index, 1);
+        const index = lane.waiters.indexOf(waiter);
+        if (index >= 0) {
+          lane.waiters.splice(index, 1);
+          this.queuedLaneWaiters = Math.max(0, this.queuedLaneWaiters - 1);
+        }
         reject(error);
-        if (this.activeSession === null)
-          this.dispatchNextLaneWaiter();
+        this.cleanupLane(sessionId, lane);
       };
-      waiter.sessionId = sessionId;
       waiter.signal = signal;
       waiter.deadlineMs = deadlineMs;
       waiter.resolve = resolve3;
@@ -11680,46 +11669,78 @@ class SubcModuleTransport {
       waiter.onAbort = () => removeAndReject(signal?.reason ?? new Error("module transport call aborted"));
       waiter.timer = setTimeout(() => removeAndReject(this.laneTimeoutError()), Math.max(0, deadlineMs - Date.now()));
       signal?.addEventListener("abort", waiter.onAbort, { once: true });
-      this.laneReleaseCallbacks.push(waiter);
+      lane.waiters.push(waiter);
+      this.queuedLaneWaiters += 1;
     });
   }
   async call(args) {
-    const deadlineMs = Date.now() + (args.timeoutMs ?? this.requestTimeoutMs);
-    const releaseLane = await this.acquireCorrectnessLane(args.sessionId, args.signal, deadlineMs);
-    const onAbort = () => this.invalidateConnection();
+    const wrapupInFlight = (this.wrapupSessions.get(args.sessionId) ?? 0) > 0;
+    const attemptTimeoutMs = args.timeoutMs ?? (args.method === "session.wrapup" || args.method === "session.status" && wrapupInFlight ? MAX_WRAPUP_REQUEST_BUDGET_MS : args.method === "transform" ? Math.min(this.requestTimeoutMs, TRANSFORM_SEND_TIMEOUT_MS) : this.requestTimeoutMs);
+    const tracksWrapup = args.method === "session.wrapup";
+    if (tracksWrapup) {
+      this.wrapupSessions.set(args.sessionId, (this.wrapupSessions.get(args.sessionId) ?? 0) + 1);
+    }
+    const finishWrapupTracking = () => {
+      if (!tracksWrapup)
+        return;
+      const remaining = (this.wrapupSessions.get(args.sessionId) ?? 1) - 1;
+      if (remaining > 0)
+        this.wrapupSessions.set(args.sessionId, remaining);
+      else
+        this.wrapupSessions.delete(args.sessionId);
+    };
+    const laneDeadlineMs = Date.now() + attemptTimeoutMs;
+    let releaseLane;
+    try {
+      releaseLane = await this.acquireCorrectnessLane(args.sessionId, args.signal, laneDeadlineMs);
+    } catch (error) {
+      finishWrapupTracking();
+      throw error;
+    }
+    let activeAttemptClient = null;
+    const onAbort = () => this.invalidateConnection(activeAttemptClient ?? this.client);
     args.signal?.addEventListener("abort", onAbort, { once: true });
     try {
       for (let attempt = 0;attempt < 2; attempt += 1) {
+        activeAttemptClient = null;
         let ensuredRoute = null;
         try {
           if (args.signal?.aborted) {
             throw args.signal.reason ?? new Error("module transport call aborted");
           }
-          const remainingMs = deadlineMs - Date.now();
-          if (remainingMs < SERIAL_LANE_MIN_REMAINING_MS)
-            throw this.laneTimeoutError();
-          ensuredRoute = await this.ensureRoute(args.sessionId, args.projectRoot);
+          const attemptDeadlineMs = Date.now() + attemptTimeoutMs;
+          ensuredRoute = await this.ensureRoute(args.sessionId, args.projectRoot, attemptDeadlineMs);
+          activeAttemptClient = ensuredRoute.client;
           if (args.signal?.aborted) {
             throw args.signal.reason ?? new Error("module transport call aborted");
           }
-          return await ensuredRoute.client.request(ensuredRoute.route, args.body, {
+          const response = await this.beforeDeadline(ensuredRoute.client.request(ensuredRoute.route, args.body, {
             priority: Priority.Background,
             admissionClass: AdmissionClass.Normal,
-            timeoutMs: Math.max(1, deadlineMs - Date.now())
-          });
+            timeoutMs: Math.max(1, attemptDeadlineMs - Date.now())
+          }), attemptDeadlineMs, "waiting for the module response");
+          if (this.client !== ensuredRoute.client || this.connectionGeneration !== ensuredRoute.generation) {
+            throw this.connectionChangedError("subc connection changed while awaiting the module response");
+          }
+          return response;
         } catch (error) {
-          const staleOrDeadRoute = isStaleOrDeadRouteFailure(error);
-          if (staleOrDeadRoute) {
+          if (isConnectionFailure(error)) {
+            const previousGeneration = ensuredRoute?.generation ?? this.connectionGeneration;
             if (ensuredRoute) {
               this.dropRoute(ensuredRoute.routeKey, ensuredRoute.route);
               this.invalidateConnection(ensuredRoute.client);
             } else {
               this.invalidateConnection();
             }
+            if (args.generationSensitive && !args.signal?.aborted) {
+              return {
+                transport_status: "connection_generation_changed",
+                previous_generation: previousGeneration,
+                current_generation: this.connectionGeneration
+              };
+            }
             if (attempt === 0 && !args.signal?.aborted)
               continue;
-          } else if (isConnectionFailure(error)) {
-            this.invalidateConnection(ensuredRoute?.client);
           }
           throw error;
         }
@@ -11727,6 +11748,7 @@ class SubcModuleTransport {
       throw new Error("module transport route retry exhausted");
     } finally {
       args.signal?.removeEventListener("abort", onAbort);
+      finishWrapupTracking();
       releaseLane();
     }
   }
@@ -11817,11 +11839,11 @@ class SubcModuleTransport {
         });
       }
     }
-    if (routes.length === 0 && this.activeSession === sessionId) {
+    if (routes.length === 0 && this.sessionLanes.get(sessionId)?.active) {
       this.invalidateConnection(client);
     }
   }
-  async ensureRoute(sessionId, rawProjectRoot) {
+  async ensureRoute(sessionId, rawProjectRoot, deadlineMs = Date.now() + this.requestTimeoutMs) {
     const projectRoot = this.canonicalRoot(rawProjectRoot);
     const routeKey = `${sessionId}\x00${projectRoot}`;
     const client = await this.ensureConnected();
@@ -11832,23 +11854,36 @@ class SubcModuleTransport {
     }
     if (existing)
       this.routes.delete(routeKey);
-    const target = { kind: "tool_provider", module_id: this.moduleId };
-    const identity = {
-      project_root: projectRoot,
-      harness: getHarness(),
-      session: `${this.routeSessionPrefix}${sessionId}`
-    };
-    const route = await client.routeOpen(target, identity);
-    if (this.client !== client || generation !== this.connectionGeneration) {
-      await client.closeRoute(route).catch(() => {
-        return;
-      });
-      const error = new Error("subc connection changed while opening module route");
-      error.code = "ECONNRESET";
-      throw error;
+    const opening = this.routeOpenings.get(routeKey);
+    if (opening?.client === client && opening.generation === generation) {
+      return await opening.promise;
+    }
+    const promise = (async () => {
+      const target = { kind: "tool_provider", module_id: this.moduleId };
+      const identity = {
+        project_root: projectRoot,
+        harness: getHarness(),
+        session: `${this.routeSessionPrefix}${sessionId}`
+      };
+      const route = await this.beforeDeadline(client.routeOpen(target, identity), deadlineMs, "opening the module route");
+      if (this.client !== client || generation !== this.connectionGeneration) {
+        await client.closeRoute(route).catch(() => {
+          return;
+        });
+        throw this.connectionChangedError("subc connection changed while opening module route");
+      }
+      this.routes.set(routeKey, { route, generation });
+      return { client, route, routeKey, generation };
+    })();
+    const routeOpening = { client, generation, promise };
+    this.routeOpenings.set(routeKey, routeOpening);
+    try {
+      return await promise;
+    } finally {
+      if (this.routeOpenings.get(routeKey) === routeOpening) {
+        this.routeOpenings.delete(routeKey);
+      }
     }
-    this.routes.set(routeKey, { route, generation });
-    return { client, route, routeKey, generation };
   }
   dropRoute(routeKey, route) {
     const existing = this.routes.get(routeKey);
@@ -11876,9 +11911,17 @@ class SubcModuleTransport {
     }
     return resolved;
   }
+  connectClient() {
+    return SubcClient.connect({
+      connectionFile: this.connectionFile,
+      handshakeTimeoutMs: HANDSHAKE_TIMEOUT_MS
+    });
+  }
   async ensureConnected() {
     if (this.client)
       return this.client;
+    if (this.connectionPromise)
+      return await this.connectionPromise;
     const now = Date.now();
     if (now < this.nextProbeMs) {
       const error = new Error(`subc connection backoff active until ${this.nextProbeMs}`);
@@ -11886,37 +11929,44 @@ class SubcModuleTransport {
       throw error;
     }
     const generation = this.connectionGeneration;
-    let candidate = null;
-    try {
-      candidate = await SubcClient.connect({
-        connectionFile: this.connectionFile,
-        handshakeTimeoutMs: HANDSHAKE_TIMEOUT_MS
-      });
-      if (generation !== this.connectionGeneration) {
-        candidate.close();
-        const error = new Error("subc connection attempt was superseded");
-        error.code = "ECONNRESET";
+    const connecting = (async () => {
+      let candidate = null;
+      try {
+        candidate = await this.connectClient();
+        if (generation !== this.connectionGeneration) {
+          candidate.close();
+          throw this.connectionChangedError("subc connection attempt was superseded");
+        }
+        this.client = candidate;
+        this.routes.clear();
+        this.backoffMs = CONNECT_BACKOFF_INITIAL_MS;
+        this.nextProbeMs = 0;
+        return candidate;
+      } catch (error) {
+        candidate?.close();
+        if (generation === this.connectionGeneration)
+          this.invalidateConnection();
+        this.nextProbeMs = Date.now() + this.backoffMs;
+        this.backoffMs = Math.min(this.backoffMs * 2, CONNECT_BACKOFF_MAX_MS);
         throw error;
       }
-      this.client = candidate;
-      this.routes.clear();
-      this.backoffMs = CONNECT_BACKOFF_INITIAL_MS;
-      this.nextProbeMs = 0;
-      return candidate;
-    } catch (error) {
-      candidate?.close();
-      this.invalidateConnection();
-      this.nextProbeMs = Date.now() + this.backoffMs;
-      this.backoffMs = Math.min(this.backoffMs * 2, CONNECT_BACKOFF_MAX_MS);
-      throw error;
+    })();
+    this.connectionPromise = connecting;
+    try {
+      return await connecting;
+    } finally {
+      if (this.connectionPromise === connecting)
+        this.connectionPromise = null;
     }
   }
   invalidateConnection(client = this.client) {
-    if (client && this.client && client !== this.client)
+    if (client && this.client !== client)
       return;
     this.connectionGeneration += 1;
+    this.invalidateStateSyncCapabilities();
     this.client = null;
     this.routes.clear();
+    this.routeOpenings.clear();
     client?.close();
   }
 }
@@ -11971,13 +12021,15 @@ function rowKeys(leaseKey) {
     return {
       holder: "dreaming_lease_holder",
       heartbeat: "dreaming_lease_heartbeat",
-      expiry: "dreaming_lease_expiry"
+      expiry: "dreaming_lease_expiry",
+      generation: "dreaming_lease_generation"
     };
   }
   return {
     holder: `lease:${leaseKey}:holder`,
     heartbeat: `lease:${leaseKey}:heartbeat`,
-    expiry: `lease:${leaseKey}:expiry`
+    expiry: `lease:${leaseKey}:expiry`,
+    generation: `lease:${leaseKey}:generation`
   };
 }
 function getLeaseExpiry(db, keys) {
@@ -11995,6 +12047,13 @@ function isLeaseActive(db, leaseKey = DREAMING_LEASE_KEY) {
 function getLeaseHolder(db, leaseKey = DREAMING_LEASE_KEY) {
   return getDreamState(db, rowKeys(leaseKey).holder);
 }
+function getLeaseGeneration(db, leaseKey = DREAMING_LEASE_KEY) {
+  const value = getDreamState(db, rowKeys(leaseKey).generation);
+  if (!value)
+    return null;
+  const generation = Number(value);
+  return Number.isSafeInteger(generation) && generation > 0 ? generation : null;
+}
 function peekLeaseHolderAndExpiry(db, expectedHolder, leaseKey = DREAMING_LEASE_KEY) {
   const keys = rowKeys(leaseKey);
   const holder = getDreamState(db, keys.holder);
@@ -12006,6 +12065,9 @@ function peekLeaseHolderAndExpiry(db, expectedHolder, leaseKey = DREAMING_LEASE_
   const expiry = Number(expiryStr);
   return Number.isFinite(expiry) && expiry >= Date.now();
 }
+function leaseOwnershipMatches(db, expectedHolder, expectedGeneration, leaseKey = DREAMING_LEASE_KEY) {
+  return getLeaseGeneration(db, leaseKey) === expectedGeneration && peekLeaseHolderAndExpiry(db, expectedHolder, leaseKey);
+}
 function runImmediate(db, body) {
   db.exec("BEGIN IMMEDIATE");
   let committed = false;
@@ -12022,26 +12084,30 @@ function runImmediate(db, body) {
     }
   }
 }
-function acquireLease(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
+function acquireLeaseWithAcquisition(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
   const keys = rowKeys(leaseKey);
   return runImmediate(db, () => {
-    if (isLeaseActive(db, leaseKey)) {
-      const existingHolder = getLeaseHolder(db, leaseKey);
-      if (existingHolder && existingHolder !== holderId) {
-        return false;
-      }
+    const existingHolder = getLeaseHolder(db, leaseKey);
+    if (isLeaseActive(db, leaseKey) && existingHolder && existingHolder !== holderId) {
+      return null;
     }
     const now = Date.now();
+    const priorGeneration = getLeaseGeneration(db, leaseKey) ?? 0;
+    const generation = existingHolder === holderId ? Math.max(1, priorGeneration) : priorGeneration + 1;
     setDreamState(db, keys.holder, holderId);
     setDreamState(db, keys.heartbeat, String(now));
     setDreamState(db, keys.expiry, String(now + LEASE_DURATION_MS));
-    return true;
+    setDreamState(db, keys.generation, String(generation));
+    return { acquiredAt: now, generation };
   });
 }
-function renewLease(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
+function acquireLease(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
+  return acquireLeaseWithAcquisition(db, holderId, leaseKey) !== null;
+}
+function renewLease(db, holderId, leaseKey = DREAMING_LEASE_KEY, expectedGeneration) {
   const keys = rowKeys(leaseKey);
   return runImmediate(db, () => {
-    if (getLeaseHolder(db, leaseKey) !== holderId || !isLeaseActive(db, leaseKey)) {
+    if (getLeaseHolder(db, leaseKey) !== holderId || !isLeaseActive(db, leaseKey) || expectedGeneration !== undefined && getLeaseGeneration(db, leaseKey) !== expectedGeneration) {
       return false;
     }
     const now = Date.now();
@@ -12059,9 +12125,12 @@ function runLeaseGuardedWrite(db, holderId, leaseKey, fn) {
   });
 }
 var LEASE_HEARTBEAT_INTERVAL_MS = 60 * 1000;
-function startLeaseHeartbeat(db, holderId, leaseKey, onLost, intervalMs = LEASE_HEARTBEAT_INTERVAL_MS) {
+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 lastConfirmedAt = Date.now();
+  let expectedGeneration = acquisition?.generation ?? getLeaseGeneration(db, leaseKey);
+  let lastConfirmedAt = acquisition?.acquiredAt ?? Date.now();
   const declareLost = (reason) => {
     if (lost)
       return;
@@ -12072,15 +12141,25 @@ function startLeaseHeartbeat(db, holderId, leaseKey, onLost, intervalMs = LEASE_
     if (lost)
       return;
     try {
-      if (renewLease(db, holderId, leaseKey)) {
+      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;
       }
-      if (acquireLease(db, holderId, leaseKey)) {
+      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();
         return;
       }
@@ -12587,7 +12666,7 @@ var DREAMER_DOCS_AGENT = "dreamer-docs";
 var DREAMER_REVIEWER_AGENT = "dreamer-reviewer";
 
 // src/features/magic-context/mural/compress-cues.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // src/features/magic-context/dreamer/manifest-parser.ts
 function extractCompleteManifestBody(text, rootName) {
@@ -12623,6 +12702,16 @@ function assertManifestCoversExactly(ids, expectedIds, rootName) {
 }
 
 // src/features/magic-context/dreamer/module-apply.ts
+class DreamerModuleBusyError extends Error {
+  state;
+  transient = true;
+  constructor(state) {
+    super(`Rust memory authority is ${state}; dreamer mutation deferred until authority settles.`);
+    this.state = state;
+    this.name = "DreamerModuleBusyError";
+  }
+}
+
 class DreamerModuleFailureError extends Error {
   transient = true;
   constructor(operation, cause) {
@@ -12644,9 +12733,12 @@ async function resolveDreamerModuleRoute(args) {
     projectRoot: args.projectRoot,
     domain: "memories"
   });
-  if (result.authority?.state !== "MODULE")
+  const authority = result.authority;
+  if (authority?.state === "DRAINING")
+    throw new DreamerModuleBusyError(authority.state);
+  if (authority?.state !== "MODULE")
     return;
-  const generation = result.authority.generation;
+  const generation = authority.generation;
   if (typeof generation !== "number")
     throw new Error("Rust authority status omitted generation");
   return {
@@ -12680,6 +12772,68 @@ function getModuleMemoryIdentities(db, projectIdentity, contextIds) {
   ] : []));
 }
 
+// src/features/magic-context/dreamer/provider-output-failure.ts
+import { createHash as createHash2 } from "node:crypto";
+var MAX_NEAR_ZERO_OUTPUT_TOKENS = 32;
+
+class DreamerProviderOutputFailureError extends Error {
+  fingerprint;
+  outputTokens;
+  reasoningTokens;
+  transient = true;
+  constructor(fingerprint, outputTokens, reasoningTokens, responseText) {
+    const preview = responseText.trim().replace(/\s+/g, " ").slice(0, 160);
+    super(`dreamer provider-outage completion (output_tokens=${outputTokens}, reasoning_tokens=${reasoningTokens}): ${JSON.stringify(preview)}`);
+    this.fingerprint = fingerprint;
+    this.outputTokens = outputTokens;
+    this.reasoningTokens = reasoningTokens;
+    this.name = "DreamerProviderOutputFailureError";
+  }
+}
+function finiteTokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function completionShape(value) {
+  if (!isRecord(value))
+    return null;
+  const info = isRecord(value.info) ? value.info : value;
+  if (info.role !== "assistant")
+    return null;
+  const time = isRecord(info.time) ? info.time : null;
+  const tokens = isRecord(info.tokens) ? info.tokens : null;
+  return {
+    createdAt: typeof time?.created === "number" ? time.created : 0,
+    finish: typeof info.finish === "string" ? info.finish : typeof info.finish_reason === "string" ? info.finish_reason : typeof info.finishReason === "string" ? info.finishReason : null,
+    error: info.error,
+    outputTokens: finiteTokenCount(tokens?.output),
+    reasoningTokens: finiteTokenCount(tokens?.reasoning)
+  };
+}
+function latestAssistantCompletion(messages) {
+  if (!Array.isArray(messages))
+    return null;
+  let latest = null;
+  for (const message of messages) {
+    const completion = completionShape(message);
+    if (completion && (!latest || completion.createdAt >= latest.createdAt))
+      latest = completion;
+  }
+  return latest;
+}
+function providerOutputFailureFromInvalidManifest(messages, responseText) {
+  const completion = latestAssistantCompletion(messages);
+  if (completion?.finish?.toLowerCase() !== "stop")
+    return null;
+  if (completion.error != null || completion.outputTokens === null || completion.outputTokens > MAX_NEAR_ZERO_OUTPUT_TOKENS || completion.reasoningTokens !== 0) {
+    return null;
+  }
+  const normalized = responseText.trim().replace(/\s+/g, " ").toLowerCase();
+  if (!normalized)
+    return null;
+  const fingerprint = createHash2("sha256").update(normalized).digest("hex").slice(0, 16);
+  return new DreamerProviderOutputFailureError(fingerprint, completion.outputTokens, completion.reasoningTokens, responseText);
+}
+
 // src/features/magic-context/mural/compress-cues-prompt.ts
 var CUE_BUDGET_HIGH = 90;
 var CUE_BUDGET_LOW = 50;
@@ -12852,7 +13006,7 @@ async function runCompressCues(args) {
     chunks.push(candidates.slice(i, i + COMPRESS_CUES_CHUNK_SIZE));
   }
   const abortController = new AbortController;
-  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort());
+  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort(), args.leaseAcquisition);
   try {
     let consecutiveTimeouts = 0;
     let timeoutStreakElapsedMs = [];
@@ -12947,7 +13101,14 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
         const text = extractLatestAssistantText(messages);
         if (!text)
           throw new Error("compress-cues returned no output");
-        parseCuesManifest(text);
+        try {
+          parseCuesManifest(text);
+        } catch (error) {
+          const providerFailure = providerOutputFailureFromInvalidManifest(messages, text);
+          if (providerFailure)
+            throw providerFailure;
+          throw error;
+        }
         return text;
       }
     });
@@ -12955,7 +13116,7 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
   } catch (error) {
     const desc = describeError(error);
     log(`[dreamer] compress-cues chunk failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
-    if (signal.aborted)
+    if (signal.aborted || error instanceof DreamerProviderOutputFailureError)
       throw error;
     return {
       compressed: 0,
@@ -13063,7 +13224,7 @@ async function applyCuesThroughModule(args, chunk, manifestText, signal) {
       log(`[dreamer] compress-cues: skipped cue for memory ${entry.id} (${failure.reason}; rejection ${rejectionCount}/${CUE_REJECTION_LATCH_THRESHOLD})`);
     }
   }
-  const commandId = `mural-cues:${route.moduleCommandId}:${createHash2("sha256").update(chunk.map((candidate) => candidate.memory.id).join(",")).digest("hex").slice(0, 24)}`;
+  const commandId = `mural-cues:${route.moduleCommandId}:${createHash3("sha256").update(chunk.map((candidate) => candidate.memory.id).join(",")).digest("hex").slice(0, 24)}`;
   let response;
   try {
     response = await route.moduleClient.call({
@@ -13200,7 +13361,7 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
   const heartbeat = startLeaseHeartbeat(args.db, args.holderId, leaseKey, (reason) => {
     log(`[dreamer] user-memories: lease lost (${reason}) — aborting`);
     abortController.abort();
-  });
+  }, args.leaseAcquisition);
   try {
     const createResponse = await createChildSessionWithFence({
       client: args.client,
@@ -13323,7 +13484,7 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
 }
 
 // src/features/magic-context/dreamer/classify.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 
 // src/plugin/rust-tool-backends.ts
 function toolCallIdFromContext(context) {
@@ -13725,7 +13886,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());
+  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort(), args.leaseAcquisition);
   try {
     for (let i = 0;i < chunks.length; i += 1) {
       const remainingMs = Math.max(0, args.deadline - Date.now());
@@ -13805,7 +13966,14 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
         const text = extractLatestAssistantText(messages);
         if (!text)
           throw new Error("classify returned no output");
-        parseClassifyManifest(text);
+        try {
+          parseClassifyManifest(text);
+        } catch (error) {
+          const providerFailure = providerOutputFailureFromInvalidManifest(messages, text);
+          if (providerFailure)
+            throw providerFailure;
+          throw error;
+        }
         return text;
       }
     });
@@ -13816,7 +13984,7 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
     const desc = describeError(failure);
     log(`[dreamer] classify chunk failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
     recordInvocation(args, startedAt, { status: "failed", error: failure });
-    if (moduleRoute || signal.aborted)
+    if (moduleRoute || signal.aborted || failure instanceof DreamerProviderOutputFailureError)
       throw failure;
     return { classified: 0, changed: 0 };
   } finally {
@@ -13845,7 +14013,7 @@ async function runClassifyThroughModule(args, chunk, anchors, signal) {
       v: 1,
       session_id: args.moduleSessionId,
       task: "classify",
-      command_id: `classify:${args.moduleCommandId ?? Date.now()}:${createHash3("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`,
+      command_id: `classify:${args.moduleCommandId ?? Date.now()}:${createHash4("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`,
       authority_generation: args.moduleAuthorityGeneration,
       payload: {
         prompt_body: prompt,
@@ -14541,7 +14709,7 @@ function throwIfAborted2(signal) {
 }
 
 // src/features/magic-context/smart-notes/compiler.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 
 // src/features/magic-context/smart-notes/sandbox-runner.ts
 var asyncModulePromise = null;
@@ -14935,7 +15103,7 @@ function manifestAdvisoryWarnings(code, manifest) {
   return warnings;
 }
 function hashCheck(surfaceCondition, compiledCheck, manifest, checkCron) {
-  return createHash4("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
+  return createHash5("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
 }
 function extractJsonObject(output) {
   const fenced = output.match(/```(?:json)?\s*([\s\S]*?)```/i);
@@ -15068,16 +15236,16 @@ function claimExpectedState(db, expected) {
                  WHERE id = ? AND type = 'smart' AND status = 'pending'
                    AND content = ? AND surface_condition IS ? AND updated_at = ?${statusClause}`).run(...params).changes > 0;
 }
-function getDueCompiledSmartNoteChecks(db, projectPath, now, limit) {
-  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && (note.checkQuarantinedUntil === null || note.checkQuarantinedUntil <= now) && (note.checkNextDueAt === null || note.checkNextDueAt <= now)).sort((a, b) => (a.checkNextDueAt ?? 0) - (b.checkNextDueAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
+function getDueCompiledSmartNoteChecks(db, projectPath, now, limit, retinaHandoff = false) {
+  return getPendingSmartNotes(db, projectPath).filter((note) => !retinaHandoff || note.compileStatus !== "compiled").map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && (note.checkQuarantinedUntil === null || note.checkQuarantinedUntil <= now) && (note.checkNextDueAt === null || note.checkNextDueAt <= now)).sort((a, b) => (a.checkNextDueAt ?? 0) - (b.checkNextDueAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
 }
-function getSmartNotesNeedingCompilation(db, projectPath, now, limit) {
-  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => (note.checkNextDueAt === null || note.checkNextDueAt <= now) && (note.checkStatus === "uncompiled" || note.checkStatus === "failing" || note.compiledCheck === null || note.policyVersion !== SMART_NOTE_CHECK_POLICY_VERSION)).sort((a, b) => a.createdAt - b.createdAt || a.id - b.id).slice(0, Math.max(1, limit));
+function getSmartNotesNeedingCompilation(db, projectPath, now, limit, retinaHandoff = false) {
+  return getPendingSmartNotes(db, projectPath).filter((note) => !retinaHandoff || note.compileStatus !== "compiled").map(toSmartNote).filter((note) => (note.checkNextDueAt === null || note.checkNextDueAt <= now) && (note.checkStatus === "uncompiled" || note.checkStatus === "failing" || note.compiledCheck === null || note.policyVersion !== SMART_NOTE_CHECK_POLICY_VERSION)).sort((a, b) => a.createdAt - b.createdAt || a.id - b.id).slice(0, Math.max(1, limit));
 }
-function getStaleCompiledSmartNotes(db, projectPath, now, limit) {
+function getStaleCompiledSmartNotes(db, projectPath, now, limit, retinaHandoff = false) {
   const staleBefore = now - SMART_NOTE_CHECK_MAX_STALENESS_MS;
   const livenessBefore = now - SMART_NOTE_CHECK_LIVENESS_RECHECK_MS;
-  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && note.checkFalseSinceAt !== null && note.checkFalseSinceAt <= staleBefore && (note.checkLastLivenessAt === null || note.checkLastLivenessAt <= livenessBefore)).sort((a, b) => (a.checkFalseSinceAt ?? 0) - (b.checkFalseSinceAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
+  return getPendingSmartNotes(db, projectPath).filter((note) => !retinaHandoff || note.compileStatus !== "compiled").map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && note.checkFalseSinceAt !== null && note.checkFalseSinceAt <= staleBefore && (note.checkLastLivenessAt === null || note.checkLastLivenessAt <= livenessBefore)).sort((a, b) => (a.checkFalseSinceAt ?? 0) - (b.checkFalseSinceAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
 }
 function storeCompiledSmartNoteCheck(db, args) {
   db.prepare(`UPDATE notes
@@ -15173,7 +15341,7 @@ var MAX_FAILURES_BEFORE_REAUTHOR = 3;
 async function runDueCompiledSmartNoteChecks(args) {
   const startedAt = Date.now();
   const now = args.now ?? startedAt;
-  const due = getDueCompiledSmartNoteChecks(args.db, args.projectIdentity, now, args.maxChecks ?? DEFAULT_MAX_CHECKS);
+  const due = getDueCompiledSmartNoteChecks(args.db, args.projectIdentity, now, args.maxChecks ?? DEFAULT_MAX_CHECKS, args.retinaHandoff);
   let ran = 0;
   let surfaced = 0;
   let failed = 0;
@@ -15303,7 +15471,8 @@ async function evaluateSmartNotes(args) {
   const projectRoot = args.sessionDirectory ?? args.projectIdentity;
   const moduleBridge = getModuleNoteEvaluationBridge(args.projectIdentity);
   await moduleBridge?.sync();
-  const pendingAtStart = getPendingSmartNotes(args.db, args.projectIdentity).length;
+  const pendingNotes = () => getPendingSmartNotes(args.db, args.projectIdentity).filter((note) => !args.retinaHandoff || note.compileStatus !== "compiled");
+  const pendingAtStart = pendingNotes().length;
   if (pendingAtStart === 0) {
     log("[dreamer] smart notes: no pending notes");
     return { surfaced: 0, pending: 0, ran: false };
@@ -15322,12 +15491,12 @@ async function evaluateSmartNotes(args) {
     leaseAbortController.abort(new Error("Dream lease lost during smart notes"));
     log("[dreamer] smart notes: lease lost — aborting");
     args.onLeaseLost?.("smart notes");
-  });
+  }, args.leaseAcquisition);
   let surfaced = 0;
   let didWork = false;
   try {
     if (moduleBridge) {
-      const candidates2 = getPendingSmartNotes(args.db, args.projectIdentity).slice(0, MAX_COMPILE_PER_RUN);
+      const candidates2 = pendingNotes().slice(0, MAX_COMPILE_PER_RUN);
       for (const note of candidates2) {
         if (Date.now() >= args.deadline)
           break;
@@ -15348,7 +15517,7 @@ async function evaluateSmartNotes(args) {
           surfaced += 1;
       }
       await moduleBridge.sync();
-      const pending2 = getPendingSmartNotes(args.db, args.projectIdentity).length;
+      const pending2 = pendingNotes().length;
       return { surfaced, pending: pending2, ran: didWork };
     }
     const dueRun = await runDueCompiledSmartNoteChecks({
@@ -15358,11 +15527,12 @@ async function evaluateSmartNotes(args) {
       maxChecks: 10,
       sweepBudgetMs: 1e4,
       leaseHeld,
-      signal: leaseAbortController.signal
+      signal: leaseAbortController.signal,
+      retinaHandoff: args.retinaHandoff
     });
     surfaced += dueRun.surfaced;
     didWork ||= dueRun.ran > 0;
-    const candidates = getSmartNotesNeedingCompilation(args.db, args.projectIdentity, Date.now(), MAX_COMPILE_PER_RUN);
+    const candidates = getSmartNotesNeedingCompilation(args.db, args.projectIdentity, Date.now(), MAX_COMPILE_PER_RUN, args.retinaHandoff);
     for (const note of candidates) {
       if (Date.now() >= args.deadline)
         break;
@@ -15372,7 +15542,7 @@ async function evaluateSmartNotes(args) {
       if (compiled)
         surfaced += 1;
     }
-    const stale = getStaleCompiledSmartNotes(args.db, args.projectIdentity, Date.now(), MAX_FALLBACK_PER_RUN);
+    const stale = getStaleCompiledSmartNotes(args.db, args.projectIdentity, Date.now(), MAX_FALLBACK_PER_RUN, args.retinaHandoff);
     for (const note of stale) {
       if (Date.now() >= args.deadline)
         break;
@@ -15382,7 +15552,7 @@ async function evaluateSmartNotes(args) {
       if (met)
         surfaced += 1;
     }
-    const fallbackNotes = getPendingSmartNotes(args.db, args.projectIdentity).filter((note) => note.checkStatus === "fallback").slice(0, MAX_FALLBACK_PER_RUN);
+    const fallbackNotes = pendingNotes().filter((note) => note.checkStatus === "fallback").slice(0, MAX_FALLBACK_PER_RUN);
     for (const note of fallbackNotes) {
       if (Date.now() >= args.deadline)
         break;
@@ -15762,7 +15932,7 @@ function enforceMaintainDocsProtectedRegions(args) {
 }
 
 // src/features/magic-context/dreamer/map-memories.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 
 // src/features/magic-context/dreamer/map-memories-prompt.ts
 import { existsSync as existsSync8, statSync as statSync2 } from "node:fs";
@@ -15879,7 +16049,7 @@ async function mapMemories(args) {
   }
   result.remaining = inputs.length;
   const abortController = new AbortController;
-  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort());
+  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort(), args.leaseAcquisition);
   try {
     for (let i = 0;i < batches.length; i += 1) {
       const remainingMs = Math.max(0, args.deadline - Date.now());
@@ -16023,7 +16193,7 @@ async function applyBatchMappings(args, batch, manifestText) {
             memory_project: args.projectIdentity,
             context_store_uuid: args.moduleRoute.moduleContextStoreUuid,
             authority_generation: args.moduleRoute.moduleAuthorityGeneration,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash5("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash6("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -16248,7 +16418,7 @@ async function promotePrimers(args) {
   const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => {
     leaseLost = true;
     log("[dreamer] primers: lease lost during promote-primers — aborting");
-  });
+  }, args.leaseAcquisition);
   try {
     assertLeaseHeld("prune start");
     result.pruned = pruneExpiredPrimerCandidatesForProject(args.db, args.projectIdentity, Date.now(), PRIMER_CANDIDATE_TTL_MS);
@@ -16480,7 +16650,7 @@ async function refreshPrimers(args) {
   if (primers.length === 0)
     return result;
   const abortController = new AbortController;
-  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort());
+  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort(), args.leaseAcquisition);
   try {
     for (let i = 0;i < primers.length; i += 1) {
       const primer = primers[i];
@@ -16967,68 +17137,6 @@ function evaluateTaskGate(task, ctx) {
 // src/features/magic-context/dreamer/verify.ts
 import { createHash as createHash7 } from "node:crypto";
 
-// src/features/magic-context/dreamer/provider-output-failure.ts
-import { createHash as createHash6 } from "node:crypto";
-var MAX_NEAR_ZERO_OUTPUT_TOKENS = 32;
-
-class DreamerProviderOutputFailureError extends Error {
-  fingerprint;
-  outputTokens;
-  reasoningTokens;
-  transient = true;
-  constructor(fingerprint, outputTokens, reasoningTokens, responseText) {
-    const preview = responseText.trim().replace(/\s+/g, " ").slice(0, 160);
-    super(`verify provider-outage completion (output_tokens=${outputTokens}, reasoning_tokens=${reasoningTokens}): ${JSON.stringify(preview)}`);
-    this.fingerprint = fingerprint;
-    this.outputTokens = outputTokens;
-    this.reasoningTokens = reasoningTokens;
-    this.name = "DreamerProviderOutputFailureError";
-  }
-}
-function finiteTokenCount(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
-}
-function completionShape(value) {
-  if (!isRecord(value))
-    return null;
-  const info = isRecord(value.info) ? value.info : value;
-  if (info.role !== "assistant")
-    return null;
-  const time = isRecord(info.time) ? info.time : null;
-  const tokens = isRecord(info.tokens) ? info.tokens : null;
-  return {
-    createdAt: typeof time?.created === "number" ? time.created : 0,
-    finish: typeof info.finish === "string" ? info.finish : typeof info.finish_reason === "string" ? info.finish_reason : typeof info.finishReason === "string" ? info.finishReason : null,
-    error: info.error,
-    outputTokens: finiteTokenCount(tokens?.output),
-    reasoningTokens: finiteTokenCount(tokens?.reasoning)
-  };
-}
-function latestAssistantCompletion(messages) {
-  if (!Array.isArray(messages))
-    return null;
-  let latest = null;
-  for (const message of messages) {
-    const completion = completionShape(message);
-    if (completion && (!latest || completion.createdAt >= latest.createdAt))
-      latest = completion;
-  }
-  return latest;
-}
-function providerOutputFailureFromInvalidManifest(messages, responseText) {
-  const completion = latestAssistantCompletion(messages);
-  if (completion?.finish?.toLowerCase() !== "stop")
-    return null;
-  if (completion.error != null || completion.outputTokens === null || completion.outputTokens > MAX_NEAR_ZERO_OUTPUT_TOKENS || completion.reasoningTokens !== 0) {
-    return null;
-  }
-  const normalized = responseText.trim().replace(/\s+/g, " ").toLowerCase();
-  if (!normalized)
-    return null;
-  const fingerprint = createHash6("sha256").update(normalized).digest("hex").slice(0, 16);
-  return new DreamerProviderOutputFailureError(fingerprint, completion.outputTokens, completion.reasoningTokens, responseText);
-}
-
 // src/features/magic-context/dreamer/verify-gate.ts
 import path4 from "node:path";
 function minOf(values) {
@@ -17273,7 +17381,7 @@ 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());
+  const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort(), args.leaseAcquisition);
   let consecutiveProviderFailures = 0;
   let priorProviderFailureFingerprint = null;
   let lastProviderFailure = null;
@@ -17609,6 +17717,9 @@ function createDreamTaskExecutor(deps) {
   return async (config, ctx) => {
     const { db, projectIdentity, holderId, leaseKey } = ctx;
     const startedAt = Date.now();
+    const leaseAcquisition = ctx.leaseAcquisition ?? acquireLeaseWithAcquisition(db, holderId, leaseKey) ?? (() => {
+      throw new Error("Dream lease unavailable during executor setup");
+    })();
     const deadline = startedAt + config.timeoutMinutes * 60 * 1000;
     const backlogAtStart = getDreamTaskBacklog(db, projectIdentity, config.task);
     const reportProgress = (processed) => {
@@ -17626,7 +17737,7 @@ function createDreamTaskExecutor(deps) {
     };
     const parent = await resolveParentSessionId();
     let moduleRoute;
-    if (config.task === "map-memories" || config.task === "compress-cues" || config.task === "verify" || config.task === "verify-broad" || config.task === "retrospective") {
+    if (config.task === "map-memories" || config.task === "compress-cues" || config.task === "classify-memories" || config.task === "verify" || config.task === "verify-broad" || config.task === "retrospective") {
       try {
         moduleRoute = await resolveDreamerModuleRoute({
           db,
@@ -17640,6 +17751,9 @@ function createDreamTaskExecutor(deps) {
         throw new DreamerModuleFailureError("authority.status", error);
       }
     }
+    if (!leaseOwnershipMatches(db, holderId, leaseAcquisition.generation, leaseKey)) {
+      throw new Error("Dream lease lost during executor setup");
+    }
     const recordRun = (status, error, extra) => {
       try {
         insertDreamRun(db, {
@@ -17712,6 +17826,7 @@ function createDreamTaskExecutor(deps) {
           holderId,
           leaseKey,
           deadline,
+          leaseAcquisition,
           model: config.model ?? deps.mural.model ?? deps.dreamerModel,
           fallbackModels: config.fallbackModels,
           moduleRoute,
@@ -17735,6 +17850,7 @@ function createDreamTaskExecutor(deps) {
           holderId,
           leaseKey,
           deadline,
+          leaseAcquisition,
           promotionThreshold: config.promotionThreshold ?? 3,
           model: config.model,
           fallbackModels: config.fallbackModels,
@@ -17754,6 +17870,7 @@ function createDreamTaskExecutor(deps) {
           holderId,
           leaseKey,
           deadline,
+          leaseAcquisition,
           model: config.model,
           fallbackModels: config.fallbackModels,
           moduleRoute,
@@ -17779,6 +17896,7 @@ function createDreamTaskExecutor(deps) {
           holderId,
           leaseKey,
           deadline,
+          leaseAcquisition,
           forceBroad: config.task === "verify-broad",
           model: config.model,
           fallbackModels: config.fallbackModels,
@@ -17812,40 +17930,15 @@ function createDreamTaskExecutor(deps) {
       }
       if (config.task === "classify-memories") {
         let moduleArgs;
-        const moduleTransport = deps.transformMode === "ts" ? undefined : deps.moduleClient;
-        if (moduleTransport?.authorityStatus) {
-          const contextStoreUuid = getContextStoreUuid(db);
-          if (!contextStoreUuid) {
-            throw new Error("Rust classify requires a context store identity");
-          }
-          let authority;
-          try {
-            authority = await moduleTransport.authorityStatus({
-              context_store_uuid: contextStoreUuid,
-              project: projectIdentity,
-              projectRoot: deps.sessionDirectory,
-              domain: "memories"
-            });
-          } catch (error) {
-            throw new ClassifyModuleFailureError("authority.status", error);
-          }
-          if (authority.authority?.state === "MODULE") {
-            const generation = authority.authority.generation;
-            if (typeof generation !== "number") {
-              throw new ClassifyModuleFailureError("authority.status", new Error("response omitted generation"));
-            }
-            const moduleClient = {
-              call: (callArgs) => moduleTransport.call(callArgs)
-            };
-            moduleArgs = {
-              moduleClient,
-              moduleSessionId: projectIdentity,
-              moduleProjectRoot: deps.sessionDirectory,
-              moduleContextStoreUuid: contextStoreUuid,
-              moduleAuthorityGeneration: generation,
-              moduleCommandId: `${startedAt}:${holderId}`
-            };
-          }
+        if (moduleRoute) {
+          moduleArgs = {
+            moduleClient: moduleRoute.moduleClient,
+            moduleSessionId: moduleRoute.moduleSessionId,
+            moduleProjectRoot: moduleRoute.moduleProjectRoot,
+            moduleContextStoreUuid: moduleRoute.moduleContextStoreUuid,
+            moduleAuthorityGeneration: moduleRoute.moduleAuthorityGeneration,
+            moduleCommandId: moduleRoute.moduleCommandId
+          };
         }
         const result = await runClassify({
           db,
@@ -17856,6 +17949,7 @@ function createDreamTaskExecutor(deps) {
           holderId,
           leaseKey,
           deadline,
+          leaseAcquisition,
           model: config.model,
           fallbackModels: config.fallbackModels,
           ...moduleArgs,
@@ -17879,6 +17973,7 @@ function createDreamTaskExecutor(deps) {
           holderId,
           leaseKey,
           deadline,
+          leaseAcquisition,
           promotionThreshold: config.promotionThreshold ?? 2,
           ensureProjectRegistered: deps.ensureProjectRegistered
         });
@@ -17896,6 +17991,7 @@ function createDreamTaskExecutor(deps) {
           holderId,
           leaseKey,
           deadline,
+          leaseAcquisition,
           model: config.model,
           fallbackModels: config.fallbackModels,
           language: config.language ?? deps.language,
@@ -17916,8 +18012,10 @@ function createDreamTaskExecutor(deps) {
           holderId,
           leaseKey,
           deadline,
+          leaseAcquisition,
           model: config.model,
-          fallbackModels: config.fallbackModels
+          fallbackModels: config.fallbackModels,
+          retinaHandoff: deps.retinaHandoff
         });
         recordRun("completed", null, {
           smartNotesSurfaced: result.surfaced,
@@ -18060,7 +18158,7 @@ async function runRetrospectiveTask(config, ctx, helpers) {
   const heartbeat = startLeaseHeartbeat(db, holderId, leaseKey, () => {
     leaseLost = true;
     abortController.abort();
-  });
+  }, ctx.leaseAcquisition);
   let childSessionId = null;
   try {
     const createResponse = await createChildSessionWithFence({
@@ -18250,7 +18348,7 @@ async function runAgenticTask(config, ctx, helpers) {
   const heartbeat = startLeaseHeartbeat(db, holderId, leaseKey, () => {
     leaseLost = true;
     abortController.abort();
-  });
+  }, ctx.leaseAcquisition);
   let childSessionId = null;
   try {
     const createResponse = await createChildSessionWithFence({
@@ -18433,15 +18531,15 @@ async function runDomainGroup(deps, group, cb) {
   const { db, projectIdentity, executor } = deps;
   const leaseKey = leaseKeyFor(group[0].config.task, projectIdentity);
   const holderId = crypto.randomUUID();
-  let acquired = acquireLease(db, holderId, leaseKey);
-  if (!acquired && cb?.leaseWaitMs) {
+  let acquisition = acquireLeaseWithAcquisition(db, holderId, leaseKey);
+  if (!acquisition && cb?.leaseWaitMs) {
     const deadline = Date.now() + cb.leaseWaitMs;
-    while (!acquired && Date.now() < deadline) {
+    while (!acquisition && Date.now() < deadline) {
       await new Promise((resolve3) => setTimeout(resolve3, LEASE_WAIT_POLL_MS));
-      acquired = acquireLease(db, holderId, leaseKey);
+      acquisition = acquireLeaseWithAcquisition(db, holderId, leaseKey);
     }
   }
-  if (!acquired) {
+  if (!acquisition) {
     log(`[dreamer] domain lease busy (${leaseKey}) — deferring ${group.length} task(s)`);
     for (const due of group)
       cb?.onBusy?.(due.config.task);
@@ -18449,7 +18547,7 @@ async function runDomainGroup(deps, group, cb) {
   }
   try {
     for (const due of [...group].sort((a, b) => compareTaskOrder(a.config.task, b.config.task))) {
-      if (!peekLeaseHolderAndExpiry(db, holderId, leaseKey)) {
+      if (!leaseOwnershipMatches(db, holderId, acquisition.generation, leaseKey)) {
         log(`[dreamer] domain lease lost (${leaseKey}) — stopping remaining task(s)`);
         break;
       }
@@ -18468,7 +18566,13 @@ async function runDomainGroup(deps, group, cb) {
       }
       let outcome;
       try {
-        outcome = await executor(due.config, { db, projectIdentity, holderId, leaseKey });
+        outcome = await executor(due.config, {
+          db,
+          projectIdentity,
+          holderId,
+          leaseKey,
+          leaseAcquisition: acquisition
+        });
       } catch (error) {
         outcome = { status: "failed", transient: true, error: String(error) };
       }
@@ -19133,6 +19237,7 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
       dreamerModel: dreamerConfig.model,
       mural: reg.mural,
       memoryInjectionBudgetTokens: reg.memoryInjectionBudgetTokens,
+      retinaHandoff: reg.retinaHandoff,
       transformMode: reg.transformMode,
       moduleClient: reg.moduleClient,
       onProgress: (progress, completedTask) => reg.onDreamerProgress?.(progress, completedTask)
@@ -19176,7 +19281,8 @@ async function runCompiledSmartNoteSweep(reg, db) {
     const result = await runDueCompiledSmartNoteChecks({
       db,
       projectIdentity: reg.projectIdentity,
-      projectRoot: reg.directory
+      projectRoot: reg.directory,
+      retinaHandoff: reg.retinaHandoff
     });
     if (result.ran > 0) {
       log(`[dreamer] compiled smart-note sweep ${reg.projectIdentity}: ran=${result.ran} surfaced=${result.surfaced} logic_failed=${result.failed} network_failed=${result.networkFailed}`);
@@ -20991,14 +21097,15 @@ function createMagicContextCommandHandler(deps) {
   const isSessionUpgradeCommand = (command) => command === "ctx-session-upgrade";
   const isEmbedCommand = (command) => command === "ctx-embed";
   const rustMode = deps.transformMode === "rust" && deps.rustModeModuleClient;
-  const callRust = async (method, body) => {
+  const callRust = async (method, body, timeoutMs) => {
     if (!rustMode)
       throw new Error("Rust module client is unavailable");
     return moduleResponseValue(await rustMode.call({
       sessionId: body.session_id,
       projectRoot: deps.projectRoot ?? process.cwd(),
       method,
-      body
+      body,
+      ...timeoutMs === undefined ? {} : { timeoutMs }
     }));
   };
   return {
@@ -21143,7 +21250,7 @@ Starting wrapup…`, {});
               session_id: sessionId,
               keep,
               command_id: rustCommandId("wrapup")
-            });
+            }, MAX_WRAPUP_REQUEST_BUDGET_MS);
             result = formatRustOperationMessage("wrapup", value);
           } catch (error) {
             result = `## Magic Wrapup — Failed
@@ -21542,6 +21649,13 @@ var sessionLocks = new Map;
 var incrementalTimers = new Map;
 var pendingIncrementalKeys = new Set;
 var completedIncrementalKeys = new Set;
+function clearCompletedIncrementalKeys(sessionId) {
+  const prefix = `${sessionId}\x00`;
+  for (const key of completedIncrementalKeys) {
+    if (key.startsWith(prefix))
+      completedIncrementalKeys.delete(key);
+  }
+}
 function defer(fn) {
   const immediate = globalThis.setImmediate;
   if (typeof immediate === "function") {
@@ -21656,14 +21770,12 @@ function scheduleIncrementalIndex(db, sessionId, messageId, messageSource) {
 function scheduleClearAndReindex(db, sessionId, readMessages) {
   reconciledSessions.delete(sessionId);
   reconciliationScheduledSessions.delete(sessionId);
-  const prefix = `${sessionId}\x00`;
-  for (const key of completedIncrementalKeys) {
-    if (key.startsWith(prefix))
-      completedIncrementalKeys.delete(key);
-  }
+  clearCompletedIncrementalKeys(sessionId);
   scheduleAfterBootQuiet(() => {
     defer(() => {
       runWithSessionLock(sessionId, () => {
+        reconciledSessions.delete(sessionId);
+        clearCompletedIncrementalKeys(sessionId);
         clearIndexedMessages(db, sessionId);
       }).then(() => reconcileSessionIndex(db, sessionId, readMessages)).catch((error) => {
         reconciledSessions.delete(sessionId);
@@ -22693,16 +22805,8 @@ function reconcileCompactionMode(args) {
       notice: COMPACTION_ON_WRAPUP_SUGGESTION
     };
   }
-  if (stored === "off_notice_pending") {
-    const markerCleanup2 = cleanupOffMarkers(sessionId);
-    return {
-      ...NO_TRANSITION,
-      recordToWrite: markerCleanup2.verified ? "off" : "off_cleanup_pending",
-      notice: COMPACTION_OFF_FLIP_NOTICE,
-      markerCleanup: markerCleanup2
-    };
-  }
-  if (!args.compactionOff) {
+  const completingOffNotice = stored === "off_notice_pending";
+  if (!args.compactionOff && !completingOffNotice) {
     if (stored === null || resolveCompactionModeRecord(stored) === "on") {
       return stored === null ? { ...NO_TRANSITION, recordToWrite: "on" } : NO_TRANSITION;
     }
@@ -22738,6 +22842,9 @@ function reconcileCompactionMode(args) {
       markerCleanup: markerCleanup2
     };
   }
+  if (!completingOffNotice) {
+    setCompactionModeRecord(db, sessionId, "off_notice_pending");
+  }
   let clearedSomething = false;
   const markerCleanup = cleanupOffMarkers(sessionId);
   if (markerCleanup.removedRows > 0)
@@ -22775,10 +22882,8 @@ function reconcileCompactionMode(args) {
     loggedUnverifiedMarkerCleanupRetry = true;
     sessionLog(sessionId, "compaction-off transition could not verify complete marker cleanup; durable cleanup retry will run on the next pass");
   }
-  const notice = clearedSomething ? COMPACTION_OFF_FLIP_NOTICE : null;
-  if (notice) {
-    setCompactionModeRecord(db, sessionId, "off_notice_pending");
-  } else if (!markerCleanup.verified) {
+  const notice = clearedSomething || completingOffNotice ? COMPACTION_OFF_FLIP_NOTICE : null;
+  if (!notice && !markerCleanup.verified) {
     setCompactionModeRecord(db, sessionId, "off_cleanup_pending");
   }
   return {
@@ -23607,6 +23712,22 @@ function partIsAnthropicThinking(part) {
   const type = part.type;
   return type === "thinking" || type === "reasoning" || type === "redacted_thinking";
 }
+function partEndsAnthropicAssistantRun(part) {
+  if (!part || typeof part !== "object")
+    return false;
+  const value = part;
+  if (value.type !== "tool" || value.providerExecuted === true || !value.state || typeof value.state !== "object") {
+    return false;
+  }
+  const status = value.state.status;
+  return status === "completed" || status === "error";
+}
+function partIsOpenCodeStepMetadata(part) {
+  if (!part || typeof part !== "object")
+    return false;
+  const type = part.type;
+  return type === "step-start" || type === "step-finish";
+}
 function validateAnthropicReasoningRuns(messages) {
   let index = 0;
   while (index < messages.length) {
@@ -23622,7 +23743,10 @@ function validateAnthropicReasoningRuns(messages) {
           thinkingBlocks += 1;
           if (thinkingBlocks > 1 || sawOtherContent)
             return false;
-        } else {
+        } else if (partEndsAnthropicAssistantRun(part)) {
+          thinkingBlocks = 0;
+          sawOtherContent = false;
+        } else if (!partIsOpenCodeStepMetadata(part)) {
           sawOtherContent = true;
         }
       }
@@ -24270,23 +24394,68 @@ function encodeOpenCodeMessagesToCk(messages) {
 
 // src/hooks/magic-context/module-state-sync.ts
 async function mirrorModuleCompartments(args) {
-  const row = args.db.prepare("SELECT COALESCE(MAX(sequence), -1) AS max_sequence FROM compartments WHERE session_id = ?").get(args.sessionId);
-  const afterSequence = row?.max_sequence ?? -1;
-  const published = await args.reader.getCompartmentsAfter(args.sessionId, afterSequence);
-  if (!Number.isFinite(published.max_sequence) || published.max_sequence <= afterSequence) {
-    return afterSequence;
-  }
-  const insert = args.db.prepare("INSERT INTO compartments (session_id, sequence, start_message, end_message, start_message_id, end_message_id, title, content, p1, p2, p3, p4, importance, episode_type, legacy, created_at, harness) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(session_id, sequence) DO NOTHING");
-  const now = Date.now();
-  args.db.transaction(() => {
+  const authoritative = [];
+  let afterSequence = -1;
+  let maxSequence = null;
+  for (;; ) {
+    const published = await args.reader.getCompartmentsAfter(args.sessionId, afterSequence);
+    if (!Number.isSafeInteger(published.max_sequence) || published.max_sequence < -1 || maxSequence !== null && published.max_sequence !== maxSequence) {
+      throw new Error("module compartment mirror changed while its authoritative set was read");
+    }
+    maxSequence ??= published.max_sequence;
+    let pageAdvanced = false;
     for (const compartment of published.compartments) {
-      if (!Number.isFinite(compartment.sequence) || compartment.sequence <= afterSequence || typeof compartment.start_message_id !== "string" || typeof compartment.end_message_id !== "string" || typeof compartment.title !== "string" || typeof compartment.content !== "string") {
-        continue;
+      if (!Number.isSafeInteger(compartment.sequence) || compartment.sequence <= afterSequence || compartment.sequence > maxSequence || !Number.isSafeInteger(compartment.start_message) || !Number.isSafeInteger(compartment.end_message) || typeof compartment.start_message_id !== "string" || typeof compartment.end_message_id !== "string" || typeof compartment.title !== "string" || typeof compartment.content !== "string") {
+        throw new Error("module compartment mirror returned an invalid authoritative row");
       }
-      insert.run(args.sessionId, compartment.sequence, compartment.start_message, compartment.end_message, compartment.start_message_id, compartment.end_message_id, compartment.title, compartment.content, compartment.p1 ?? null, compartment.p2 ?? null, compartment.p3 ?? null, compartment.p4 ?? null, compartment.importance ?? 50, compartment.episode_type ?? null, compartment.legacy ?? (compartment.p1 ? 0 : 1), compartment.created_at ?? now, getHarness());
+      authoritative.push(compartment);
+      afterSequence = compartment.sequence;
+      pageAdvanced = true;
+    }
+    if (afterSequence >= maxSequence)
+      break;
+    if (!pageAdvanced) {
+      throw new Error("module compartment mirror returned an incomplete authoritative set");
+    }
+  }
+  const local = args.db.prepare("SELECT sequence, end_message FROM compartments WHERE session_id = ? ORDER BY sequence ASC").all(args.sessionId);
+  let firstDifference = 0;
+  while (firstDifference < local.length && firstDifference < authoritative.length && local[firstDifference]?.sequence === authoritative[firstDifference]?.sequence && local[firstDifference]?.end_message === authoritative[firstDifference]?.end_message) {
+    firstDifference += 1;
+  }
+  const localDifference = local[firstDifference]?.sequence;
+  const authoritativeDifference = authoritative[firstDifference]?.sequence;
+  const divergentSequence = localDifference === undefined ? authoritativeDifference : authoritativeDifference === undefined ? localDifference : Math.min(localDifference, authoritativeDifference);
+  const upsert = args.db.prepare(`INSERT INTO compartments
+            (session_id, sequence, start_message, end_message, start_message_id, end_message_id,
+             title, content, p1, p2, p3, p4, importance, episode_type, legacy, created_at, harness)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(session_id, sequence) DO UPDATE SET
+             start_message = excluded.start_message,
+             end_message = excluded.end_message,
+             start_message_id = excluded.start_message_id,
+             end_message_id = excluded.end_message_id,
+             title = excluded.title,
+             content = excluded.content,
+             p1 = excluded.p1,
+             p2 = excluded.p2,
+             p3 = excluded.p3,
+             p4 = excluded.p4,
+             importance = excluded.importance,
+             episode_type = excluded.episode_type,
+             legacy = excluded.legacy,
+             created_at = excluded.created_at,
+             harness = excluded.harness`);
+  const now = Date.now();
+  args.db.transaction(() => {
+    if (divergentSequence !== undefined) {
+      args.db.prepare("DELETE FROM compartments WHERE session_id = ? AND sequence >= ?").run(args.sessionId, divergentSequence);
+    }
+    for (const compartment of authoritative) {
+      upsert.run(args.sessionId, compartment.sequence, compartment.start_message, compartment.end_message, compartment.start_message_id, compartment.end_message_id, compartment.title, compartment.content, compartment.p1 ?? null, compartment.p2 ?? null, compartment.p3 ?? null, compartment.p4 ?? null, compartment.importance ?? 50, compartment.episode_type ?? null, compartment.legacy ?? (compartment.p1 ? 0 : 1), compartment.created_at ?? now, getHarness());
     }
   })();
-  return published.max_sequence;
+  return maxSequence;
 }
 function stableHash(value) {
   return createHmac("sha256", "magic-context-shadow-watermark").update(value).digest("hex");
@@ -24906,7 +25075,7 @@ async function buildModuleStateSyncPayload(args) {
     workspace,
     nowMs: args.pass.nowMs
   }) : [];
-  const userProfile = includeUserProfile && profileChanged ? getActiveUserMemories(args.pass.db).map((memory) => memory.content) : [];
+  const userProfile = includeUserProfile ? getActiveUserMemories(args.pass.db).map((memory) => memory.content) : [];
   const memoryMutations = memoryMutationsChanged && args.pass.projectPath ? getMemoryMutationsForRenderByProjects(args.pass.db, workspace.expandedIdentities, acked.memory_mutation_id, renderedMemoryIds).map((row) => ({
     id: row.id,
     project_path: row.projectPath,
@@ -25051,62 +25220,87 @@ function readAuthoritySeqMismatch(error) {
 async function syncModuleState(args) {
   let force = args.force;
   const adoption = args.options?.authoritySeqAdoption ?? { used: false };
-  let stateSyncDeltas = args.options?.stateSyncDeltas;
-  if (stateSyncDeltas === undefined && args.client.stateSyncCapabilities) {
-    try {
-      stateSyncDeltas = (await args.client.stateSyncCapabilities({
-        sessionId: args.pass.sessionId,
-        projectRoot: args.projectRoot
-      })).state_sync_deltas === true;
-    } catch {
-      stateSyncDeltas = false;
-    }
-  }
-  for (;; ) {
-    const payload = await buildModuleStateSyncPayload({
-      state: args.state,
-      pass: args.pass,
-      force,
-      options: { ...args.options, stateSyncDeltas }
-    });
-    if (payload === null)
-      return { status: "no_change" };
-    if (payload === "m0_mutation" || payload === "mismatch" || payload === "unresolved" || payload === "seed_budget") {
-      throw new Error(`module state sync ${payload}`);
-    }
-    try {
-      const batches = payload.wireBatches ?? [payload];
-      for (const batch of batches) {
-        const response = await args.client.call({
+  const resolveStateSyncDeltas = async (afterGenerationChange = false) => {
+    let capability = afterGenerationChange ? undefined : args.options?.stateSyncDeltas;
+    capability ??= args.client.getCachedStateSyncCapabilities?.()?.state_sync_deltas;
+    if (capability === undefined && args.client.stateSyncCapabilities) {
+      try {
+        capability = (await args.client.stateSyncCapabilities({
           sessionId: args.pass.sessionId,
-          projectRoot: args.projectRoot,
-          method: "state_sync",
-          body: {
-            method: batch.method,
-            ...batch.params
+          projectRoot: args.projectRoot
+        })).state_sync_deltas;
+      } catch {
+        capability = false;
+      }
+    }
+    return capability === true;
+  };
+  let stateSyncDeltas = await resolveStateSyncDeltas();
+  syncLoop:
+    for (;; ) {
+      const payload = await buildModuleStateSyncPayload({
+        state: args.state,
+        pass: args.pass,
+        force,
+        options: { ...args.options, stateSyncDeltas }
+      });
+      if (payload === null)
+        return { status: "no_change" };
+      if (payload === "m0_mutation" || payload === "mismatch" || payload === "unresolved" || payload === "seed_budget") {
+        throw new Error(`module state sync ${payload}`);
+      }
+      try {
+        const batches = payload.wireBatches ?? [payload];
+        for (const batch of batches) {
+          const response = await args.client.call({
+            sessionId: args.pass.sessionId,
+            projectRoot: args.projectRoot,
+            method: "state_sync",
+            body: {
+              method: batch.method,
+              ...batch.params
+            },
+            generationSensitive: stateSyncDeltas
+          });
+          if (isModuleTransportGenerationChangedResult(response)) {
+            stateSyncDeltas = await resolveStateSyncDeltas(true);
+            continue syncLoop;
+          }
+          if (args.options?.authority === true && responseMemoriesSkipped(response) && !args.state.authorityMemorySyncSkipLogged) {
+            args.state.authorityMemorySyncSkipLogged = true;
+            sessionLog(args.pass.sessionId, "authority state sync skipped module-owned memory sections");
           }
-        });
-        if (args.options?.authority === true && responseMemoriesSkipped(response) && !args.state.authorityMemorySyncSkipLogged) {
-          args.state.authorityMemorySyncSkipLogged = true;
-          sessionLog(args.pass.sessionId, "authority state sync skipped module-owned memory sections");
         }
+      } catch (error) {
+        if (isHistorianCompartmentSyncBusy(error)) {
+          return { status: "retry_busy" };
+        }
+        const durableSeq = args.options?.authority ? readAuthoritySeqMismatch(error) : null;
+        if (durableSeq === null || adoption.used)
+          throw error;
+        adoption.used = true;
+        args.state.lastAckedSeq = durableSeq;
+        args.state.lastAckedWatermarks = null;
+        force = true;
+        continue;
       }
-    } catch (error) {
-      if (isHistorianCompartmentSyncBusy(error)) {
-        return { status: "retry_busy" };
-      }
-      const durableSeq = args.options?.authority ? readAuthoritySeqMismatch(error) : null;
-      if (durableSeq === null || adoption.used)
-        throw error;
-      adoption.used = true;
-      args.state.lastAckedSeq = durableSeq;
-      args.state.lastAckedWatermarks = null;
-      force = true;
-      continue;
+      args.state.lastAckedWatermarks = payload.watermarks;
+      args.state.lastAckedSeq += 1;
+      return { status: "acked", watermarks: payload.watermarks };
     }
-    args.state.lastAckedWatermarks = payload.watermarks;
-    args.state.lastAckedSeq += 1;
-    return { status: "acked", watermarks: payload.watermarks };
+}
+
+// src/hooks/magic-context/raw-fallback-context-limit.ts
+class RawFallbackContextLimitError extends Error {
+  estimatedTokens;
+  contextLimitTokens;
+  code = "RAW_FALLBACK_CONTEXT_LIMIT";
+  recoverable = true;
+  constructor(estimatedTokens, contextLimitTokens, options) {
+    super(`Magic Context could not safely serve the raw prompt: the best local estimate is ${estimatedTokens.toLocaleString()} tokens, above the known ${contextLimitTokens.toLocaleString()}-token context limit. Retry the turn so the module can reconnect.`, options);
+    this.estimatedTokens = estimatedTokens;
+    this.contextLimitTokens = contextLimitTokens;
+    this.name = "RawFallbackContextLimitError";
   }
 }
 
@@ -27590,7 +27784,7 @@ var REASONING_IGNORED_PART_TYPES = new Set([
   "compaction"
 ]);
 var REASONING_PART_TYPES = new Set(["reasoning", "thinking", "redacted_thinking"]);
-function stripReasoningFromMergedAssistants(messages, providerID) {
+function stripReasoningFromMergedAssistants(messages, providerID, options) {
   if (providerID !== "anthropic")
     return 0;
   let stripped = 0;
@@ -27606,6 +27800,10 @@ function stripReasoningFromMergedAssistants(messages, providerID) {
     const firstInRun = prevRole !== "assistant";
     if (firstInRun)
       keptReasoningInRun = false;
+    if (message === options?.mutationExemptMessage) {
+      prevRole = role;
+      continue;
+    }
     let keepIndex = -1;
     if (firstInRun && !keptReasoningInRun) {
       for (let i = 0;i < message.parts.length; i++) {
@@ -28700,11 +28898,21 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
       clearedParts = stripClearedReasoning(targetedMessages);
     }
   }
-  const mergedReasoningParts = stripReasoningFromMergedAssistants(messages, resolvedProviderID);
+  const mergedReasoningParts = stripReasoningFromMergedAssistants(messages, resolvedProviderID, {
+    mutationExemptMessage: options?.reasoningMutationExemptMessage
+  });
   return { clearedParts, mergedReasoningParts };
 }
 async function runPostTransformPhase(args) {
   const compactionOff = args.compactionOff === true;
+  let reasoningMutationExemptMessage;
+  for (let index = args.messages.length - 1;index >= 0; index -= 1) {
+    const message = args.messages[index];
+    if (message.info.role !== "assistant")
+      continue;
+    reasoningMutationExemptMessage = message;
+    break;
+  }
   const pendingMaterializationAtPassStart = args.pendingMaterializationSessions.has(args.sessionId);
   const deferredMaterializationAtPassStart = args.deferredMaterializationSessions.has(args.sessionId);
   const isExplicitFlush = pendingMaterializationAtPassStart;
@@ -28723,6 +28931,10 @@ async function runPostTransformPhase(args) {
     state: args.sessionMeta,
     projectPath: args.m0M1.projectPath,
     projectDirectory: args.m0M1.projectDirectory,
+    injectDocs: args.m0M1.injectDocs,
+    muralEnabled: args.m0M1.muralEnabled,
+    memoryInjectionBudgetTokens: args.m0M1.memoryInjectionBudgetTokens,
+    historyBudgetTokens: args.m0M1.historyBudgetTokens,
     hardSignals: args.m0M1.hardSignals
   }).value : false;
   const bypassCompartmentGate = forceMaterialization || m0HardFoldThisPass;
@@ -29251,7 +29463,8 @@ async function runPostTransformPhase(args) {
   const tFinalRepresentation = performance.now();
   const finalRepresentation = finalizeMessageRepresentation(args.messages, args.resolvedProviderID, {
     prependedMessageCount,
-    reasoningMutatedMessages
+    reasoningMutatedMessages,
+    reasoningMutationExemptMessage
   });
   sessionLog(args.sessionId, `final representation: clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts}`);
   logTransformTiming(args.sessionId, "finalizeMessageRepresentation", tFinalRepresentation, `clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts}`);
@@ -29293,6 +29506,15 @@ var RUST_PARK_RETRY_INTERVAL = 5;
 var RUST_EMERGENCY_WALL_PCT = 95;
 var RUST_PARK_PROBE_PRESSURE_BYPASS_PCT = 90;
 var RUST_SEND_TIMEOUT_MS = 15000;
+var RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN = 4;
+function rawFallbackSerializedBytes(messages) {
+  try {
+    const serialized = JSON.stringify(messages);
+    return typeof serialized === "string" ? Buffer.byteLength(serialized) : null;
+  } catch {
+    return null;
+  }
+}
 function isRecord3(value) {
   return value !== null && typeof value === "object";
 }
@@ -29321,34 +29543,26 @@ function updateFnv1a32(hash, value) {
   }
   return next;
 }
-var SNAPSHOT_ARRAY = Symbol("array");
-var SNAPSHOT_OBJECT = Symbol("object");
-var SNAPSHOT_KEY = Symbol("key");
-var SNAPSHOT_STRING = Symbol("string");
-var SNAPSHOT_NUMBER = Symbol("number");
-var SNAPSHOT_BOOLEAN = Symbol("boolean");
-var SNAPSHOT_NULL = Symbol("null");
-var SNAPSHOT_UNDEFINED = Symbol("undefined");
 function isSnapshotObjectChild(value) {
   return value !== undefined && typeof value !== "function" && typeof value !== "symbol";
 }
 function visitMessageContentFields(value, visitor) {
   if (value === null)
-    return visitor.field(SNAPSHOT_NULL);
+    return visitor.field(LKG_SNAPSHOT_NULL);
   if (typeof value === "string") {
-    return visitor.field(SNAPSHOT_STRING) && visitor.field(value);
+    return visitor.field(LKG_SNAPSHOT_STRING) && visitor.field(value);
   }
   if (typeof value === "number") {
-    return visitor.field(SNAPSHOT_NUMBER) && visitor.field(value);
+    return visitor.field(LKG_SNAPSHOT_NUMBER) && visitor.field(value);
   }
   if (typeof value === "boolean") {
-    return visitor.field(SNAPSHOT_BOOLEAN) && visitor.field(value);
+    return visitor.field(LKG_SNAPSHOT_BOOLEAN) && visitor.field(value);
   }
   if (value === undefined || typeof value === "function" || typeof value === "symbol") {
-    return visitor.field(SNAPSHOT_UNDEFINED);
+    return visitor.field(LKG_SNAPSHOT_UNDEFINED);
   }
   if (Array.isArray(value)) {
-    if (!visitor.field(SNAPSHOT_ARRAY) || !visitor.field(value.length))
+    if (!visitor.field(LKG_SNAPSHOT_ARRAY) || !visitor.field(value.length))
       return false;
     for (const item of value) {
       if (!visitMessageContentFields(item, visitor))
@@ -29357,7 +29571,7 @@ function visitMessageContentFields(value, visitor) {
     return true;
   }
   if (typeof value === "object") {
-    if (!visitor.field(SNAPSHOT_OBJECT))
+    if (!visitor.field(LKG_SNAPSHOT_OBJECT))
       return false;
     const objectToken = visitor.beginObject();
     if (objectToken === undefined)
@@ -29370,13 +29584,13 @@ function visitMessageContentFields(value, visitor) {
       if (!isSnapshotObjectChild(child))
         continue;
       entryCount += 1;
-      if (!visitor.field(SNAPSHOT_KEY) || !visitor.field(key) || !visitMessageContentFields(child, visitor)) {
+      if (!visitor.field(LKG_SNAPSHOT_KEY) || !visitor.field(key) || !visitMessageContentFields(child, visitor)) {
         return false;
       }
     }
     return visitor.endObject(objectToken, entryCount);
   }
-  return visitor.field(SNAPSHOT_UNDEFINED);
+  return visitor.field(LKG_SNAPSHOT_UNDEFINED);
 }
 function messageContentFields(message) {
   const fields = [];
@@ -29533,6 +29747,19 @@ function responseValue(response) {
     return response;
   throw new Error("module transform returned a non-object response");
 }
+function mirrorRustRenderedMemoryIds(args) {
+  if (!("rendered_memory_ids" in args.response))
+    return;
+  const rawIds = args.response.rendered_memory_ids;
+  if (!Array.isArray(rawIds) || rawIds.some((id) => typeof id !== "number" || !Number.isSafeInteger(id) || id <= 0)) {
+    throw new Error("module transform returned an invalid rendered-memory manifest");
+  }
+  const serialized = JSON.stringify(rawIds);
+  args.db.prepare(`UPDATE session_meta
+                SET memory_block_ids = ?, memory_block_count = ?
+              WHERE session_id = ?
+                AND (COALESCE(memory_block_ids, '') <> ? OR COALESCE(memory_block_count, -1) <> ?)`).run(serialized, rawIds.length, args.sessionId, serialized, rawIds.length);
+}
 function noteDeliveryPassIds(response) {
   if (!Array.isArray(response.note_deliveries))
     return [];
@@ -29587,7 +29814,10 @@ function ensureState(states, sessionId) {
       memoryAuthorityProject: null,
       memoryAuthorityRoot: null,
       memoryAuthorityReady: false,
-      authorityMemorySyncSkipLogged: false
+      authorityMemorySyncSkipLogged: false,
+      lkgCaptureSequence: 0,
+      lkgLastCapturedRowVersion: 0,
+      lkgSyncCaptureRequired: false
     };
     states.set(sessionId, state);
   }
@@ -29878,8 +30108,10 @@ function buildTransformBody(args) {
     model_key: args.modelKey,
     provider_id: args.providerId,
     tool_present: args.passInputs.tool_present === true,
+    ...typeof args.passInputs.todo_tool_present === "boolean" ? { todo_tool_present: args.passInputs.todo_tool_present } : {},
     prompt_surface_preset: args.passInputs.prompt_surface_preset ?? "full",
     prompt_surface_model_key: args.passInputs.prompt_surface_model_key,
+    prompt_surface_config_identity: args.passInputs.prompt_surface_config_identity,
     prompt_surface_tool_descriptions: args.passInputs.prompt_surface_tool_descriptions ?? {},
     effective_execute_threshold: args.passInputs.effective_execute_threshold,
     history_budget_tokens: args.passInputs.history_budget_tokens,
@@ -29901,6 +30133,8 @@ function buildTransformBody(args) {
 function createRustModeTransform(deps, options) {
   const states = new Map;
   const wireCaches = new Map;
+  const scheduleLkgCapture = options.scheduleLkgCapture ?? ((capture) => setImmediate(capture));
+  const rawFallbackEstimator = options.rawFallbackEstimatorForTests ?? estimateFinalWireInputTokens;
   const timeoutMs = Math.max(1, options.moduleTimeoutMs ?? RUST_SEND_TIMEOUT_MS);
   const logStage = (sessionId, stage, startedAt, timings, extra) => {
     const elapsed = Math.max(0, performance.now() - startedAt);
@@ -30019,28 +30253,50 @@ function createRustModeTransform(deps, options) {
     sessionLog(sessionId, "lkg_replay_served");
     return true;
   };
-  const captureRustResponse = (sessionId, input, response) => {
-    const ids = input.map((message) => message.info.id);
-    if (ids.some((id) => typeof id !== "string") || new Set(ids).size !== ids.length || ids.length === 0) {
-      return false;
+  const prepareRustCapture = (state, sessionId, input, inputSnapshots, response, responseRowVersion) => {
+    state.lkgCaptureSequence += 1;
+    const inputIds = input.map((message) => message.info.id);
+    if (inputIds.some((id) => typeof id !== "string") || new Set(inputIds).size !== inputIds.length || inputIds.length === 0 || inputSnapshots.length !== inputIds.length) {
+      return null;
     }
-    const inputContentDigests = input.map((message) => lkgContentDigest(message));
-    if (inputContentDigests.some((digest) => digest === null))
-      return false;
     const native = response.native_messages;
     const jsonPrefix = typeof native === "string" ? native : JSON.stringify(native);
     if (typeof jsonPrefix !== "string")
-      return false;
+      return null;
     const keys = resolveLkgModelKeys(input);
-    return captureSlot(sessionId, {
+    return {
+      sessionId,
+      inputIds,
+      inputSnapshots,
       jsonPrefix,
-      inputIdSeq: ids,
-      inputContentDigests,
-      lastInputMessageId: ids[ids.length - 1],
       modelKey: keys.modelKey,
       providerKey: keys.providerKey,
-      capturedAt: Date.now()
+      capturedAt: Date.now(),
+      rowVersion: responseRowVersion,
+      captureSequence: state.lkgCaptureSequence
+    };
+  };
+  const commitRustCapture = (state, plan) => {
+    if (states.get(plan.sessionId) !== state || plan.captureSequence !== state.lkgCaptureSequence || plan.rowVersion < state.lkgLastCapturedRowVersion) {
+      return "superseded";
+    }
+    const inputContentDigests = plan.inputSnapshots.map((snapshot) => lkgContentDigestFromFields(snapshot.fields));
+    const captured = captureSlot(plan.sessionId, {
+      jsonPrefix: plan.jsonPrefix,
+      inputIdSeq: plan.inputIds,
+      inputContentDigests,
+      lastInputMessageId: plan.inputIds[plan.inputIds.length - 1],
+      modelKey: plan.modelKey,
+      providerKey: plan.providerKey,
+      capturedAt: plan.capturedAt,
+      rowVersion: plan.rowVersion,
+      captureSequence: plan.captureSequence
     });
+    if (!captured)
+      throw new Error("LKG slot rejected the prepared snapshot");
+    state.lkgLastCapturedRowVersion = plan.rowVersion;
+    state.lkgSyncCaptureRequired = false;
+    return "captured";
   };
   const run = async (sessionId, messages, output, sessionMeta) => {
     const passStartedAt = performance.now();
@@ -30098,6 +30354,29 @@ function createRustModeTransform(deps, options) {
       const hasProviderProof = overflowState.detectedContextLimit > 0 && detectedLimitMatchesModel || isProviderOverflowReconfirmed(sessionId);
       emergencyFailClosed ||= overflowState.needsEmergencyRecovery && overflowState.emergencyRecoveryOrigin === "provider_overflow" && hasProviderProof;
     }
+    const serveRawFallback = (cause) => {
+      const contextLimit = resolvedContextLimit ?? (overflowState && overflowState.detectedContextLimit > 0 ? overflowState.detectedContextLimit : undefined);
+      if (contextLimit !== undefined) {
+        let estimate;
+        try {
+          estimate = rawFallbackEstimator({
+            messages,
+            systemPromptTokens: sessionMeta.systemPromptTokens,
+            providerID: model?.providerID,
+            modelID: model?.modelID,
+            agentName: deps.getNotificationParams?.(sessionId)?.agent
+          });
+        } catch {}
+        const rawBytes = rawFallbackSerializedBytes(messages);
+        const proxyTokens = rawBytes === null ? contextLimit + 1 : Math.ceil(rawBytes / RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN);
+        const refusalTokens = Math.max(estimate?.tokens ?? 0, proxyTokens);
+        if (refusalTokens > contextLimit) {
+          sessionLog(sessionId, `raw_fallback_over_context_limit estimated=${estimate?.tokens ?? "unavailable"} ` + `proxy_bytes=${rawBytes ?? "unavailable"} proxy_tokens=${proxyTokens} limit=${contextLimit}`);
+          throw new RawFallbackContextLimitError(refusalTokens, contextLimit, { cause });
+        }
+      }
+      replaceMessagesInPlace(output, messages);
+    };
     const finishPass = (applied, served = true) => {
       const elapsedAt = applied && appliedAt !== undefined ? appliedAt : performance.now();
       const elapsedMs = Math.max(0, elapsedAt - passStartedAt);
@@ -30128,11 +30407,19 @@ function createRustModeTransform(deps, options) {
       servedFrom = typeof response.served_from === "string" ? response.served_from : "unknown";
       materializeReason = typeof response.materialize_reason === "string" && response.materialize_reason.length > 0 ? response.materialize_reason : "none";
       const timings2 = isRecord3(response.timings) ? response.timings : undefined;
-      const total = timings2?.total;
-      moduleElapsedMs = typeof total === "number" && Number.isFinite(total) ? total : 0;
+      const applyOnceTotal = timings2?.total;
+      const handlerTotal = timings2?.handler_total;
+      moduleElapsedMs = typeof handlerTotal === "number" && Number.isFinite(handlerTotal) ? handlerTotal : typeof applyOnceTotal === "number" && Number.isFinite(applyOnceTotal) ? applyOnceTotal : 0;
       rowVersion = typeof response.row_version === "number" && Number.isSafeInteger(response.row_version) ? response.row_version : 0;
+      if (timings2 && (typeof timings2.handler_total === "number" || typeof timings2.native_cache_reused_messages === "number" || typeof timings2.native_cache_encoded_messages === "number")) {
+        const stage = (name) => {
+          const value = timings2[name];
+          return typeof value === "number" && Number.isFinite(value) ? value.toFixed(1) : "n/a";
+        };
+        sessionLog(sessionId, `rust module stages: handler=${stage("handler_total")} apply_once=${stage("total")} ` + `request_to_handler=${stage("request_observed_to_handler")} ` + `projection=${stage("projection")} selection=${stage("selection")} ` + `build_output=${stage("build_output")} store_commit=${stage("store_commit")} ` + `post_attach=${stage("post_attach")} response_encode=${stage("response_encode")} ` + `native_cache_reused=${stage("native_cache_reused_messages")} ` + `native_cache_encoded=${stage("native_cache_encoded_messages")}`);
+      }
       if (timings2 && moduleElapsedMs >= 1000) {
-        const detail = Object.entries(timings2).filter(([key, value]) => key !== "total" && typeof value === "number").map(([key, value]) => `${key}:${value.toFixed(1)}`).join(" ");
+        const detail = Object.entries(timings2).filter(([key, value]) => key !== "total" && key !== "handler_total" && typeof value === "number").map(([key, value]) => `${key}:${value.toFixed(1)}`).join(" ");
         if (detail)
           sessionLog(sessionId, `rust module stages (slow pass): ${detail}`);
       }
@@ -30146,7 +30433,12 @@ function createRustModeTransform(deps, options) {
           servedFrom = "lkg";
         } else {
           servedFrom = "raw";
-          replaceMessagesInPlace(output, messages);
+          try {
+            serveRawFallback();
+          } catch (error) {
+            finishPass(false, false);
+            throw error;
+          }
         }
         finishPass(false);
         return;
@@ -30154,7 +30446,9 @@ function createRustModeTransform(deps, options) {
     }
     const reduceAvailability = resolveCtxReduceAvailability(sessionId);
     resolveTodowriteAvailabilityFromMessages(sessionId, messages);
+    const todoAvailability = resolveTodowriteAvailability(sessionId);
     const toolPresent = reduceAvailability.frozen && reduceAvailability.callable;
+    const todoToolPresent = todoAvailability.frozen ? todoAvailability.callable : undefined;
     try {
       if (preflightError)
         throw preflightError;
@@ -30188,8 +30482,10 @@ function createRustModeTransform(deps, options) {
         system_prompt_hash: sessionMeta.systemPromptHash ?? "",
         upgrade_state: readUpgradeState(deps.db, sessionId),
         tool_present: toolPresent,
+        todo_tool_present: todoToolPresent,
         prompt_surface_preset: promptSurface.preset,
         prompt_surface_model_key: modelKey,
+        prompt_surface_config_identity: promptSurfaceConfigIdentity(deps.promptSurface),
         prompt_surface_tool_descriptions: deps.promptSurface?.tool_descriptions ?? {},
         protected_tags: deps.protectedTags ?? DEFAULT_PROTECTED_TAGS,
         temporal_awareness: deps.experimentalTemporalAwareness === true,
@@ -30306,10 +30602,12 @@ function createRustModeTransform(deps, options) {
             };
           }
         }
+        const getCachedStateSyncCapabilities = options.moduleClient.getCachedStateSyncCapabilities;
         const stateSyncCapabilities = options.moduleClient.stateSyncCapabilities;
         const stateSyncResult = await syncModuleState({
           client: {
             call: callModule,
+            getCachedStateSyncCapabilities: getCachedStateSyncCapabilities ? () => getCachedStateSyncCapabilities.call(options.moduleClient) : undefined,
             stateSyncCapabilities: stateSyncCapabilities ? (capabilityArgs) => stateSyncCapabilities.call(options.moduleClient, capabilityArgs) : undefined
           },
           state,
@@ -30434,6 +30732,7 @@ function createRustModeTransform(deps, options) {
         throw new Error("rust module returned no transform response");
       captureResponseTelemetry(response);
       if (isNeedFullSync(response)) {
+        options.moduleClient.invalidateStateSyncCapabilities?.();
         state.forceFullWire = true;
         if (wireDelta) {
           const retryOrdinalStartedAt = performance.now();
@@ -30587,13 +30886,46 @@ function createRustModeTransform(deps, options) {
         }
         logStage(sessionId, "apply", applyStartedAt, timings);
         const lkgSnapshotStartedAt = performance.now();
-        if (cacheBustingPass || !getSlot(sessionId)) {
-          const captured = captureRustResponse(sessionId, messages, response);
-          if (cacheBustingPass && !captured) {
-            dropSlot(sessionId, "lkg_refresh_declined");
+        if (cacheBustingPass) {
+          dropSlot(sessionId, "lkg_cache_bust_pending_capture");
+        }
+        const capturePlan = prepareRustCapture(state, sessionId, messages, pendingWireCache.rawContentSnapshots, response, rowVersion);
+        let captureMode = "async";
+        const captureFailed = (mode, error) => {
+          if (states.get(sessionId) !== state || capturePlan && capturePlan.captureSequence !== state.lkgCaptureSequence) {
+            return;
+          }
+          dropSlot(sessionId, `lkg_${mode}_capture_failed`);
+          state.lkgSyncCaptureRequired = true;
+          sessionLog(sessionId, `LKG ${mode.toUpperCase()} CAPTURE FAILED; forcing synchronous capture on the next applied pass:`, error);
+        };
+        if (!capturePlan) {
+          captureMode = "declined";
+          captureFailed("async", new Error("LKG snapshot preparation was rejected"));
+        } else if (state.lkgSyncCaptureRequired) {
+          captureMode = "sync_recovery";
+          try {
+            commitRustCapture(state, capturePlan);
+          } catch (error) {
+            captureFailed("sync", error);
+          }
+        } else {
+          try {
+            scheduleLkgCapture(() => {
+              const asyncStartedAt = performance.now();
+              try {
+                const result = commitRustCapture(state, capturePlan);
+                logTransformTiming(sessionId, "rust.lkg_snapshot_async", asyncStartedAt, `result=${result} row_version=${capturePlan.rowVersion}`);
+              } catch (error) {
+                captureFailed("async", error);
+              }
+            });
+          } catch (error) {
+            captureMode = "schedule_failed";
+            captureFailed("async", error);
           }
         }
-        logStage(sessionId, "lkgSnapshot", lkgSnapshotStartedAt, timings, cacheBustingPass ? "captured=true" : "captured=false");
+        logStage(sessionId, "lkgSnapshot", lkgSnapshotStartedAt, timings, `mode=${captureMode} row_version=${rowVersion}`);
         const applyReplaceStartedAt = performance.now();
         replaceMessagesInPlace(output, appliedMessages);
         logStage(sessionId, "apply", applyReplaceStartedAt, timings);
@@ -30606,6 +30938,11 @@ function createRustModeTransform(deps, options) {
         }
         throw error;
       }
+      try {
+        mirrorRustRenderedMemoryIds({ db: deps.db, sessionId, response });
+      } catch (error) {
+        sessionLog(sessionId, "rust rendered-memory mirror write failed (ignored):", error);
+      }
       if (deliveryPassIds.length > 0) {
         try {
           await sendNoteDeliveryDisposition("transform.ack");
@@ -30700,13 +31037,19 @@ function createRustModeTransform(deps, options) {
         throw new EmergencyFailClosedError("Rust Magic Context was unavailable at a provider-proven context limit", { cause: error });
       }
       const replayed = replayLastGood(sessionId, messages, output, sessionMeta.systemPromptTokens);
-      if (!replayed)
-        replaceMessagesInPlace(output, messages);
       servedFrom = replayed ? "lkg" : "raw";
       if (decision.toLowerCase() !== "need_full_sync")
         decision = "error";
       materializeReason = "none";
       markFailure(sessionId, state, error);
+      if (!replayed) {
+        try {
+          serveRawFallback(error);
+        } catch (rawFallbackError) {
+          finishPass(false, false);
+          throw rawFallbackError;
+        }
+      }
       finishPass(false);
       return;
     }
@@ -31156,16 +31499,6 @@ function createTransform(deps) {
       sessionLog(sessionId, "transform skipped (internal magic-context child session)");
       return;
     }
-    if (deps.transformMode === "rust") {
-      if (!rustModeTransform) {
-        sessionLog(sessionId, "rust transform unavailable; using raw passthrough");
-        return;
-      }
-      await rustModeTransform.run(sessionId, messages, output, sessionMeta);
-      return;
-    }
-    const reducedMode = sessionMeta.isSubagent;
-    const fullFeatureMode = !reducedMode;
     const compactionOff = deps.compactionOff === true;
     try {
       const transition = reconcileCompactionMode({
@@ -31207,6 +31540,18 @@ function createTransform(deps) {
       passOutcome.record("compaction-mode-transition-failure");
       sessionLog(sessionId, "compaction mode transition failed (retrying next pass):", error);
     }
+    if (deps.transformMode === "rust") {
+      if (compactionOff)
+        return;
+      if (!rustModeTransform) {
+        sessionLog(sessionId, "rust transform unavailable; using raw passthrough");
+        return;
+      }
+      await rustModeTransform.run(sessionId, messages, output, sessionMeta);
+      return;
+    }
+    const reducedMode = sessionMeta.isSubagent;
+    const fullFeatureMode = !reducedMode;
     const ctxReduceAvailability = resolveCtxReduceAvailabilityFromMessages(sessionId, messages);
     const ctxReduceCallable = ctxReduceAvailability.callable;
     const todowriteAvailability = resolveTodowriteAvailabilityFromMessages(sessionId, messages);
@@ -33284,37 +33629,49 @@ function createSystemPromptHashHandler(deps) {
     }
     const isCacheBusting = deps.systemPromptRefreshSessions.has(sessionId);
     const DATE_PATTERN = /Today's date: .+/;
+    const DATE_PATTERN_ALL = /Today's date: .+/g;
+    const liveSystemContent = output.system.join(`
+`);
+    if (liveSystemContent.length === 0)
+      return;
+    const previousHash = sessionMetaEarly?.systemPromptHash ?? "";
+    const hasPersistedHash = previousHash !== "" && previousHash !== "0";
+    const dateElementIndexes = [];
+    let currentDate;
     for (let i = 0;i < output.system.length; i++) {
       const match = output.system[i].match(DATE_PATTERN);
       if (!match)
         continue;
-      const currentDate = match[0];
-      const stickyDate = stickyDateBySession.get(sessionId);
-      if (!stickyDate) {
+      dateElementIndexes.push(i);
+      currentDate ??= match[0];
+    }
+    const stickyDate = stickyDateBySession.get(sessionId);
+    const stableCandidate = currentDate && stickyDate && currentDate !== stickyDate ? liveSystemContent.replace(DATE_PATTERN_ALL, stickyDate) : liveSystemContent;
+    const stableCandidateHash = createHash14("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
+    const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
+    const dateMayAdvance = isCacheBusting || contentOrPresetChanged;
+    if (currentDate && !stickyDate) {
+      stickyDateBySession.set(sessionId, currentDate);
+    } else if (currentDate && stickyDate && currentDate !== stickyDate) {
+      if (dateMayAdvance) {
         stickyDateBySession.set(sessionId, currentDate);
-      } else if (currentDate !== stickyDate) {
-        if (isCacheBusting) {
-          stickyDateBySession.set(sessionId, currentDate);
-          sessionLog(sessionId, `system prompt date updated: ${stickyDate} → ${currentDate} (cache-busting pass)`);
-        } else {
-          output.system[i] = output.system[i].replace(DATE_PATTERN, stickyDate);
-          sessionLog(sessionId, `system prompt date frozen: real=${currentDate}, using=${stickyDate} (defer pass)`);
+        sessionLog(sessionId, `system prompt date updated: ${stickyDate} → ${currentDate} (cache-busting pass)`);
+      } else if (dateElementIndexes.length > 0) {
+        for (const index of dateElementIndexes) {
+          output.system[index] = output.system[index].replace(DATE_PATTERN_ALL, stickyDate);
         }
+        sessionLog(sessionId, `system prompt date frozen: real=${currentDate}, using=${stickyDate} (defer pass)`);
       }
-      break;
     }
     const systemContent = output.system.join(`
 `);
-    if (systemContent.length === 0)
-      return;
-    if (!availability.frozen)
+    if (!availability.frozen || !modelKey)
       return;
     const currentHash = createHash14("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
     if (!sessionMetaEarly) {
       return;
     }
     const sessionMeta = sessionMetaEarly;
-    const previousHash = sessionMeta.systemPromptHash;
     if (previousHash !== "" && previousHash !== "0" && previousHash !== currentHash) {
       sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${systemContent.length}), triggering flush`);
       deps.historyRefreshSessions.add(sessionId);
@@ -33487,6 +33844,37 @@ function notifyMagicContextDisabled(client, reason) {
     log("[magic-context] failed to show disabled toast:", error);
   });
 }
+function moduleNoteRowId(response, depth = 0) {
+  if (depth > 4 || response === null || response === undefined)
+    return null;
+  if (typeof response === "string") {
+    const match = response.match(/\b(?:smart\s+)?note\s+#(\d+)/i);
+    return match ? Number(match[1]) : null;
+  }
+  if (Array.isArray(response)) {
+    for (const item of response) {
+      const id = moduleNoteRowId(item, depth + 1);
+      if (id !== null)
+        return id;
+    }
+    return null;
+  }
+  if (typeof response !== "object")
+    return null;
+  const record = response;
+  return moduleNoteRowId(record.result, depth + 1) ?? moduleNoteRowId(record.content, depth + 1) ?? moduleNoteRowId(record.text, depth + 1);
+}
+function moduleNoteResponseIsError(response, depth = 0) {
+  if (depth > 4 || response === null || typeof response !== "object")
+    return false;
+  if (Array.isArray(response)) {
+    return response.some((item) => moduleNoteResponseIsError(item, depth + 1));
+  }
+  const record = response;
+  if (record.isError === true || record.ok === false || record.error !== undefined)
+    return true;
+  return moduleNoteResponseIsError(record.result, depth + 1);
+}
 function createMagicContextHook(deps) {
   const contextUsageMap = new Map;
   let db;
@@ -33761,6 +34149,7 @@ function createMagicContextHook(deps) {
     autoEmbedAttemptedBySession.add(sessionId);
     const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
     (async () => {
+      let completedDrainWithWork = false;
       try {
         await new Promise((resolve3) => setTimeout(resolve3, 0));
         await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
@@ -33782,6 +34171,8 @@ function createMagicContextHook(deps) {
           });
         }
         const summary = await executeEmbedHistory(sessionId);
+        const completedCoverage = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
+        completedDrainWithWork = completedCoverage.session.total - completedCoverage.session.embedded <= 0;
         if (!isTuiConnected(sessionId)) {
           await sendIgnoredMessage(deps.client, sessionId, summary, {
             ...notifyParams
@@ -33789,6 +34180,9 @@ function createMagicContextHook(deps) {
         }
       } catch (error) {
         log("[magic-context] auto-embed drain failed:", error);
+      } finally {
+        if (!completedDrainWithWork)
+          autoEmbedAttemptedBySession.delete(sessionId);
       }
     })();
   };
@@ -33878,6 +34272,10 @@ function createMagicContextHook(deps) {
       action,
       content,
       surfaceCondition,
+      compiledProvider,
+      compiledConfig,
+      compiledAt,
+      compileStatus,
       filter,
       limit,
       offset,
@@ -33903,6 +34301,22 @@ function createMagicContextHook(deps) {
         }
       });
       await syncModuleNotes();
+      if (compileStatus && !moduleNoteResponseIsError(response)) {
+        const moduleRowId = action === "write" ? moduleNoteRowId(response) : noteId ?? null;
+        if (moduleRowId === null || !applyMirroredNoteCompileFields({
+          db,
+          moduleProject: memoryProject,
+          moduleRowId,
+          fields: {
+            compiledProvider: compiledProvider ?? null,
+            compiledConfig: compiledConfig ?? null,
+            compiledAt: compiledAt ?? null,
+            compileStatus
+          }
+        })) {
+          throw new Error("Rust note was written but its host compilation metadata could not be mirrored");
+        }
+      }
       return response;
     },
     memory: async ({
@@ -34130,6 +34544,7 @@ function createMagicContextHook(deps) {
       }),
       userMemoryCollectionEnabled: userMemoryCollectionEnabled(dreaming),
       language: deps.config.language,
+      retinaHandoff: deps.config.smart_notes?.retina_handoff === true,
       transformMode: deps.config.transform_mode,
       moduleClient: rustModeModuleClient,
       onProgress: (progress, completedTask) => {
@@ -34215,6 +34630,7 @@ function createMagicContextHook(deps) {
           language: deps.config.language,
           mural: deps.config.mural,
           memoryInjectionBudgetTokens: deps.config.memory?.injection_budget_tokens,
+          retinaHandoff: deps.config.smart_notes?.retina_handoff === true,
           transformMode: deps.config.transform_mode,
           moduleClient: rustModeModuleClient,
           onProgress: (progress, completedTask) => {
@@ -34443,6 +34859,8 @@ function createMessagesTransformHandler(args) {
       await magicContext?.["experimental.chat.messages.transform"]?.(input, output);
       return output.messages;
     } catch (error) {
+      if (error instanceof RawFallbackContextLimitError)
+        throw error;
       if (error instanceof EmergencyFailClosedError || isFailClosedBlockingError(error)) {
         if (!args.compactionOff)
           throw error;
@@ -35182,7 +35600,7 @@ function registerRpcHandlers(rpcServer, args) {
     }
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens: deriveHistorianChunkTokens2, resolveHistorianContextLimit: resolveHistorianContextLimit2 } = await import("./derive-budgets-9crp0cvd.js");
+    const { deriveHistorianChunkTokens: deriveHistorianChunkTokens2, resolveHistorianContextLimit: resolveHistorianContextLimit2 } = await import("./derive-budgets-88mxk2w1.js");
     const { resolveFallbackChain: resolveFallbackChain2 } = await import("./resolve-fallbacks-5n5tvge1.js");
     const { userMemoryCollectionEnabled: userMemoryCollectionEnabled2 } = await import("./task-config-gbp7r23g.js");
     const DEFAULT_HISTORIAN_TIMEOUT_MS2 = 600000;
@@ -35209,8 +35627,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-29f4rqax.js");
-    const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-sr5g06hz.js");
+    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-a0g9b52q.js");
+    const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-bgtf4853.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
     runManagedRecomp2(ctx, sessionId).then((message) => {
@@ -35225,8 +35643,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-29f4rqax.js");
-    const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-sr5g06hz.js");
+    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-a0g9b52q.js");
+    const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-bgtf4853.js");
     log(`[rpc] session-upgrade requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
     runManagedUpgrade2(ctx, sessionId).then((message) => {
@@ -35242,7 +35660,7 @@ function registerRpcHandlers(rpcServer, args) {
     if (!db)
       return { ok: false, error: "db unavailable" };
     try {
-      const { updateSessionMeta: updateSessionMeta2 } = await import("./storage-meta-session-ev8b55a9.js");
+      const { updateSessionMeta: updateSessionMeta2 } = await import("./storage-meta-session-df9tstzr.js");
       updateSessionMeta2(db, sessionId, { upgradeRemindedAt: Date.now() });
       return { ok: true };
     } catch (error) {
@@ -36198,6 +36616,496 @@ Smart notes: pass surface_condition and the note stays hidden until a background
 Example: ctx_note(action="write", content="Re-run the perf benchmark once the boundary rework ships", surface_condition="When the latest release tag is >= v0.23.0")`;
 // src/tools/ctx-note/tools.ts
 import { tool as tool3 } from "@opencode-ai/plugin";
+
+// src/features/magic-context/smart-notes/condition-compiler.ts
+import { existsSync as existsSync11 } from "node:fs";
+import { isAbsolute as isAbsolute4 } from "node:path";
+
+// ../retina-local-fs/src/path-fence.ts
+import { lstat as lstat2, readlink, realpath as realpath2 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { basename, dirname as dirname4, isAbsolute as isAbsolute3, join as join6, relative, resolve as resolve3, sep } from "node:path";
+
+// ../retina-local-fs/src/errors.ts
+class ProviderError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ProviderError";
+  }
+}
+
+// ../retina-local-fs/src/path-fence.ts
+async function resolveAndFenceProviderPath(configuredPath, options) {
+  const { home, dataDirectory } = await resolveFenceRoots(options);
+  const expanded = configuredPath.startsWith("~/") ? join6(home, configuredPath.slice(2)) : configuredPath === "~" ? home : configuredPath;
+  const absolute = isAbsolute3(expanded) ? resolve3(expanded) : resolve3(options.cwd ?? process.cwd(), expanded);
+  const canonical = await canonicalPath(absolute, options.allowMissing);
+  if (isFencedPath(canonical, home, dataDirectory)) {
+    throw new ProviderError("fenced_path", `Refusing fenced path: ${canonical}`);
+  }
+  return canonical;
+}
+async function resolveFenceRoots(options) {
+  const configuredHomePath = resolve3(options.homeDirectory ?? process.env.HOME ?? homedir4());
+  let home;
+  try {
+    home = await realpath2(configuredHomePath);
+  } catch (error) {
+    throw fsError(configuredHomePath, error);
+  }
+  const configuredDataDirectory = resolve3(options.dataDirectory ?? process.env.XDG_DATA_HOME ?? join6(home, ".local", "share"));
+  const dataDirectory = await canonicalPath(configuredDataDirectory, true);
+  return { home, dataDirectory };
+}
+async function canonicalPath(path6, allowMissing) {
+  try {
+    return await realpath2(path6);
+  } catch (error) {
+    if (!allowMissing || !isMissingError(error)) {
+      throw fsError(path6, error);
+    }
+    const suffix = [];
+    let candidate = path6;
+    while (true) {
+      try {
+        const metadata = await lstat2(candidate);
+        if (metadata.isSymbolicLink()) {
+          const target = await readlink(candidate);
+          const resolvedTarget = resolve3(dirname4(candidate), target);
+          return canonicalPath(join6(resolvedTarget, ...suffix), true);
+        }
+      } catch (candidateError) {
+        if (!isMissingError(candidateError)) {
+          throw fsError(path6, candidateError);
+        }
+      }
+      const parent = dirname4(candidate);
+      if (parent === candidate) {
+        throw fsError(path6, error);
+      }
+      suffix.unshift(basename(candidate));
+      candidate = parent;
+      try {
+        return join6(await realpath2(candidate), ...suffix);
+      } catch (parentError) {
+        if (!isMissingError(parentError)) {
+          throw fsError(path6, parentError);
+        }
+      }
+    }
+  }
+}
+function isFencedPath(canonicalPath2, homeDirectory, dataDirectory = process.env.XDG_DATA_HOME ?? join6(resolve3(homeDirectory), ".local", "share")) {
+  const cortexkitRoot = join6(resolve3(dataDirectory), "cortexkit");
+  const relativeToCortexkit = relative(cortexkitRoot, canonicalPath2);
+  const insideCortexkit = relativeToCortexkit !== "" && relativeToCortexkit !== ".." && !relativeToCortexkit.startsWith(`..${sep}`) && !isAbsolute3(relativeToCortexkit);
+  const parts = insideCortexkit ? relativeToCortexkit.split(sep) : [];
+  const pathParts = canonicalPath2.split(sep).filter(Boolean);
+  const name = basename(canonicalPath2);
+  const catalogDirectoryCarveIn = pathParts.includes("catalog");
+  const moduleBinCarveIn = parts.length >= 2 && parts[1] === "bin";
+  const catalogJsonCarveIn = name.endsWith(".json") && name.includes("catalog");
+  const rootWithoutCarveIns = insideCortexkit && (parts[0] === "run" || parts[0] === "magic-context");
+  if (!rootWithoutCarveIns && (catalogDirectoryCarveIn || moduleBinCarveIn || catalogJsonCarveIn)) {
+    return false;
+  }
+  const inFencedRoot = insideCortexkit && ["plexus", "claustrum", "staging", "run", "magic-context"].includes(parts[0] ?? "");
+  const fencedBasename = name.includes("binding-key") || name.endsWith(".handle");
+  const plexusStore = insideCortexkit && parts[0] === "plexus" && name.startsWith("store.db");
+  return inFencedRoot || fencedBasename || plexusStore;
+}
+function fsError(path6, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return new ProviderError("unreadable_path", `Could not read ${path6}: ${message}`);
+}
+function isMissingError(error) {
+  return error !== null && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+
+// ../retina-local-fs/src/provider.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var execFileAsync3 = promisify3(execFile3);
+function parseSemver(value) {
+  const match = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value);
+  if (!match) {
+    throw new ProviderError("invalid_config", `Invalid semantic version: ${value}`);
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".").map((part) => /^\d+$/.test(part) ? Number(part) : part) : []
+  };
+}
+function validateProviderConfig(input) {
+  try {
+    return { success: true, config: parseConfig(input) };
+  } catch (error) {
+    return {
+      success: false,
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function parseConfig(value) {
+  const config = requireObject(value, "config");
+  if ("any" in config) {
+    requireOnlyKeys(config, ["any"], "compound config");
+    if (!Array.isArray(config.any) || config.any.length < 1 || config.any.length > 4) {
+      invalid("config.any must contain between 1 and 4 predicates");
+    }
+    return { any: config.any.map(parseAtomicPredicate) };
+  }
+  return parseAtomicPredicate(config);
+}
+function parseAtomicPredicate(value) {
+  const predicate = requireObject(value, "predicate");
+  if (typeof predicate.kind !== "string") {
+    invalid("predicate.kind must be a string");
+  }
+  switch (predicate.kind) {
+    case "file_contains":
+      requireOnlyKeys(predicate, ["kind", "path", "needle", "absent", "resolved_path_exists"], predicate.kind);
+      return {
+        kind: predicate.kind,
+        path: requireString(predicate.path, "path"),
+        needle: requireString(predicate.needle, "needle", true),
+        ...optionalBoolean(predicate.absent, "absent") === undefined ? {} : { absent: predicate.absent },
+        ...predicateAudit(predicate)
+      };
+    case "path_exists":
+      requireOnlyKeys(predicate, ["kind", "path", "gone", "resolved_path_exists"], predicate.kind);
+      return {
+        kind: predicate.kind,
+        path: requireString(predicate.path, "path"),
+        ...optionalBoolean(predicate.gone, "gone") === undefined ? {} : { gone: predicate.gone },
+        ...predicateAudit(predicate)
+      };
+    case "mtime_after":
+      requireOnlyKeys(predicate, ["kind", "path", "since_ms", "resolved_path_exists"], predicate.kind);
+      return {
+        kind: predicate.kind,
+        path: requireString(predicate.path, "path"),
+        since_ms: requireFiniteNumber(predicate.since_ms, "since_ms"),
+        ...predicateAudit(predicate)
+      };
+    case "git_commit_after":
+      requireOnlyKeys(predicate, ["kind", "repo_path", "ref", "sha", "resolved_path_exists"], predicate.kind);
+      return {
+        kind: predicate.kind,
+        repo_path: requireString(predicate.repo_path, "repo_path"),
+        sha: requireString(predicate.sha, "sha"),
+        ...predicate.ref === undefined ? {} : { ref: requireString(predicate.ref, "ref") },
+        ...predicateAudit(predicate)
+      };
+    case "git_tag_matching": {
+      requireOnlyKeys(predicate, ["kind", "repo_path", "pattern", "above", "resolved_path_exists"], predicate.kind);
+      const above = predicate.above === undefined ? undefined : requireString(predicate.above, "above");
+      if (above !== undefined) {
+        parseSemver(above);
+      }
+      return {
+        kind: predicate.kind,
+        repo_path: requireString(predicate.repo_path, "repo_path"),
+        pattern: requireString(predicate.pattern, "pattern"),
+        ...above === undefined ? {} : { above },
+        ...predicateAudit(predicate)
+      };
+    }
+    default:
+      invalid(`Unsupported predicate kind: ${predicate.kind}`);
+  }
+}
+function requireObject(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    invalid(`${field} must be an object`);
+  }
+  return value;
+}
+function requireOnlyKeys(value, allowed, field) {
+  const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (unknown.length > 0) {
+    invalid(`${field} contains unknown field(s): ${unknown.join(", ")}`);
+  }
+}
+function requireString(value, field, allowEmpty = false) {
+  if (typeof value !== "string" || !allowEmpty && value.length === 0) {
+    invalid(`${field} must be ${allowEmpty ? "a string" : "a non-empty string"}`);
+  }
+  return value;
+}
+function predicateAudit(predicate) {
+  const exists = optionalBoolean(predicate.resolved_path_exists, "resolved_path_exists");
+  return exists === undefined ? {} : { resolved_path_exists: exists };
+}
+function optionalBoolean(value, field) {
+  if (value !== undefined && typeof value !== "boolean") {
+    invalid(`${field} must be a boolean`);
+  }
+  return value;
+}
+function requireFiniteNumber(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    invalid(`${field} must be a finite number`);
+  }
+  return value;
+}
+function invalid(message) {
+  throw new ProviderError("invalid_config", message);
+}
+
+// src/features/magic-context/smart-notes/condition-compiler.ts
+var RETINA_LOCAL_FS_PROVIDER = "local-fs";
+var VALUE = String.raw`(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+)`;
+async function compileSurfaceCondition(surfaceCondition, options) {
+  const plainReason = unsafeGrammarReason(surfaceCondition);
+  if (plainReason)
+    return { status: "plain", reason: plainReason };
+  const parsed = parseCondition(surfaceCondition, options.projectPath);
+  if (parsed === null)
+    return { status: "plain" };
+  const now = (options.now ?? Date.now)();
+  const resolvePath = options.resolvePath ?? (async (path6) => {
+    const resolved = await resolveAndFenceProviderPath(path6, {
+      allowMissing: true,
+      homeDirectory: options.homeDirectory,
+      cwd: options.projectPath
+    });
+    return { path: resolved, exists: existsSync11(resolved) };
+  });
+  let predicates;
+  try {
+    predicates = [];
+    for (const predicate of parsed) {
+      predicates.push(await resolvePredicate(predicate, resolvePath, now));
+    }
+  } catch (error) {
+    const code = error !== null && typeof error === "object" && "code" in error ? error.code : undefined;
+    return {
+      status: "refused",
+      reason: code === "fenced_path" ? "fenced path" : "path resolution failed"
+    };
+  }
+  const candidate = predicates.length === 1 ? predicates[0] : { any: predicates };
+  const validation = validateProviderConfig(candidate);
+  if (!validation.success) {
+    return {
+      status: "refused",
+      reason: `provider schema: ${singleLine(validation.reason)}`.slice(0, 180)
+    };
+  }
+  return {
+    status: "compiled",
+    provider: RETINA_LOCAL_FS_PROVIDER,
+    config: validation.config,
+    compiledAt: now
+  };
+}
+function conditionCompileStorageFields(result) {
+  if (result.status === "compiled") {
+    return {
+      compiledProvider: result.provider,
+      compiledConfig: JSON.stringify(result.config),
+      compiledAt: result.compiledAt,
+      compileStatus: result.status
+    };
+  }
+  return {
+    compiledProvider: null,
+    compiledConfig: null,
+    compiledAt: null,
+    compileStatus: result.status
+  };
+}
+function conditionCompileReplySuffix(result) {
+  if (result.status === "compiled") {
+    return `
+- Retina provider: ${result.provider}`;
+  }
+  if (result.status === "refused") {
+    return `
+- Retina compile refused: ${result.reason}`;
+  }
+  return "";
+}
+function parseCondition(surfaceCondition, projectPath) {
+  const trimmed = surfaceCondition.trim();
+  const either = trimmed.match(/^either\s+(.+)$/i);
+  if (!either) {
+    const predicate = parseAtomicCondition(trimmed, projectPath);
+    return predicate ? [predicate] : null;
+  }
+  const clauses = splitOrClauses(either[1]);
+  if (clauses.length < 2)
+    return null;
+  const predicates = clauses.map((clause) => parseAtomicCondition(clause, projectPath));
+  return predicates.every((predicate) => predicate !== null) ? predicates : null;
+}
+function parseAtomicCondition(text, projectPath) {
+  const fileContains = text.match(new RegExp(`^(?:when\\s+)?file\\s+(${VALUE})\\s+(no longer contains|contains)\\s+(${VALUE})$`, "i"));
+  if (fileContains) {
+    const path6 = unquote(fileContains[1]);
+    const needle = unquote(fileContains[3].trim());
+    if (path6 === null || needle === null)
+      return null;
+    return {
+      kind: "file_contains",
+      path: path6,
+      needle,
+      ...fileContains[2].toLowerCase() === "no longer contains" ? { absent: true } : {}
+    };
+  }
+  const commit = text.match(new RegExp(`^(?:when\\s+)?(?:repo(?:sitory)?\\s+)?(${VALUE})\\s+has\\s+a\\s+commit\\s+(?:after|newer than)\\s+([0-9a-f]{7,64})$`, "i"));
+  if (commit) {
+    const repoPath = unquote(commit[1]);
+    if (repoPath === null)
+      return null;
+    return {
+      kind: "git_commit_after",
+      repo_path: repoPath,
+      sha: commit[2]
+    };
+  }
+  const tag = text.match(new RegExp(`^(?:when\\s+)?a\\s+tag\\s+(?:(?:matching\\s+(${VALUE})(?:\\s+above\\s+semver\\s+(${VALUE}))?)|(?:above\\s+semver\\s+(${VALUE})))\\s+appears(?:\\s+in\\s+(?:repo(?:sitory)?\\s+)?(${VALUE}))?$`, "i"));
+  if (tag) {
+    const pattern = tag[1] ? unquote(tag[1]) : "*";
+    const above = unquote(tag[2] ?? tag[3] ?? "");
+    const repoPath = tag[4] ? unquote(tag[4]) : projectPath;
+    if (pattern === null || above === null || repoPath === null)
+      return null;
+    return {
+      kind: "git_tag_matching",
+      repo_path: repoPath,
+      pattern,
+      ...above.length > 0 ? { above } : {}
+    };
+  }
+  const mtime = text.match(new RegExp(`^(?:when\\s+)?(?:file\\s+)?(${VALUE})\\s+(changes|is rebuilt|mtime moves)$`, "i"));
+  if (mtime) {
+    const path6 = unquote(mtime[1]);
+    if (path6 === null)
+      return null;
+    return {
+      kind: "mtime_after",
+      path: path6
+    };
+  }
+  const pathExists = text.match(new RegExp(`^(?:when\\s+)?(?:path\\s+)?(${VALUE})\\s+(exists|is gone)$`, "i"));
+  if (pathExists) {
+    const path6 = unquote(pathExists[1]);
+    if (path6 === null)
+      return null;
+    return {
+      kind: "path_exists",
+      path: path6,
+      ...pathExists[2].toLowerCase() === "is gone" ? { gone: true } : {}
+    };
+  }
+  return null;
+}
+async function resolvePredicate(predicate, resolvePath, now) {
+  const configuredPath = "repo_path" in predicate ? predicate.repo_path : predicate.path;
+  const resolved = await resolvePath(configuredPath);
+  const sourceIsResolvable = isAbsolute4(configuredPath) || configuredPath === "~" || configuredPath.startsWith("~/");
+  const audit = sourceIsResolvable && resolved.exists ? {} : { resolved_path_exists: false };
+  switch (predicate.kind) {
+    case "file_contains":
+      return { ...predicate, path: resolved.path, ...audit };
+    case "path_exists":
+      return { ...predicate, path: resolved.path, ...audit };
+    case "mtime_after":
+      return { kind: predicate.kind, path: resolved.path, since_ms: now, ...audit };
+    case "git_commit_after":
+      return { ...predicate, repo_path: resolved.path, ...audit };
+    case "git_tag_matching":
+      return { ...predicate, repo_path: resolved.path, ...audit };
+  }
+}
+function splitOrClauses(text) {
+  const clauses = [];
+  let start = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = 0;index < text.length; index += 1) {
+    const character = text[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (quote && character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = quote === character ? null : quote === null ? character : quote;
+      continue;
+    }
+    if (quote !== null)
+      continue;
+    const separator = text.slice(index).match(/^\s+or\s+/i);
+    if (!separator)
+      continue;
+    clauses.push(text.slice(start, index).trim());
+    index += separator[0].length - 1;
+    start = index + 1;
+  }
+  clauses.push(text.slice(start).trim());
+  return clauses.filter(Boolean);
+}
+function unsafeGrammarReason(value) {
+  let quote = null;
+  let escaped = false;
+  for (const character of value) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (quote && character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = quote === character ? null : quote === null ? character : quote;
+    }
+  }
+  if (quote !== null)
+    return "unbalanced quote; leaving condition dreamer-evaluated";
+  if (/\bcontains\s+no(?:\s|$)/i.test(value)) {
+    return "ambiguous negation after contains; leaving condition dreamer-evaluated";
+  }
+  const temporalSuffix = new RegExp(`\\bcontains\\s+${VALUE}\\s+(?:since|until|after|before|when|while|for|as\\s+of)\\b`, "i");
+  if (temporalSuffix.test(value)) {
+    return "temporal suffix after contains; leaving condition dreamer-evaluated";
+  }
+  return null;
+}
+function unquote(value) {
+  const quote = value[0];
+  const final = value.at(-1);
+  const startsQuoted = quote === '"' || quote === "'";
+  const endsQuoted = final === '"' || final === "'";
+  if (!startsQuoted && !endsQuoted)
+    return value;
+  if (!startsQuoted || final !== quote || value.length < 2)
+    return null;
+  if (quote === '"') {
+    try {
+      const parsed = JSON.parse(value);
+      return typeof parsed === "string" ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  return value.slice(1, -1).replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+}
+function singleLine(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+// src/tools/ctx-note/tools.ts
 function captureAnchorOrdinal(db, sessionId) {
   try {
     const ordinal = getLastIndexedOrdinal(db, sessionId);
@@ -36377,8 +37285,15 @@ function createCtxNoteTool(deps) {
         if (!rustNote || !projectIdentity) {
           return "Error: Rust notes authority is active, but this module transport does not support ctx_note.";
         }
-        if (action === "write" && args.surface_condition?.trim() && deps.rustToolBackends?.noteEvaluationAvailable?.(projectIdentity) !== true) {
-          return "Error: Smart-note evaluation is unavailable for this Rust-authority project; the note was not written.";
+        const surfaceCondition = args.surface_condition?.trim();
+        let compilation;
+        if ((action === "write" || action === "update") && surfaceCondition) {
+          if (deps.rustToolBackends?.noteEvaluationAvailable?.(projectIdentity) !== true) {
+            return "Error: Smart-note evaluation is unavailable for this Rust-authority project; the note was not written.";
+          }
+          compilation = await compileSurfaceCondition(surfaceCondition, {
+            projectPath: toolContext.directory
+          });
         }
         const commandId = toolCallIdFromContext(toolContext);
         const request2 = {
@@ -36389,7 +37304,8 @@ function createCtxNoteTool(deps) {
           memoryProject: projectIdentity,
           action,
           content: args.content,
-          surfaceCondition: args.surface_condition,
+          surfaceCondition,
+          ...compilation ? conditionCompileStorageFields(compilation) : {},
           filter: args.filter,
           limit: args.limit,
           offset: args.offset,
@@ -36397,9 +37313,13 @@ function createCtxNoteTool(deps) {
         };
         try {
           const text = moduleNoteText(await rustNote(request2));
-          if (text !== null)
-            return text;
-          return "Error: Rust module returned an invalid ctx_note response.";
+          if (text === null) {
+            return "Error: Rust module returned an invalid ctx_note response.";
+          }
+          if (compilation && !text.startsWith("Error:")) {
+            return text + conditionCompileReplySuffix(compilation);
+          }
+          return text;
         } catch (error) {
           if (isRustAuthorityDrainingError(error)) {
             return "Error: Rust notes authority is not ready; TypeScript fallback is disabled.";
@@ -36423,16 +37343,21 @@ function createCtxNoteTool(deps) {
           if (!projectIdentity) {
             return "Error: Could not resolve project identity for smart note.";
           }
+          const surfaceCondition = args.surface_condition.trim();
+          const compilation = await compileSurfaceCondition(surfaceCondition, {
+            projectPath: toolContext.directory
+          });
           const note2 = addNote(deps.db, "smart", {
             content,
             projectPath: projectIdentity,
             sessionId,
-            surfaceCondition: args.surface_condition.trim(),
-            anchorOrdinal
+            surfaceCondition,
+            anchorOrdinal,
+            ...conditionCompileStorageFields(compilation)
           });
           return `Created smart note #${note2.id}. Dreamer will evaluate the condition during nightly runs:
 - Content: ${content}
-- Condition: ${args.surface_condition.trim()}`;
+- Condition: ${surfaceCondition}${conditionCompileReplySuffix(compilation)}`;
         }
         const note = addNote(deps.db, "session", { sessionId, content, anchorOrdinal });
         return `Saved session note #${note.id}.`;
@@ -36459,8 +37384,15 @@ function createCtxNoteTool(deps) {
         const updates = {};
         if (args.content?.trim())
           updates.content = args.content.trim();
-        if (args.surface_condition?.trim())
-          updates.surfaceCondition = args.surface_condition.trim();
+        let compilation;
+        if (args.surface_condition?.trim()) {
+          const surfaceCondition = args.surface_condition.trim();
+          updates.surfaceCondition = surfaceCondition;
+          compilation = await compileSurfaceCondition(surfaceCondition, {
+            projectPath: toolContext.directory
+          });
+          Object.assign(updates, conditionCompileStorageFields(compilation));
+        }
         if (!updates.content && !updates.surfaceCondition) {
           return "Error: Provide 'content' and/or 'surface_condition' to update.";
         }
@@ -36481,7 +37413,7 @@ function createCtxNoteTool(deps) {
           parts.push(`Condition: ${updates.surfaceCondition}`);
         return `Updated note #${noteId}:
 ${parts.join(`
-`)}`;
+`)}${compilation ? conditionCompileReplySuffix(compilation) : ""}`;
       }
       const limit = typeof args.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : DEFAULT_READ_LIMIT;
       const offset = typeof args.offset === "number" && args.offset > 0 ? Math.floor(args.offset) : 0;
@@ -37050,7 +37982,7 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+import { dirname as dirname5 } from "node:path";
 var MAX_BODY_BYTES = 1048576;
 var WS_AUTH_TIMEOUT_MS = 5000;
 var WS_CLOSE_UNAUTHORIZED = 4401;
@@ -37124,7 +38056,7 @@ class MagicContextRpcServer {
     this.port = server.port ?? 0;
     try {
       this.warnIfOtherLiveInstance();
-      const dir = dirname4(this.portFilePath);
+      const dir = dirname5(this.portFilePath);
       const enforcePrivatePermissions = shouldEnforcePrivateStoragePermissions();
       if (enforcePrivatePermissions) {
         mkdirSync2(dir, { recursive: true, mode: 448 });
@@ -37357,7 +38289,7 @@ var server = async (ctx) => {
 `);
     setTimeout(async () => {
       try {
-        const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-sr5g06hz.js");
+        const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-bgtf4853.js");
         const clientWithSessions = ctx.client;
         const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
         const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -37501,6 +38433,7 @@ var server = async (ctx) => {
         memoryEnabled: pluginConfig.memory?.enabled === true,
         memoryInjectionBudgetTokens: pluginConfig.memory?.injection_budget_tokens,
         mural: pluginConfig.mural,
+        retinaHandoff: pluginConfig.smart_notes.retina_handoff,
         gitCommitIndexing: pluginConfig.memory.git_commit_indexing?.enabled ? {
           enabled: true,
           since_days: pluginConfig.memory.git_commit_indexing.since_days,
@@ -37538,7 +38471,7 @@ var server = async (ctx) => {
   {
     const fence = getSchemaFenceRejection();
     if (fence) {
-      import("./conflict-warning-hook-p2pmhvn7.js").then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence));
+      import("./conflict-warning-hook-mt0ttc4x.js").then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence));
     }
   }
   if (conflictResult?.hasConflict) {
@@ -37556,10 +38489,10 @@ var server = async (ctx) => {
         ANNOUNCEMENT_FEATURES: ANNOUNCEMENT_FEATURES2,
         ANNOUNCEMENT_FOOTER: ANNOUNCEMENT_FOOTER2,
         markAnnouncementSeen: markAnnouncementSeen2
-      } = await import("./announcement-gms2nhya.js");
+      } = await import("./announcement-6c1g4es4.js");
       if (shouldShowAnnouncement2()) {
         setTimeout(() => {
-          import("./conflict-warning-hook-p2pmhvn7.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION2, ANNOUNCEMENT_FEATURES2, ANNOUNCEMENT_FOOTER2, markAnnouncementSeen2)).catch(() => {});
+          import("./conflict-warning-hook-mt0ttc4x.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION2, ANNOUNCEMENT_FEATURES2, ANNOUNCEMENT_FOOTER2, markAnnouncementSeen2)).catch(() => {});
         }, 8000);
       }
     } catch {}
@@ -37611,6 +38544,7 @@ var server = async (ctx) => {
       await magicContextRuntime.magicContext?.["command.execute.before"]?.(input, output);
     },
     "chat.message": async (input, _output) => {
+      await preloadTokenizer();
       const typed = input;
       const provId = typed.model?.providerID;
       const modId = typed.model?.modelID;
@@ -37686,14 +38620,17 @@ var server = async (ctx) => {
           historianDisallowed: pluginConfig.historian?.disallowed_tools ?? []
         });
         const agentConfig = { ...config.agent ?? {} };
+        const agentConfigRecord = agentConfig;
+        const internalAgentIds = registrations.map((registration) => registration.id);
         for (const reg of registrations) {
           if (typeof reg.prompt !== "string" || reg.prompt.length === 0) {
             log(`[magic-context] skipping hidden agent '${reg.id}' — prompt unavailable at config time (dir=${ctx.directory}); will re-register on a later complete pass`);
             continue;
           }
-          agentConfig[reg.id] = buildHiddenAgentConfig(reg.prompt, reg.allowedTools, reg.maxSteps, reg.overrides, reg.id, reg.lockPermissions === true, reg.description);
+          agentConfigRecord[reg.id] = buildHiddenAgentConfig(reg.prompt, reg.allowedTools, reg.maxSteps, reg.overrides, reg.id, reg.lockPermissions === true, reg.description);
         }
-        config.agent = agentConfig;
+        const callerAgentConfig = denyTaskRoutingToCallerAgents(agentConfigRecord, internalAgentIds);
+        config.agent = callerAgentConfig;
       } catch (error) {
         const e = error;
         log(`[magic-context] config hook failed (commands/agents NOT registered; transform still active): ${e?.message ?? error}`, e?.stack ? { stackHead: e.stack.split(`