@cortexkit/opencode-magic-context 0.35.1 → 0.36.0

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,
@@ -230,6 +238,7 @@ import {
   isPidAlive,
   isProviderOverflowReconfirmed,
   lkgContentDigest,
+  lkgContentDigestFromFields,
   loadCompartmentChunkEmbeddingsForSearch,
   loadPersistedUsage,
   loadProjectCommitEmbeddings,
@@ -382,7 +391,7 @@ import {
   upsertCommits,
   verificationFileExists,
   withContentLanguageDirective
-} from "./index-fkyamz2w.js";
+} from "./index-3nfgbsp4.js";
 import {
   deriveHistorianChunkTokens,
   deriveTriggerBudget,
@@ -394,7 +403,7 @@ import {
   setOutputReserveConfig,
   setStoragePrivatePermissionEnforcement,
   shouldEnforcePrivateStoragePermissions
-} from "./index-ry8rh8cv.js";
+} from "./index-wgvxkqpx.js";
 import {
   modelBodyField,
   resolveFallbackChain
@@ -406,7 +415,7 @@ import {
   getErrorMessage,
   sendIgnoredMessage,
   sendUserPrompt
-} from "./index-h5zjfesc.js";
+} from "./index-nsx2n9eg.js";
 import {
   ToolMutationBatch,
   advanceToolReclaimWatermark,
@@ -463,7 +472,7 @@ import {
   textMentionsRecentCommit,
   updateSessionMeta,
   withRawSessionMessageCache
-} from "./index-dpdnjawy.js";
+} from "./index-z8v31d85.js";
 import {
   Database,
   closeQuietly,
@@ -472,12 +481,12 @@ import {
   isMidTurn,
   openCodeDbExists,
   withReadOnlySessionDb
-} from "./index-w0nygb4p.js";
+} from "./index-3tnkymva.js";
 import {
   cleanupConflictWarnings,
   detectConflicts,
   sendConflictWarning
-} from "./index-8aaadh98.js";
+} from "./index-37rt2bka.js";
 import {
   detectConfigFile,
   parseJsonc,
@@ -491,7 +500,7 @@ import {
   isValidSemver,
   markAnnouncementSeen,
   shouldShowAnnouncement
-} from "./index-dmr999a2.js";
+} from "./index-qf20mv7e.js";
 import {
   acknowledgeNotifications,
   drainNotifications,
@@ -499,17 +508,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 +8379,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 [];
@@ -11523,6 +11575,7 @@ 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 SERIAL_LANE_MAX_WAITERS = 16;
 var SERIAL_LANE_MIN_REMAINING_MS = 25;
 var CANONICAL_ROOT_CACHE_MAX_ENTRIES = 256;
@@ -11558,15 +11611,21 @@ 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);
+  });
 }
 
 class SubcModuleTransport {
@@ -11584,7 +11643,20 @@ class SubcModuleTransport {
   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 +11666,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,11 +11676,31 @@ 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;
   }
+  laneTimeoutError() {
+    return this.deadlineError("while queued");
+  }
+  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);
+    }
+  }
   laneRelease() {
     let released = false;
     return () => {
@@ -11684,8 +11778,9 @@ class SubcModuleTransport {
     });
   }
   async call(args) {
-    const deadlineMs = Date.now() + (args.timeoutMs ?? this.requestTimeoutMs);
-    const releaseLane = await this.acquireCorrectnessLane(args.sessionId, args.signal, deadlineMs);
+    const attemptTimeoutMs = args.timeoutMs ?? (args.method === "transform" ? Math.min(this.requestTimeoutMs, TRANSFORM_SEND_TIMEOUT_MS) : this.requestTimeoutMs);
+    const laneDeadlineMs = Date.now() + attemptTimeoutMs;
+    const releaseLane = await this.acquireCorrectnessLane(args.sessionId, args.signal, laneDeadlineMs);
     const onAbort = () => this.invalidateConnection();
     args.signal?.addEventListener("abort", onAbort, { once: true });
     try {
@@ -11695,21 +11790,18 @@ class SubcModuleTransport {
           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);
           if (args.signal?.aborted) {
             throw args.signal.reason ?? new Error("module transport call aborted");
           }
-          return await ensuredRoute.client.request(ensuredRoute.route, args.body, {
+          return 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");
         } catch (error) {
-          const staleOrDeadRoute = isStaleOrDeadRouteFailure(error);
-          if (staleOrDeadRoute) {
+          if (isConnectionFailure(error)) {
             if (ensuredRoute) {
               this.dropRoute(ensuredRoute.routeKey, ensuredRoute.route);
               this.invalidateConnection(ensuredRoute.client);
@@ -11718,8 +11810,6 @@ class SubcModuleTransport {
             }
             if (attempt === 0 && !args.signal?.aborted)
               continue;
-          } else if (isConnectionFailure(error)) {
-            this.invalidateConnection(ensuredRoute?.client);
           }
           throw error;
         }
@@ -11821,7 +11911,7 @@ class SubcModuleTransport {
       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();
@@ -11838,7 +11928,7 @@ class SubcModuleTransport {
       harness: getHarness(),
       session: `${this.routeSessionPrefix}${sessionId}`
     };
-    const route = await client.routeOpen(target, identity);
+    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;
@@ -11915,6 +12005,7 @@ class SubcModuleTransport {
     if (client && this.client && client !== this.client)
       return;
     this.connectionGeneration += 1;
+    this.invalidateStateSyncCapabilities();
     this.client = null;
     this.routes.clear();
     client?.close();
@@ -15068,16 +15159,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 +15264,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 +15394,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 };
@@ -15327,7 +15419,7 @@ async function evaluateSmartNotes(args) {
   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 +15440,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 +15450,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 +15465,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 +15475,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;
@@ -17917,7 +18010,8 @@ function createDreamTaskExecutor(deps) {
           leaseKey,
           deadline,
           model: config.model,
-          fallbackModels: config.fallbackModels
+          fallbackModels: config.fallbackModels,
+          retinaHandoff: deps.retinaHandoff
         });
         recordRun("completed", null, {
           smartNotesSurfaced: result.surfaced,
@@ -19133,6 +19227,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 +19271,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}`);
@@ -25051,7 +25147,7 @@ function readAuthoritySeqMismatch(error) {
 async function syncModuleState(args) {
   let force = args.force;
   const adoption = args.options?.authoritySeqAdoption ?? { used: false };
-  let stateSyncDeltas = args.options?.stateSyncDeltas;
+  let stateSyncDeltas = args.options?.stateSyncDeltas ?? args.client.getCachedStateSyncCapabilities?.()?.state_sync_deltas;
   if (stateSyncDeltas === undefined && args.client.stateSyncCapabilities) {
     try {
       stateSyncDeltas = (await args.client.stateSyncCapabilities({
@@ -25110,6 +25206,20 @@ async function syncModuleState(args) {
   }
 }
 
+// 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";
+  }
+}
+
 // src/hooks/magic-context/todo-view.ts
 import { createHash as createHash11 } from "node:crypto";
 var TODO_STATUS_PENDING = "pending";
@@ -29321,34 +29431,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 +29459,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 +29472,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 = [];
@@ -29587,7 +29689,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);
   }
@@ -29901,6 +30006,7 @@ function buildTransformBody(args) {
 function createRustModeTransform(deps, options) {
   const states = new Map;
   const wireCaches = new Map;
+  const scheduleLkgCapture = options.scheduleLkgCapture ?? ((capture) => setImmediate(capture));
   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 +30125,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 +30226,30 @@ 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) {
+        try {
+          const estimate = estimateFinalWireInputTokens({
+            messages,
+            systemPromptTokens: sessionMeta.systemPromptTokens,
+            providerID: model?.providerID,
+            modelID: model?.modelID,
+            agentName: deps.getNotificationParams?.(sessionId)?.agent
+          });
+          if (estimate.tokens > contextLimit) {
+            sessionLog(sessionId, `raw_fallback_over_context_limit estimated=${estimate.tokens} limit=${contextLimit}`);
+            throw new RawFallbackContextLimitError(estimate.tokens, contextLimit, {
+              cause
+            });
+          }
+        } catch (error) {
+          if (error instanceof RawFallbackContextLimitError)
+            throw error;
+        }
+      }
+      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 +30280,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 +30306,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;
@@ -30306,10 +30471,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 +30601,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 +30755,43 @@ 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");
+        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);
@@ -30700,13 +30898,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;
     }
@@ -34130,6 +34334,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 +34420,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 +34649,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 +35390,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 +35417,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-7wbbvf87.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 +35433,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-7wbbvf87.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 +35450,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-kh5egr11.js");
       updateSessionMeta2(db, sessionId, { upgradeRemindedAt: Date.now() });
       return { ok: true };
     } catch (error) {
@@ -36198,6 +36406,447 @@ 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 configuredHomePath = resolve3(options.homeDirectory ?? process.env.HOME ?? homedir4());
+  let home;
+  try {
+    home = await realpath2(configuredHomePath);
+  } catch (error) {
+    throw fsError(configuredHomePath, error);
+  }
+  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)) {
+    throw new ProviderError("fenced_path", `Refusing fenced path: ${canonical}`);
+  }
+  return canonical;
+}
+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) {
+  const home = resolve3(homeDirectory);
+  const cortexkitRoot = join6(home, ".local", "share", "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");
+  if (catalogDirectoryCarveIn || moduleBinCarveIn || catalogJsonCarveIn) {
+    return false;
+  }
+  const inFencedRoot = insideCortexkit && ["plexus", "claustrum", "staging"].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 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+(.+)$`, "i"));
+  if (fileContains) {
+    const needle = unquote(fileContains[3].trim());
+    if (needle === null)
+      return null;
+    return {
+      kind: "file_contains",
+      path: unquote(fileContains[1]) ?? fileContains[1],
+      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) {
+    return {
+      kind: "git_commit_after",
+      repo_path: unquote(commit[1]) ?? commit[1],
+      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) {
+    return {
+      kind: "mtime_after",
+      path: unquote(mtime[1]) ?? mtime[1]
+    };
+  }
+  const pathExists = text.match(new RegExp(`^(?:when\\s+)?(?:path\\s+)?(${VALUE})\\s+(exists|is gone)$`, "i"));
+  if (pathExists) {
+    return {
+      kind: "path_exists",
+      path: unquote(pathExists[1]) ?? pathExists[1],
+      ...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 unquote(value) {
+  if (value.length < 2)
+    return value;
+  const quote = value[0];
+  if (quote !== '"' && quote !== "'" || value.at(-1) !== quote)
+    return value;
+  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);
@@ -36423,16 +37072,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 +37113,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 +37142,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 +37711,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 +37785,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 +38018,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 +38162,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 +38200,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-dw9fs934.js").then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence));
     }
   }
   if (conflictResult?.hasConflict) {
@@ -37556,10 +38218,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-dw9fs934.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION2, ANNOUNCEMENT_FEATURES2, ANNOUNCEMENT_FOOTER2, markAnnouncementSeen2)).catch(() => {});
         }, 8000);
       }
     } catch {}
@@ -37686,14 +38348,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(`