@cortexkit/opencode-magic-context 0.34.1 → 0.35.0

package/dist/index.js

@@ -85,11 +85,15 @@ import {
   computeNormalizedHash,
   computeWorkspaceEpochFingerprint,
   contentSha256,
+  cortexKitProjectConfigBasePath,
+  cortexKitUserConfigBasePath,
   cosineSimilarity,
   countEmbeddedCommits,
   countPrimerCandidatesForProject,
   createChildSessionWithFence,
   createPrimer,
+  createPromptSurfaceGuidanceEpochCache,
+  createPromptSurfaceRuntime,
   deleteTagsByMessageId,
   deleteUserMemoryCandidates,
   deriveTagLoadFloor,
@@ -111,7 +115,6 @@ import {
   ensureContextStoreUuid,
   ensureMemoryEmbeddings,
   escalationBands,
-  estimateTrueRawMessageTokens,
   expandWorkspaceIdentitySetWithAliases,
   exports_external,
   extractLatestAssistantText,
@@ -138,6 +141,7 @@ import {
   getDroppedTagsBySession,
   getEmbeddingCoverageStatus,
   getEmergencyInputSample,
+  getEmergencyRecoveryArmedAt,
   getHistorianFailureState,
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
@@ -219,7 +223,6 @@ import {
   insertUserMemoryCandidates,
   invalidateMemory,
   invalidateProject,
-  invalidateTrueRawTokenCache,
   isConsumerReconnectTransient,
   isDatabasePersisted,
   isEmbeddingEnabled,
@@ -240,6 +243,7 @@ import {
   markProjectLoadUntrusted,
   memoryNeedsCue,
   mergeMemoryStats,
+  migrateMagicContextConfigLocations,
   mustMaterialize,
   nextDueAtMs,
   nextOccurrence,
@@ -261,6 +265,7 @@ import {
   prepareCompartmentInjection,
   primerOccurrenceKey,
   primerOccurrenceUtcDay,
+  promptSurfaceHashMaterial,
   promptSyncWithValidatedOutputRetry,
   pruneAutoSearchHintDecisions,
   pruneExpiredUserMemoryCandidates,
@@ -279,6 +284,7 @@ import {
   recordHighPressureNoEligibleHead,
   recordMemoryMapping,
   recordMemoryVerifications,
+  recordMuralCueRejection,
   recordOverflowDetected,
   recordSessionProjectIdentity,
   recordToolDefinition,
@@ -307,10 +313,14 @@ import {
   resetProtectedTailNoEligibleHead,
   resolveCompactionModeRecord,
   resolveGitTopLevel,
+  resolveLegacyConfigSources,
+  resolveLegacyConfigSourcesForHarness,
+  resolveModelConfigOrDefault,
   resolveOpenCodeProtectedTailBoundary,
   resolveProjectIdentity,
   resolveProjectIdentityForSession,
   resolveProjectIdentityStrict,
+  resolvePromptSurface,
   resolveStoredPathWorkspaceIdentity,
   resolveWorkspaceIdentitySet,
   resolveWorkspaceShareCategories,
@@ -372,7 +382,7 @@ import {
   upsertCommits,
   verificationFileExists,
   withContentLanguageDirective
-} from "./index-x8spt5wy.js";
+} from "./index-4anesz49.js";
 import {
   deriveHistorianChunkTokens,
   deriveTriggerBudget,
@@ -409,6 +419,7 @@ import {
   createToolDropTarget,
   deleteIndexedMessage,
   estimateTokens,
+  estimateTrueRawMessageTokens,
   extractInMemoryMessageViews,
   extractTexts,
   extractToolCallObservation,
@@ -422,6 +433,7 @@ import {
   hasMeaningfulUserText,
   indexMessagesAfterOrdinal,
   indexSingleMessage,
+  invalidateTrueRawTokenCache,
   isEditTool,
   isFilePart,
   isMessageIndexReconciledThrough,
@@ -451,7 +463,7 @@ import {
   textMentionsRecentCommit,
   updateSessionMeta,
   withRawSessionMessageCache
-} from "./index-b563sga5.js";
+} from "./index-h8mk7vpa.js";
 import {
   Database,
   closeQuietly,
@@ -463,12 +475,14 @@ import {
 } from "./index-fcyvznch.js";
 import {
   cleanupConflictWarnings,
-  detectConfigFile,
   detectConflicts,
+  sendConflictWarning
+} from "./index-8aaadh98.js";
+import {
+  detectConfigFile,
   parseJsonc,
-  sendConflictWarning,
   stripJsonComments
-} from "./index-dtas91s5.js";
+} from "./index-0c9dmw9m.js";
 import {
   ANNOUNCEMENT_FEATURES,
   ANNOUNCEMENT_FOOTER,
@@ -8188,10 +8202,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join2 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
+  var join = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join2(comment, inside, gap);
+    return join(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -8213,13 +8227,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join2(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join2(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -8240,13 +8254,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join2(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join2(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -8514,7 +8528,7 @@ function buildHiddenAgentConfig(prompt, allowedTools, maxSteps, overrides, agent
 }
 
 // src/config/index.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 
 // src/config/agent-disable.ts
 var COMPACTION_ENABLED_PATH = `compaction${"."}enabled`;
@@ -8576,384 +8590,6 @@ function migrateLegacyAgentEnabledInMemory(rawConfig, warnings) {
   return patched;
 }
 
-// src/config/migrate-config-location.ts
-import {
-  closeSync,
-  existsSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  statSync,
-  unlinkSync,
-  writeFileSync
-} from "node:fs";
-import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join } from "node:path";
-var CONFIG_FILE_BASENAME = "magic-context";
-var MOVED_MARKER_SUFFIX = ".MOVED_READPLEASE";
-function homeDir() {
-  if (process.platform === "win32") {
-    return process.env.USERPROFILE || process.env.HOME || homedir();
-  }
-  return process.env.HOME || homedir();
-}
-function configHome() {
-  const xdg = process.env.XDG_CONFIG_HOME;
-  if (xdg && isAbsolute(xdg))
-    return xdg;
-  return join(homeDir(), ".config");
-}
-function cortexKitUserConfigBasePath() {
-  return join(configHome(), "cortexkit", CONFIG_FILE_BASENAME);
-}
-function cortexKitProjectConfigBasePath(directory) {
-  return join(directory, ".cortexkit", CONFIG_FILE_BASENAME);
-}
-function resolveCortexKitUserConfigPath() {
-  return `${cortexKitUserConfigBasePath()}.jsonc`;
-}
-function resolveCortexKitProjectConfigPath(directory) {
-  return `${cortexKitProjectConfigBasePath(directory)}.jsonc`;
-}
-function legacySourcesForBase(basePath, label) {
-  return [
-    { path: `${basePath}.jsonc`, label: `${label} magic-context.jsonc` },
-    { path: `${basePath}.json`, label: `${label} magic-context.json` }
-  ];
-}
-function userScopeConfigPaths() {
-  return new Set([
-    `${cortexKitUserConfigBasePath()}.jsonc`,
-    `${cortexKitUserConfigBasePath()}.json`,
-    join(configHome(), "opencode", `${CONFIG_FILE_BASENAME}.jsonc`),
-    join(configHome(), "opencode", `${CONFIG_FILE_BASENAME}.json`),
-    join(homeDir(), ".pi", "agent", `${CONFIG_FILE_BASENAME}.jsonc`),
-    join(homeDir(), ".pi", "agent", `${CONFIG_FILE_BASENAME}.json`)
-  ]);
-}
-function resolveLegacyConfigSources(directory) {
-  const userPaths = userScopeConfigPaths();
-  return {
-    user: [
-      ...legacySourcesForBase(join(configHome(), "opencode", CONFIG_FILE_BASENAME), "OpenCode user"),
-      ...legacySourcesForBase(join(homeDir(), ".pi", "agent", CONFIG_FILE_BASENAME), "Pi user")
-    ],
-    project: [
-      ...legacySourcesForBase(join(directory, CONFIG_FILE_BASENAME), "project root"),
-      ...legacySourcesForBase(join(directory, ".opencode", CONFIG_FILE_BASENAME), "OpenCode project"),
-      ...legacySourcesForBase(join(directory, ".pi", CONFIG_FILE_BASENAME), "Pi project")
-    ].filter((source) => !userPaths.has(source.path))
-  };
-}
-function resolveLegacyConfigSourcesForHarness(directory, harness) {
-  if (harness === "pi") {
-    return {
-      user: legacySourcesForBase(join(homeDir(), ".pi", "agent", CONFIG_FILE_BASENAME), "Pi user"),
-      project: legacySourcesForBase(join(directory, ".pi", CONFIG_FILE_BASENAME), "Pi project")
-    };
-  }
-  return {
-    user: legacySourcesForBase(join(configHome(), "opencode", CONFIG_FILE_BASENAME), "OpenCode user"),
-    project: [
-      ...legacySourcesForBase(join(directory, CONFIG_FILE_BASENAME), "project root"),
-      ...legacySourcesForBase(join(directory, ".opencode", CONFIG_FILE_BASENAME), "OpenCode project")
-    ]
-  };
-}
-function stripJsoncForParse(input) {
-  let out = "";
-  let inString = false;
-  let escaped = false;
-  for (let i = 0;i < input.length; i++) {
-    const ch = input[i];
-    const next = input[i + 1];
-    if (inString) {
-      out += ch;
-      if (escaped)
-        escaped = false;
-      else if (ch === "\\")
-        escaped = true;
-      else if (ch === '"')
-        inString = false;
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-      out += ch;
-      continue;
-    }
-    if (ch === "/" && next === "/") {
-      while (i < input.length && input[i] !== `
-`)
-        i++;
-      out += `
-`;
-      continue;
-    }
-    if (ch === "/" && next === "*") {
-      i += 2;
-      while (i < input.length && !(input[i] === "*" && input[i + 1] === "/"))
-        i++;
-      i++;
-      out += " ";
-      continue;
-    }
-    out += ch;
-  }
-  let withoutTrailingCommas = "";
-  inString = false;
-  escaped = false;
-  for (let i = 0;i < out.length; i++) {
-    const ch = out[i];
-    if (inString) {
-      withoutTrailingCommas += ch;
-      if (escaped)
-        escaped = false;
-      else if (ch === "\\")
-        escaped = true;
-      else if (ch === '"')
-        inString = false;
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-      withoutTrailingCommas += ch;
-      continue;
-    }
-    if (ch === ",") {
-      let j = i + 1;
-      while (j < out.length && /\s/.test(out[j]))
-        j++;
-      if (out[j] === "}" || out[j] === "]")
-        continue;
-    }
-    withoutTrailingCommas += ch;
-  }
-  return withoutTrailingCommas;
-}
-function sortJson(value) {
-  if (Array.isArray(value))
-    return value.map(sortJson);
-  if (value && typeof value === "object") {
-    const sorted = {};
-    for (const key of Object.keys(value).sort()) {
-      sorted[key] = sortJson(value[key]);
-    }
-    return sorted;
-  }
-  return value;
-}
-function normalizedJsoncSemantics(content) {
-  return JSON.stringify(sortJson(JSON.parse(stripJsoncForParse(content))));
-}
-function fileSemanticsMatch(a, b) {
-  try {
-    return normalizedJsoncSemantics(a) === normalizedJsoncSemantics(b);
-  } catch {
-    return a === b;
-  }
-}
-var CONFIG_LOCK_STALE_MS = 4000;
-function acquireConfigMigrationLock(lockDir) {
-  for (let attempt = 0;attempt < 2; attempt++) {
-    try {
-      mkdirSync(lockDir, { recursive: false });
-      return () => {
-        try {
-          rmSync(lockDir, { recursive: true, force: true });
-        } catch {}
-      };
-    } catch (err) {
-      const code = err?.code;
-      if (code !== "EEXIST")
-        throw err;
-      try {
-        const ageMs = Date.now() - statSync(lockDir).mtimeMs;
-        if (ageMs > CONFIG_LOCK_STALE_MS) {
-          rmSync(lockDir, { recursive: true, force: true });
-          continue;
-        }
-      } catch {
-        continue;
-      }
-      return null;
-    }
-  }
-  return null;
-}
-function atomicCopyConfigFile(sourcePath, targetPath) {
-  mkdirSync(dirname(targetPath), { recursive: true });
-  const tmpPath = join(dirname(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
-  let fd = null;
-  try {
-    fd = openSync(tmpPath, "wx", 384);
-    writeFileSync(fd, readFileSync(sourcePath));
-    closeSync(fd);
-    fd = null;
-    renameSync(tmpPath, targetPath);
-  } catch (err) {
-    if (fd !== null) {
-      try {
-        closeSync(fd);
-      } catch {}
-    }
-    try {
-      unlinkSync(tmpPath);
-    } catch {}
-    throw err;
-  }
-}
-function atomicWriteConfigFile(targetPath, content) {
-  mkdirSync(dirname(targetPath), { recursive: true });
-  const tmpPath = join(dirname(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
-  let fd = null;
-  try {
-    fd = openSync(tmpPath, "wx", 384);
-    writeFileSync(fd, content);
-    closeSync(fd);
-    fd = null;
-    renameSync(tmpPath, targetPath);
-  } catch (err) {
-    if (fd !== null) {
-      try {
-        closeSync(fd);
-      } catch {}
-    }
-    try {
-      unlinkSync(tmpPath);
-    } catch {}
-    throw err;
-  }
-}
-function movedMarkerContent(targetPath, originalName, originalContent) {
-  const header = [
-    "// Magic Context configuration moved.",
-    "//",
-    "// Magic Context now reads its configuration from one shared CortexKit",
-    "// location instead of a per-agent path. The settings that were in this",
-    "// file have been moved to:",
-    "//",
-    `//     ${targetPath}`,
-    "//",
-    "// Edit that file to change Magic Context settings. This location is no",
-    "// longer read by Magic Context.",
-    "//",
-    `// To undo, rename this file back to "${originalName}" (and remove the`,
-    "// CortexKit copy above if you want this location to take precedence).",
-    "//",
-    "// Your original settings are preserved below for reference.",
-    "",
-    ""
-  ].join(`
-`);
-  return `${header}${originalContent}`;
-}
-function markLegacySourcesMovedAside(sources, targetPath, logger) {
-  const warnings = [];
-  const info = logger?.info ?? logger?.log;
-  for (const source of sources) {
-    const markerPath = `${source.path}${MOVED_MARKER_SUFFIX}`;
-    try {
-      const original = readFileSync(source.path, "utf-8");
-      atomicWriteConfigFile(markerPath, movedMarkerContent(targetPath, basename(source.path), original));
-      unlinkSync(source.path);
-      info?.(`Moved legacy Magic Context config ${source.path} aside to ${markerPath}; now reading ${targetPath}`);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      warnings.push(`Magic Context could not move legacy config ${source.path} aside (${msg}); it is now stale and ignored. Delete it manually — config is read from ${targetPath}.`);
-      logger?.warn?.(`Could not move legacy Magic Context config ${source.path} aside (${msg}); reading ${targetPath}`);
-    }
-  }
-  return warnings;
-}
-function visibleConfigMigrationWarning(scope, targetPath, paths, reason) {
-  const uniquePaths = [...new Set([targetPath, ...paths])];
-  return `Magic Context ${scope} config migration refused: ${reason}. ` + `Legacy and CortexKit config paths collapse to one file, but Magic Context will not overwrite or merge them automatically. ` + `Please consolidate manually into ${targetPath}. Paths: ${uniquePaths.join(" ; ")}`;
-}
-function migrateConfigFile(opts) {
-  const warnings = [];
-  const existingSources = opts.legacySources.filter((source) => existsSync(source.path));
-  const info = opts.logger?.info ?? opts.logger?.log;
-  if (existingSources.length === 0) {
-    return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
-  }
-  mkdirSync(dirname(opts.targetPath), { recursive: true });
-  const release = acquireConfigMigrationLock(`${opts.targetPath}.lock`);
-  if (!release) {
-    warnings.push(`Config migration for ${opts.scope} skipped this run (another instance is migrating); will retry on next start.`);
-    return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
-  }
-  try {
-    const sources = existingSources.map((source) => ({
-      ...source,
-      content: readFileSync(source.path, "utf-8")
-    }));
-    if (existsSync(opts.targetPath)) {
-      const targetContent = readFileSync(opts.targetPath, "utf-8");
-      const differing2 = sources.filter((source) => !fileSemanticsMatch(source.content, targetContent));
-      if (differing2.length > 0) {
-        const message = visibleConfigMigrationWarning(opts.scope, opts.targetPath, differing2.map((source) => source.path), "the CortexKit target already exists with different settings");
-        warnings.push(message);
-        opts.logger?.warn?.(message);
-        return { migrated: false, conflict: true, targetPath: opts.targetPath, warnings };
-      }
-      info?.(`Magic Context ${opts.scope} config already present at ${opts.targetPath}; legacy copies match`);
-      warnings.push(...markLegacySourcesMovedAside(sources, opts.targetPath, opts.logger));
-      return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
-    }
-    const first = sources[0];
-    const differing = sources.filter((source) => !fileSemanticsMatch(source.content, first.content));
-    if (differing.length > 0) {
-      const message = visibleConfigMigrationWarning(opts.scope, opts.targetPath, sources.map((source) => source.path), "multiple legacy sources have different settings");
-      warnings.push(message);
-      opts.logger?.warn?.(message);
-      return { migrated: false, conflict: true, targetPath: opts.targetPath, warnings };
-    }
-    atomicCopyConfigFile(first.path, opts.targetPath);
-    info?.(`Migrated Magic Context ${opts.scope} config from ${first.path} to ${opts.targetPath}`);
-    warnings.push(...markLegacySourcesMovedAside(sources, opts.targetPath, opts.logger));
-    return {
-      migrated: true,
-      conflict: false,
-      sourcePath: first.path,
-      targetPath: opts.targetPath,
-      warnings
-    };
-  } catch (err) {
-    const message = visibleConfigMigrationWarning(opts.scope, opts.targetPath, existingSources.map((source) => source.path), `migration failed (${err instanceof Error ? err.message : String(err)})`);
-    warnings.push(message);
-    opts.logger?.warn?.(message);
-    return { migrated: false, conflict: true, targetPath: opts.targetPath, warnings };
-  } finally {
-    release();
-  }
-}
-function migrateMagicContextConfigLocations(directory, logger) {
-  const warnings = [];
-  const legacy = resolveLegacyConfigSources(directory);
-  try {
-    warnings.push(...migrateConfigFile({
-      scope: "user",
-      targetPath: resolveCortexKitUserConfigPath(),
-      legacySources: legacy.user,
-      logger
-    }).warnings);
-    warnings.push(...migrateConfigFile({
-      scope: "project",
-      targetPath: resolveCortexKitProjectConfigPath(directory),
-      legacySources: legacy.project,
-      logger
-    }).warnings);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger?.warn?.(`Magic Context config-location migration error (continuing): ${msg}`);
-    warnings.push(`Magic Context config-location migration error: ${msg}`);
-  }
-  return warnings;
-}
-
 // src/config/migrate-dreamer-v2.ts
 var OLD_VERIFY_TASK = "verify";
 var OLD_CURATE_TASKS = ["consolidate", "archive-stale", "improve"];
@@ -9265,6 +8901,7 @@ function migrateLegacyExperimental(rawConfig, warnings) {
 // src/config/project-security.ts
 var HIDDEN_AGENT_KEYS = ["historian", "dreamer", "sidekick"];
 var HISTORIAN_USER_ONLY_FIELDS = ["model", "fallback_models"];
+var PROMPT_SURFACE_USER_ONLY_FIELDS = ["guidance_override_path", "tool_descriptions"];
 var AGENT_ESCALATION_FIELDS = ["prompt", "permission", "tools", "system_prompt"];
 var EMBEDDING_DESTINATION_FIELDS = ["endpoint", "provider", "fallback_provider"];
 var PERCENTAGE_THRESHOLD_REASON = "security: a repository may only raise compaction thresholds above the user's effective value; it cannot force earlier historian work or cloned-repo cost escalation.";
@@ -9400,6 +9037,19 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     delete storage.enforce_private_permissions;
     warnings.push("Ignoring storage.enforce_private_permissions from project config (security: only user-level config may opt into externally managed shared storage permissions).");
   }
+  const promptSurface = projectRaw.prompt_surface;
+  if (isPlainObject(promptSurface)) {
+    const removed = [];
+    for (const field of PROMPT_SURFACE_USER_ONLY_FIELDS) {
+      if (field in promptSurface) {
+        delete promptSurface[field];
+        removed.push(field);
+      }
+    }
+    if (removed.length > 0) {
+      warnings.push(`Ignoring prompt_surface.${removed.join("/")} from project config (security: repositories may select prompt presets but only user config may provide guidance or tool-description text).`);
+    }
+  }
   const pi = projectRaw.pi;
   if (isPlainObject(pi) && "subagent_extensions" in pi) {
     delete pi.subagent_extensions;
@@ -9647,13 +9297,13 @@ function resolveTransformMode(args) {
 }
 
 // src/config/variable.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, isAbsolute as isAbsolute2, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, resolve } from "node:path";
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
 var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function sensitiveFilePathReason(resolvedPath) {
-  const home = homedir2();
+  const home = homedir();
   const sensitiveDirs = [
     { dir: resolve(home, ".ssh"), label: "SSH keys" },
     { dir: resolve(home, ".aws"), label: "AWS credentials" },
@@ -9698,7 +9348,7 @@ function substituteConfigVariables(input) {
   if (fileMatches.length === 0) {
     return { text, warnings };
   }
-  const configDir = input.configPath ? dirname2(input.configPath) : process.cwd();
+  const configDir = input.configPath ? dirname(input.configPath) : process.cwd();
   let output = "";
   let cursor = 0;
   for (const match of fileMatches) {
@@ -9716,21 +9366,21 @@ function substituteConfigVariables(input) {
     }
     let filePath = rawPath.trim();
     if (filePath.startsWith("~/")) {
-      filePath = resolve(homedir2(), filePath.slice(2));
-    } else if (!isAbsolute2(filePath)) {
+      filePath = resolve(homedir(), filePath.slice(2));
+    } else if (!isAbsolute(filePath)) {
       filePath = resolve(configDir, filePath);
     }
     const sensitiveReason = sensitiveFilePathReason(filePath);
     if (sensitiveReason) {
       warnings.push(`${token} resolves to a sensitive path (${sensitiveReason}: ${filePath}); ` + "inlining its contents into config — make sure this is intentional.");
     }
-    if (!existsSync2(filePath)) {
+    if (!existsSync(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
     let contents;
     try {
-      contents = readFileSync2(filePath, "utf-8").trim();
+      contents = readFileSync(filePath, "utf-8").trim();
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
@@ -9750,15 +9400,15 @@ function getProjectConfigBasePath(directory) {
   return cortexKitProjectConfigBasePath(directory);
 }
 function resolveLegacyReadFallback(sources) {
-  return { source: sources.find((s) => existsSync3(s.path)) ?? null };
+  return { source: sources.find((s) => existsSync2(s.path)) ?? null };
 }
 function loadConfigFileDetailed(configPath, source) {
-  if (!existsSync3(configPath)) {
+  if (!existsSync2(configPath)) {
     return null;
   }
   let rawText;
   try {
-    rawText = readFileSync3(configPath, "utf-8");
+    rawText = readFileSync2(configPath, "utf-8");
   } catch (error) {
     return {
       config: {},
@@ -9917,9 +9567,6 @@ function parsePluginConfig(rawConfig, recoveredTopLevelKeys = []) {
     configWarnings: [...preMigrationWarnings, ...warnings]
   };
 }
-function loadPluginConfig(directory) {
-  return loadPluginConfigDetailed(directory).config;
-}
 function hasUserTierSubcConfig(config) {
   const subc = config?.subc;
   if (typeof subc !== "object" || subc === null || Array.isArray(subc))
@@ -9975,8 +9622,8 @@ function loadPluginConfigDetailed(directory) {
   const harnessLegacy = resolveLegacyConfigSourcesForHarness(directory, "opencode");
   const userLegacyFallback = userDetected.format === "none" ? resolveLegacyReadFallback(harnessLegacy.user) : { source: null };
   const projectLegacyFallback = projectDetected.format === "none" ? resolveLegacyReadFallback(harnessLegacy.project) : { source: null };
-  const legacyUserUnmigrated = userDetected.format === "none" && !userLegacyFallback.source && legacySources.user.some((source) => existsSync3(source.path));
-  const legacyProjectUnmigrated = projectDetected.format === "none" && !projectLegacyFallback.source && legacySources.project.some((source) => existsSync3(source.path));
+  const legacyUserUnmigrated = userDetected.format === "none" && !userLegacyFallback.source && legacySources.user.some((source) => existsSync2(source.path));
+  const legacyProjectUnmigrated = projectDetected.format === "none" && !projectLegacyFallback.source && legacySources.project.some((source) => existsSync2(source.path));
   const userLoaded = userDetected.format !== "none" ? loadConfigFileDetailed(userDetected.path, "user") : userLegacyFallback.source ? loadConfigFileDetailed(userLegacyFallback.source.path, "user") : null;
   const projectLoaded = projectDetected.format !== "none" ? loadConfigFileDetailed(projectDetected.path, "project") : projectLegacyFallback.source ? loadConfigFileDetailed(projectLegacyFallback.source.path, "project") : null;
   const allWarnings = [];
@@ -10048,6 +9695,7 @@ function loadPluginConfigDetailed(directory) {
   };
   return {
     config,
+    registrationPromptSurface: trustedBaseConfig.prompt_surface,
     loadOutcome: combinedOutcome({ sources, substitutionFailures, recoveredTopLevelKeys }),
     sources,
     substitutionFailures,
@@ -10096,10 +9744,10 @@ function getMagicContextBuiltinCommands(compactionEnabled = true) {
 }
 
 // src/features/magic-context/dreamer/open-opencode-db.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath();
-  if (!existsSync4(dbPath)) {
+  if (!existsSync3(dbPath)) {
     log(`[dreamer] OpenCode DB not found at ${dbPath} — skipping OpenCode history scan`);
     return null;
   }
@@ -10469,6 +10117,15 @@ function formatFailClosedBlockingProcesses(processes) {
 }
 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.",
@@ -10577,7 +10234,7 @@ function getLastHookInitFailure() {
 
 // src/features/magic-context/session-project-backfill.ts
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 var LEASE_TTL_MS = 10 * 60 * 1000;
 var SESSION_PAGE_SIZE = 100;
 var SESSION_QUERY_CHUNK_SIZE = 250;
@@ -10773,7 +10430,7 @@ async function runSessionProjectBackfill(db, source, options = {}) {
         if (!session.directory) {
           result.skippedEmptyDirectories += 1;
         } else {
-          const stillExists = existenceCache.get(session.directory) ?? existsSync5(session.directory);
+          const stillExists = existenceCache.get(session.directory) ?? existsSync4(session.directory);
           existenceCache.set(session.directory, stillExists);
           if (!stillExists) {
             result.skippedDeadDirectories += 1;
@@ -11198,45 +10855,45 @@ async function runDeferredV22Backfill(db, options = {}) {
 }
 
 // src/hooks/auto-update-checker/index.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync5, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname4, join as join4 } from "node:path";
+import { existsSync as existsSync6, mkdirSync, readFileSync as readFileSync4, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join3 } from "node:path";
 
 // src/hooks/auto-update-checker/checker.ts
 var import_comment_json = __toESM(require_src2(), 1);
 import { spawn } from "node:child_process";
 import {
   accessSync,
-  existsSync as existsSync6,
+  existsSync as existsSync5,
   constants as fsConstants,
-  readFileSync as readFileSync4,
-  renameSync as renameSync2,
-  statSync as statSync2,
-  writeFileSync as writeFileSync2
+  readFileSync as readFileSync3,
+  renameSync,
+  statSync,
+  writeFileSync
 } from "node:fs";
-import { dirname as dirname3, isAbsolute as isAbsolute3, join as join3, resolve as resolve2 } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/hooks/auto-update-checker/constants.ts
-import { homedir as homedir3, platform } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir2, platform } from "node:os";
+import { join } from "node:path";
 var PACKAGE_NAME = "@cortexkit/opencode-magic-context";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function getOpenCodeCacheRoot() {
   if (platform() === "win32") {
-    return join2(process.env.LOCALAPPDATA ?? homedir3(), "opencode");
+    return join(process.env.LOCALAPPDATA ?? homedir2(), "opencode");
   }
-  return join2(homedir3(), ".cache", "opencode");
+  return join(homedir2(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform() === "win32") {
-    return join2(process.env.APPDATA ?? join2(homedir3(), "AppData", "Roaming"), "opencode");
+    return join(process.env.APPDATA ?? join(homedir2(), "AppData", "Roaming"), "opencode");
   }
-  return join2(process.env.XDG_CONFIG_HOME ?? join2(homedir3(), ".config"), "opencode");
+  return join(process.env.XDG_CONFIG_HOME ?? join(homedir2(), ".config"), "opencode");
 }
-var CACHE_DIR = join2(getOpenCodeCacheRoot(), "packages");
-var USER_OPENCODE_CONFIG = join2(getOpenCodeConfigRoot(), "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = join2(getOpenCodeConfigRoot(), "opencode.jsonc");
+var CACHE_DIR = join(getOpenCodeCacheRoot(), "packages");
+var USER_OPENCODE_CONFIG = join(getOpenCodeConfigRoot(), "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = join(getOpenCodeConfigRoot(), "opencode.jsonc");
 
 // src/hooks/auto-update-checker/types.ts
 var NpmPackageEnvelopeSchema = exports_external.object({
@@ -11297,17 +10954,17 @@ function extractChannel(version) {
 }
 function getSurfaceConfigPaths(directory, surface) {
   const name = surface === "server" ? "opencode" : "tui";
-  const globalDir = dirname3(USER_OPENCODE_CONFIG);
+  const globalDir = dirname2(USER_OPENCODE_CONFIG);
   const dirs = [
     globalDir,
     directory,
-    join3(directory, ".opencode"),
+    join2(directory, ".opencode"),
     process.env.OPENCODE_CONFIG_DIR
   ].filter((value) => Boolean(value));
   const paths = [];
   for (const dir of dirs) {
     for (const extension of ["json", "jsonc"]) {
-      const path2 = join3(dir, `${name}.${extension}`);
+      const path2 = join2(dir, `${name}.${extension}`);
       if (!paths.includes(path2))
         paths.push(path2);
     }
@@ -11318,9 +10975,9 @@ function getWinningConfig(directory, surface) {
   let winner = null;
   for (const path2 of getSurfaceConfigPaths(directory, surface)) {
     try {
-      if (!existsSync6(path2))
+      if (!existsSync5(path2))
         continue;
-      const parsed = parseJsonConfig(readFileSync4(path2, "utf-8"));
+      const parsed = parseJsonConfig(readFileSync3(path2, "utf-8"));
       const entries = getPluginEntries(parsed);
       if (entries.some((entry) => entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))) {
         if (winner) {
@@ -11343,24 +11000,24 @@ function resolvePathPluginSpec(spec, configPath) {
       return spec.replace(/^file:\/\//, "");
     }
   }
-  if (isAbsolute3(spec) || /^[A-Za-z]:[\\/]/.test(spec))
+  if (isAbsolute2(spec) || /^[A-Za-z]:[\\/]/.test(spec))
     return spec;
-  return resolve2(dirname3(configPath), spec);
+  return resolve2(dirname2(configPath), spec);
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat = statSync2(startPath);
-    let dir = stat.isDirectory() ? startPath : dirname3(startPath);
+    const stat = statSync(startPath);
+    let dir = stat.isDirectory() ? startPath : dirname2(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join3(dir, "package.json");
-      if (existsSync6(pkgPath)) {
+      const pkgPath = join2(dir, "package.json");
+      if (existsSync5(pkgPath)) {
         try {
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(pkgPath, "utf-8")));
+          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync3(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return pkgPath;
         } catch {}
       }
-      const parent = dirname3(dir);
+      const parent = dirname2(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -11371,19 +11028,19 @@ function findPackageJsonUp(startPath) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync6(configPath))
+      if (!existsSync5(configPath))
         continue;
-      const rawConfig = parseJsonConfig(readFileSync4(configPath, "utf-8"));
+      const rawConfig = parseJsonConfig(readFileSync3(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))
           continue;
-        if (entry.startsWith("file://") || entry.startsWith(".") || isAbsolute3(entry)) {
+        if (entry.startsWith("file://") || entry.startsWith(".") || isAbsolute2(entry)) {
           const localPath = resolvePathPluginSpec(entry, configPath);
           const pkgPath = findPackageJsonUp(localPath);
           if (!pkgPath)
             continue;
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(pkgPath, "utf-8")));
+          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync3(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return localPath;
         }
@@ -11400,7 +11057,7 @@ function getLocalDevVersion(directory) {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath)
       return null;
-    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(pkgPath, "utf-8")));
+    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync3(pkgPath, "utf-8")));
     return pkg.success ? pkg.data.version ?? null : null;
   } catch {
     return null;
@@ -11408,7 +11065,7 @@ function getLocalDevVersion(directory) {
 }
 function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
   try {
-    return findPackageJsonUp(dirname3(fileURLToPath(currentModuleUrl)));
+    return findPackageJsonUp(dirname2(fileURLToPath(currentModuleUrl)));
   } catch (err) {
     warn(`[auto-update-checker] Failed to resolve runtime package path: ${String(err)}`);
     return null;
@@ -11449,7 +11106,7 @@ function preflightConfigUpdates(paths, version) {
   for (const path2 of paths) {
     try {
       accessSync(path2, fsConstants.W_OK);
-      const original = readFileSync4(path2, "utf-8");
+      const original = readFileSync3(path2, "utf-8");
       const updated = configUpdateContent(original, version);
       if (!updated)
         return null;
@@ -11463,8 +11120,8 @@ function preflightConfigUpdates(paths, version) {
 }
 function writeConfig(path2, content) {
   const tmp = `${path2}.mc-tmp-${process.pid}`;
-  writeFileSync2(tmp, content, "utf-8");
-  renameSync2(tmp, path2);
+  writeFileSync(tmp, content, "utf-8");
+  renameSync(tmp, path2);
 }
 function restoreConfigs(snapshots) {
   for (const snapshot of snapshots) {
@@ -11478,7 +11135,7 @@ function restoreConfigs(snapshots) {
 function configsHaveSpec(paths, spec) {
   return paths.every((path2) => {
     try {
-      const parsed = parseJsonConfig(readFileSync4(path2, "utf-8"));
+      const parsed = parseJsonConfig(readFileSync3(path2, "utf-8"));
       return getPluginEntries(parsed).includes(spec);
     } catch {
       return false;
@@ -11534,8 +11191,8 @@ async function preparePluginUpdate(directory, _pluginInfo, version, options = {}
     return null;
   const spec = `${PACKAGE_NAME}@${version}`;
   const globalServerPaths = [USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC];
-  const globalTuiPaths = globalServerPaths.map((path2) => join3(dirname3(path2), "tui.json"));
-  globalTuiPaths.push(...globalServerPaths.map((path2) => join3(dirname3(path2), "tui.jsonc")));
+  const globalTuiPaths = globalServerPaths.map((path2) => join2(dirname2(path2), "tui.json"));
+  globalTuiPaths.push(...globalServerPaths.map((path2) => join2(dirname2(path2), "tui.jsonc")));
   const isGlobal = globalServerPaths.includes(paths[0]) && globalTuiPaths.includes(paths[1]);
   if (isGlobal) {
     const hostResult = await runHostPluginInstall(spec, options.signal, options.timeoutMs);
@@ -11568,9 +11225,9 @@ function getCachedVersion(_spec) {
   const candidates = [getCurrentRuntimePackageJsonPath()].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
-      if (!existsSync6(packageJsonPath))
+      if (!existsSync5(packageJsonPath))
         continue;
-      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(packageJsonPath, "utf-8")));
+      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync3(packageJsonPath, "utf-8")));
       if (pkg.success && pkg.data.version) {
         if (!_spec)
           cachedPackageVersion = pkg.data.version;
@@ -11668,20 +11325,20 @@ function claimCheckSlot(storageDir, intervalMs) {
   if (!storageDir)
     return true;
   try {
-    const file = join4(storageDir, TIMESTAMP_FILENAME);
-    if (existsSync7(file)) {
+    const file = join3(storageDir, TIMESTAMP_FILENAME);
+    if (existsSync6(file)) {
       try {
-        const raw = JSON.parse(readFileSync5(file, "utf-8"));
+        const raw = JSON.parse(readFileSync4(file, "utf-8"));
         const last = typeof raw.lastCheckedMs === "number" ? raw.lastCheckedMs : 0;
         if (Number.isFinite(last) && Date.now() - last < intervalMs) {
           return false;
         }
       } catch {}
     }
-    mkdirSync2(dirname4(file), { recursive: true });
+    mkdirSync(dirname3(file), { recursive: true });
     const tmp = `${file}.tmp.${process.pid}`;
-    writeFileSync3(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
-    renameSync3(tmp, file);
+    writeFileSync2(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
+    renameSync2(tmp, file);
     return true;
   } catch (err) {
     warn2(`[auto-update-checker] Could not coordinate via timestamp file: ${String(err)}`);
@@ -11689,39 +11346,39 @@ function claimCheckSlot(storageDir, intervalMs) {
   }
 }
 function pendingMarkerPath(storageDir) {
-  return join4(storageDir ?? getOpenCodeStorageDir(), PENDING_UPDATE_FILENAME);
+  return join3(storageDir ?? getOpenCodeStorageDir(), PENDING_UPDATE_FILENAME);
 }
 function writePendingUpdateMarker(storageDir, update, version) {
   try {
-    const dir = storageDir ?? dirname4(pendingMarkerPath(storageDir));
-    mkdirSync2(dir, { recursive: true });
+    const dir = storageDir ?? dirname3(pendingMarkerPath(storageDir));
+    mkdirSync(dir, { recursive: true });
     const path2 = pendingMarkerPath(storageDir);
     const temp = `${path2}.tmp.${process.pid}`;
-    writeFileSync3(temp, `${JSON.stringify({ spec: update.spec, version, configPaths: update.configPaths, writtenAt: Date.now() }, null, 2)}
+    writeFileSync2(temp, `${JSON.stringify({ spec: update.spec, version, configPaths: update.configPaths, writtenAt: Date.now() }, null, 2)}
 `, "utf-8");
-    renameSync3(temp, path2);
+    renameSync2(temp, path2);
   } catch (err) {
     warn2(`[auto-update-checker] Could not write pending update marker: ${String(err)}`);
   }
 }
 function consumePendingUpdateMarker(storageDir, loadedVersion) {
   const path2 = pendingMarkerPath(storageDir);
-  if (!existsSync7(path2))
+  if (!existsSync6(path2))
     return;
   try {
-    const marker = JSON.parse(readFileSync5(path2, "utf-8"));
+    const marker = JSON.parse(readFileSync4(path2, "utf-8"));
     const age = Date.now() - (marker.writtenAt ?? 0);
     const olderThanLoaded = typeof marker.version === "string" && typeof loadedVersion === "string" && (compareSemverCore(marker.version, loadedVersion) ?? 0) < 0;
     if (marker.version === loadedVersion && marker.spec === `${PACKAGE_NAME}@${loadedVersion}` && Array.isArray(marker.configPaths) && marker.configPaths.length === 2) {
-      rmSync2(path2, { force: true });
+      rmSync(path2, { force: true });
       log(`[auto-update-checker] Pending update applied: ${marker.spec}`);
     } else if (age > PENDING_UPDATE_MAX_AGE_MS || olderThanLoaded) {
-      rmSync2(path2, { force: true });
+      rmSync(path2, { force: true });
       warn2("[auto-update-checker] Discarded stale or mismatched pending update marker");
     }
   } catch (err) {
     try {
-      rmSync2(path2, { force: true });
+      rmSync(path2, { force: true });
     } catch {}
     warn2(`[auto-update-checker] Discarded corrupt pending update marker: ${String(err)}`);
   }
@@ -11822,7 +11479,7 @@ function createLiveSessionState() {
 
 // src/hooks/magic-context/module-transport.ts
 import { realpathSync as realpathSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join4 } from "node:path";
 var DEFAULT_MODULE_ID = "magic-context";
 var CONNECT_BACKOFF_INITIAL_MS = 1000;
 var CONNECT_BACKOFF_MAX_MS = 30000;
@@ -11832,7 +11489,7 @@ var SERIAL_LANE_MAX_WAITERS = 16;
 var SERIAL_LANE_MIN_REMAINING_MS = 25;
 var CANONICAL_ROOT_CACHE_MAX_ENTRIES = 256;
 function getDefaultConnectionFile() {
-  return join5(getDataDir(), "cortexkit", "run", "subc-connection.json");
+  return join4(getDataDir(), "cortexkit", "run", "subc-connection.json");
 }
 function errorChainSome(error, predicate) {
   let current = error;
@@ -12100,6 +11757,14 @@ class SubcModuleTransport {
       throw new Error("mirror.pull omitted page");
     return { page: response.page };
   }
+  async deleteSession(sessionId, projectRoot) {
+    await this.call({
+      sessionId,
+      projectRoot,
+      method: "session.delete",
+      body: { method: "session.delete", v: 1, session_id: sessionId }
+    });
+  }
   closeSession(sessionId) {
     const client = this.client;
     const prefix = `${sessionId}\x00`;
@@ -12219,7 +11884,7 @@ class SubcModuleTransport {
 }
 
 // src/plugin/dream-timer.ts
-import { statSync as statSync4 } from "node:fs";
+import { statSync as statSync3 } from "node:fs";
 
 // src/features/magic-context/dreamer/storage-dream-state.ts
 var getDreamStateStatements = new WeakMap;
@@ -12847,6 +12512,7 @@ function seedTaskScheduleState(db, projectPath, task, nextDueAt, lastRunAt, sche
   db.prepare("INSERT INTO task_schedule_state (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count) VALUES (?, ?, ?, ?, ?, NULL, NULL, 0) ON CONFLICT(project_path, task) DO NOTHING").run(projectPath, task, lastRunAt, nextDueAt, schedule);
 }
 function writeTaskScheduleState(db, row) {
+  const broadCycleUpdate = row.lastBroadRunAt === undefined ? "last_broad_run_at = task_schedule_state.last_broad_run_at" : "last_broad_run_at = excluded.last_broad_run_at";
   db.prepare(`INSERT INTO task_schedule_state
            (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -12858,7 +12524,7 @@ function writeTaskScheduleState(db, row) {
            last_error           = excluded.last_error,
            retry_count          = excluded.retry_count,
            last_checked_commit  = COALESCE(excluded.last_checked_commit, task_schedule_state.last_checked_commit),
-           last_broad_run_at    = COALESCE(excluded.last_broad_run_at, task_schedule_state.last_broad_run_at),
+           ${broadCycleUpdate},
            retrospective_watermark_ms = COALESCE(excluded.retrospective_watermark_ms, task_schedule_state.retrospective_watermark_ms)`).run(row.projectPath, row.task, row.lastRunAt, row.nextDueAt, row.schedule, row.lastStatus, row.lastError, row.retryCount, row.lastCheckedCommit ?? null, row.lastBroadRunAt ?? null, row.retrospectiveWatermarkMs ?? null);
 }
 function isRetrospectiveWindowProcessed(db, projectPath, windowKey) {
@@ -12870,8 +12536,8 @@ function recordRetrospectiveWindowProcessed(db, projectPath, windowKey) {
 }
 
 // src/features/magic-context/dreamer/task-executor.ts
-import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync10 } from "node:fs";
+import { createHash as createHash8 } from "node:crypto";
+import { existsSync as existsSync9 } from "node:fs";
 
 // src/agents/dreamer.ts
 var DREAMER_AGENT = "dreamer";
@@ -12882,6 +12548,9 @@ var DREAMER_CLASSIFIER_AGENT = "dreamer-classifier";
 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";
+
 // src/features/magic-context/dreamer/manifest-parser.ts
 function extractCompleteManifestBody(text, rootName) {
   const escapedRoot = rootName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -12915,6 +12584,64 @@ function assertManifestCoversExactly(ids, expectedIds, rootName) {
   }
 }
 
+// src/features/magic-context/dreamer/module-apply.ts
+class DreamerModuleFailureError extends Error {
+  transient = true;
+  constructor(operation, cause) {
+    super(`Rust dreamer ${operation} failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.name = "DreamerModuleFailureError";
+    this.cause = cause;
+  }
+}
+async function resolveDreamerModuleRoute(args) {
+  const transport = args.transformMode === "ts" ? undefined : args.moduleClient;
+  if (!transport?.authorityStatus)
+    return;
+  const contextStoreUuid = getContextStoreUuid(args.db);
+  if (!contextStoreUuid)
+    throw new Error("Rust dreamer requires a context store identity");
+  const result = await transport.authorityStatus({
+    context_store_uuid: contextStoreUuid,
+    project: args.projectIdentity,
+    projectRoot: args.projectRoot,
+    domain: "memories"
+  });
+  if (result.authority?.state !== "MODULE")
+    return;
+  const generation = result.authority.generation;
+  if (typeof generation !== "number")
+    throw new Error("Rust authority status omitted generation");
+  return {
+    moduleClient: transport,
+    moduleSessionId: args.projectIdentity,
+    moduleProjectRoot: args.projectRoot,
+    moduleContextStoreUuid: contextStoreUuid,
+    moduleAuthorityGeneration: generation,
+    moduleCommandId: args.commandId
+  };
+}
+function getModuleMemoryIdentities(db, projectIdentity, contextIds) {
+  if (contextIds.length === 0)
+    return new Map;
+  const placeholders = contextIds.map(() => "?").join(", ");
+  const rows = db.prepare(`SELECT identity.context_row_id, identity.module_row_id, live.normalized_hash
+               FROM mirror_identity identity
+               LEFT JOIN mirror_live_memory_rows live
+                 ON live.module_project = identity.module_project
+                AND live.module_row_id = identity.module_row_id
+              WHERE identity.domain = 'memories' AND identity.module_project = ?
+                AND identity.context_row_id IN (${placeholders})`).all(projectIdentity, ...contextIds);
+  return new Map(rows.flatMap((row) => Number.isInteger(row.context_row_id) && Number.isInteger(row.module_row_id) && typeof row.normalized_hash === "string" ? [
+    [
+      row.context_row_id,
+      {
+        moduleId: row.module_row_id,
+        normalizedHash: row.normalized_hash
+      }
+    ]
+  ] : []));
+}
+
 // src/features/magic-context/mural/compress-cues-prompt.ts
 var CUE_BUDGET_HIGH = 90;
 var CUE_BUDGET_LOW = 50;
@@ -12986,7 +12713,7 @@ function hasBalancedParentheses(cue) {
   }
   return depth === 0;
 }
-function validateCue(cue, importance) {
+function validateCue(cue, importance, ownId) {
   const trimmed = cue.trim();
   if (trimmed.length === 0)
     return { reason: "empty" };
@@ -12994,8 +12721,9 @@ function validateCue(cue, importance) {
   const length = [...trimmed].length;
   if (length > budget)
     return { reason: `over-budget ${length}>${budget}` };
-  if (/#\d+/.test(trimmed))
+  if (ownId !== undefined && new RegExp(`#${ownId}\\b`).test(trimmed)) {
     return { reason: "leaked-id" };
+  }
   if (!hasBalancedParentheses(trimmed))
     return { reason: "unbalanced-parens" };
   const markers = trimmed.split("⊘").length - 1;
@@ -13011,6 +12739,7 @@ function validateCue(cue, importance) {
 // src/features/magic-context/mural/compress-cues.ts
 var COMPRESS_CUES_CHUNK_SIZE = 40;
 var CHUNK_TIMEOUT_FLOOR_MS = 240000;
+var CUE_REJECTION_LATCH_THRESHOLD = 3;
 var CONSECUTIVE_TIMEOUT_LIMIT = 2;
 function toPromptMemory(candidate) {
   const memory = candidate.memory;
@@ -13021,6 +12750,38 @@ function toPromptMemory(candidate) {
     content: memory.content
   };
 }
+function stripOwnIdToken(value, ownId) {
+  return value.replace(new RegExp(`#${ownId}\\b`, "g"), "");
+}
+function truncateCue(value, budget) {
+  const trimmed = value.trim();
+  const codepoints = [...trimmed];
+  if (codepoints.length <= budget)
+    return trimmed;
+  const prefix = codepoints.slice(0, budget).join("");
+  const boundary = prefix.search(/\s+\S*$/);
+  return (boundary > 0 ? prefix.slice(0, boundary) : prefix).trim();
+}
+function sanitizeCue(value, candidate) {
+  return truncateCue(stripOwnIdToken(value, candidate.memory.id), cueBudgetFor(candidate.memory.importance ?? 50));
+}
+function deterministicFallbackCue(candidate, lastCandidate) {
+  const importance = candidate.memory.importance ?? 50;
+  const budget = cueBudgetFor(importance);
+  const sanitizedCandidate = sanitizeCue(lastCandidate, candidate);
+  if (validateCue(sanitizedCandidate, importance, candidate.memory.id) === null) {
+    return sanitizedCandidate;
+  }
+  const sourceSlice = sanitizeCue(candidate.memory.content, candidate);
+  if (validateCue(sourceSlice, importance, candidate.memory.id) === null) {
+    return sourceSlice;
+  }
+  const grammarSafe = truncateCue(sourceSlice.replaceAll("⊘", "").replace(/[()]/g, "").replace(/\b(?:must not|never|without|instead of|exclude|excludes)\b/gi, "").replace(/\s+/g, " "), budget);
+  if (validateCue(grammarSafe, importance, candidate.memory.id) === null) {
+    return grammarSafe;
+  }
+  return "memory";
+}
 function selectCandidates(db, projectIdentity) {
   const memories = getMemoriesByProject(db, projectIdentity, ["active", "permanent"]);
   const cueState = getMuralCueState(db, memories.map((memory) => memory.id));
@@ -13152,7 +12913,7 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
         return text;
       }
     });
-    return applyCues(args, chunk, run.validated);
+    return args.moduleRoute ? await applyCuesThroughModule(args, chunk, run.validated, signal) : applyCues(args, chunk, run.validated);
   } catch (error) {
     const desc = describeError(error);
     log(`[dreamer] compress-cues chunk failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
@@ -13189,10 +12950,19 @@ function applyCues(args, chunk, manifestText) {
       const candidate = byId.get(entry.id);
       if (!candidate)
         throw new Error(`cues manifest contains unknown id ${entry.id}`);
-      const failure = validateCue(entry.cue, candidate.memory.importance ?? 50);
+      const importance = candidate.memory.importance ?? 50;
+      const failure = validateCue(entry.cue, importance, candidate.memory.id);
       if (failure) {
+        const rejectionCount = recordMuralCueRejection(args.db, args.projectIdentity, entry.id, candidate.contentHash);
+        if (rejectionCount >= CUE_REJECTION_LATCH_THRESHOLD) {
+          const fallback = deterministicFallbackCue(candidate, entry.cue);
+          setMuralCue(args.db, args.projectIdentity, entry.id, fallback, candidate.contentHash);
+          compressed += 1;
+          log(`[dreamer] compress-cues: fallback cue for memory ${entry.id} (${failure.reason}; ${rejectionCount} rejections; fallback)`);
+          continue;
+        }
         skipped += 1;
-        log(`[dreamer] compress-cues: skipped cue for memory ${entry.id} (${failure.reason})`);
+        log(`[dreamer] compress-cues: skipped cue for memory ${entry.id} (${failure.reason}; rejection ${rejectionCount}/${CUE_REJECTION_LATCH_THRESHOLD})`);
         continue;
       }
       setMuralCue(args.db, args.projectIdentity, entry.id, entry.cue.trim(), candidate.contentHash);
@@ -13201,6 +12971,111 @@ function applyCues(args, chunk, manifestText) {
   });
   return { compressed, skipped };
 }
+async function applyCuesThroughModule(args, chunk, manifestText, signal) {
+  const route = args.moduleRoute;
+  if (!route)
+    throw new Error("module cue apply called without a module route");
+  const byId = new Map(chunk.map((candidate) => [candidate.memory.id, candidate]));
+  const parsed = parseCuesManifest(manifestText);
+  assertManifestCoversExactly(parsed.map((entry) => entry.id), new Set(byId.keys()), "cues");
+  const state = getMuralCueState(args.db, chunk.map((candidate) => candidate.memory.id));
+  const identities = getModuleMemoryIdentities(args.db, args.projectIdentity, chunk.map((candidate) => candidate.memory.id));
+  const updates = [];
+  for (const entry of parsed) {
+    const candidate = byId.get(entry.id);
+    if (!candidate)
+      throw new Error(`cues manifest contains unknown id ${entry.id}`);
+    const identity = identities.get(candidate.memory.id);
+    if (!identity) {
+      throw new Error(`module mirror identity missing for memory ${candidate.memory.id}`);
+    }
+    const failure = validateCue(entry.cue, candidate.memory.importance ?? 50, candidate.memory.id);
+    if (!failure) {
+      updates.push({
+        contextId: candidate.memory.id,
+        moduleId: identity.moduleId,
+        contentHash: candidate.contentHash,
+        cue: entry.cue.trim(),
+        rejectionCount: 0,
+        kind: "compressed"
+      });
+      continue;
+    }
+    const previous = state.get(candidate.memory.id);
+    const rejectionCount = previous?.hash === candidate.contentHash ? (previous.rejectionCount ?? 0) + 1 : 1;
+    if (rejectionCount >= CUE_REJECTION_LATCH_THRESHOLD) {
+      updates.push({
+        contextId: candidate.memory.id,
+        moduleId: identity.moduleId,
+        contentHash: candidate.contentHash,
+        cue: deterministicFallbackCue(candidate, entry.cue),
+        rejectionCount: 0,
+        kind: "compressed"
+      });
+      log(`[dreamer] compress-cues: fallback cue for memory ${entry.id} (${failure.reason}; ${rejectionCount} rejections; fallback)`);
+    } else {
+      updates.push({
+        contextId: candidate.memory.id,
+        moduleId: identity.moduleId,
+        contentHash: candidate.contentHash,
+        cue: null,
+        rejectionCount,
+        kind: "skipped"
+      });
+      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)}`;
+  let response;
+  try {
+    response = await route.moduleClient.call({
+      sessionId: route.moduleSessionId,
+      projectRoot: route.moduleProjectRoot,
+      method: "memory.set_mural_cue",
+      body: {
+        name: "memory.set_mural_cue",
+        arguments: {
+          memory_project: args.projectIdentity,
+          context_store_uuid: route.moduleContextStoreUuid,
+          authority_generation: route.moduleAuthorityGeneration,
+          command_id: commandId,
+          rows: updates.map((update) => ({
+            memory_id: update.moduleId,
+            content_hash_at_prompt: update.contentHash,
+            cue: update.cue,
+            rejection_count: update.rejectionCount
+          }))
+        }
+      },
+      signal
+    });
+  } catch (error) {
+    throw new DreamerModuleFailureError("mural cue apply", error);
+  }
+  const result = response?.result ?? response;
+  if (!result || typeof result !== "object") {
+    throw new Error("module returned invalid mural cue apply result");
+  }
+  const accepted = result.accepted;
+  if (!Array.isArray(accepted) || !accepted.every((id) => Number.isInteger(id))) {
+    throw new Error("module returned no mural cue acceptance list");
+  }
+  const acceptedIds = new Set(accepted);
+  const rejected = result.rejected;
+  const rejectedReasons = new Map;
+  for (const row of Array.isArray(rejected) ? rejected : []) {
+    const reason = row && typeof row === "object" && typeof row.reason === "string" ? row.reason : "unknown";
+    rejectedReasons.set(reason, (rejectedReasons.get(reason) ?? 0) + 1);
+  }
+  if ([...rejectedReasons].some(([reason]) => reason !== "stale")) {
+    throw new Error(`module rejected mural cues (${[...rejectedReasons].map(([reason, count]) => `${reason}=${count}`).join(", ")})`);
+  }
+  return updates.reduce((counts, update) => {
+    if (acceptedIds.has(update.moduleId))
+      counts[update.kind] += 1;
+    return counts;
+  }, { compressed: 0, skipped: 0 });
+}
 
 // src/features/magic-context/user-memory/review-user-memories.ts
 async function reviewUserMemories(args) {
@@ -13410,7 +13285,7 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
 }
 
 // src/features/magic-context/dreamer/classify.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // src/plugin/rust-tool-backends.ts
 function toolCallIdFromContext(context) {
@@ -13445,7 +13320,7 @@ function isRustAuthorityDrainingError(error) {
 }
 
 // src/shared/redaction.ts
-import { homedir as homedir4, userInfo } from "node:os";
+import { homedir as homedir3, userInfo } from "node:os";
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -13494,7 +13369,7 @@ var SECRET_QUALIFIERS = new Set([
   "azure"
 ]);
 function sanitizePathString(value) {
-  const home = homedir4();
+  const home = homedir3();
   const username = userInfo().username;
   let sanitized = value;
   if (home) {
@@ -13696,64 +13571,6 @@ function parseClassifyManifest(text) {
   return out;
 }
 
-// src/features/magic-context/dreamer/module-apply.ts
-class DreamerModuleFailureError extends Error {
-  transient = true;
-  constructor(operation, cause) {
-    super(`Rust dreamer ${operation} failed: ${cause instanceof Error ? cause.message : String(cause)}`);
-    this.name = "DreamerModuleFailureError";
-    this.cause = cause;
-  }
-}
-async function resolveDreamerModuleRoute(args) {
-  const transport = args.transformMode === "ts" ? undefined : args.moduleClient;
-  if (!transport?.authorityStatus)
-    return;
-  const contextStoreUuid = getContextStoreUuid(args.db);
-  if (!contextStoreUuid)
-    throw new Error("Rust dreamer requires a context store identity");
-  const result = await transport.authorityStatus({
-    context_store_uuid: contextStoreUuid,
-    project: args.projectIdentity,
-    projectRoot: args.projectRoot,
-    domain: "memories"
-  });
-  if (result.authority?.state !== "MODULE")
-    return;
-  const generation = result.authority.generation;
-  if (typeof generation !== "number")
-    throw new Error("Rust authority status omitted generation");
-  return {
-    moduleClient: transport,
-    moduleSessionId: args.projectIdentity,
-    moduleProjectRoot: args.projectRoot,
-    moduleContextStoreUuid: contextStoreUuid,
-    moduleAuthorityGeneration: generation,
-    moduleCommandId: args.commandId
-  };
-}
-function getModuleMemoryIdentities(db, projectIdentity, contextIds) {
-  if (contextIds.length === 0)
-    return new Map;
-  const placeholders = contextIds.map(() => "?").join(", ");
-  const rows = db.prepare(`SELECT identity.context_row_id, identity.module_row_id, live.normalized_hash
-               FROM mirror_identity identity
-               LEFT JOIN mirror_live_memory_rows live
-                 ON live.module_project = identity.module_project
-                AND live.module_row_id = identity.module_row_id
-              WHERE identity.domain = 'memories' AND identity.module_project = ?
-                AND identity.context_row_id IN (${placeholders})`).all(projectIdentity, ...contextIds);
-  return new Map(rows.flatMap((row) => Number.isInteger(row.context_row_id) && Number.isInteger(row.module_row_id) && typeof row.normalized_hash === "string" ? [
-    [
-      row.context_row_id,
-      {
-        moduleId: row.module_row_id,
-        normalizedHash: row.normalized_hash
-      }
-    ]
-  ] : []));
-}
-
 // src/features/magic-context/dreamer/classify.ts
 var MIN_POOL_TO_CLASSIFY = 10;
 var FULL_POOL_CEILING = 100;
@@ -13990,7 +13807,7 @@ async function runClassifyThroughModule(args, chunk, anchors, signal) {
       v: 1,
       session_id: args.moduleSessionId,
       task: "classify",
-      command_id: `classify:${args.moduleCommandId ?? Date.now()}:${createHash2("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`,
+      command_id: `classify:${args.moduleCommandId ?? Date.now()}:${createHash3("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`,
       authority_generation: args.moduleAuthorityGeneration,
       payload: {
         prompt_body: prompt,
@@ -14522,21 +14339,21 @@ function isSecretDeniedPath(repoRelativePath) {
   const segments = normalized.split("/");
   if (segments.includes(".git") || segments.includes("secrets"))
     return true;
-  const basename2 = segments.at(-1) ?? "";
-  if (basename2 === ".npmrc" || basename2.startsWith(".env"))
+  const basename = segments.at(-1) ?? "";
+  if (basename === ".npmrc" || basename.startsWith(".env"))
     return true;
-  if (basename2 === ".pgpass" || basename2 === ".netrc")
+  if (basename === ".pgpass" || basename === ".netrc")
     return true;
-  if (SECRET_KEY_EXTENSIONS.some((extension) => basename2.endsWith(extension)))
+  if (SECRET_KEY_EXTENSIONS.some((extension) => basename.endsWith(extension)))
     return true;
-  if (basename2 === "id_rsa" || basename2 === "id_dsa" || basename2 === "id_ecdsa" || basename2 === "id_ed25519" || basename2.startsWith("id_")) {
+  if (basename === "id_rsa" || basename === "id_dsa" || basename === "id_ecdsa" || basename === "id_ed25519" || basename.startsWith("id_")) {
     return true;
   }
-  if (segments.includes(".aws") && basename2 === "credentials")
+  if (segments.includes(".aws") && basename === "credentials")
     return true;
-  if (basename2.endsWith(".json")) {
-    const serviceAccountJson = basename2.includes("service-account") || basename2.includes("service_account");
-    const gcloudCredentialJson = segments.includes("gcloud") && (basename2 === "application_default_credentials.json" || basename2.includes("credential") || segments.includes("legacy_credentials"));
+  if (basename.endsWith(".json")) {
+    const serviceAccountJson = basename.includes("service-account") || basename.includes("service_account");
+    const gcloudCredentialJson = segments.includes("gcloud") && (basename === "application_default_credentials.json" || basename.includes("credential") || segments.includes("legacy_credentials"));
     if (serviceAccountJson || gcloudCredentialJson)
       return true;
   }
@@ -14686,7 +14503,7 @@ function throwIfAborted2(signal) {
 }
 
 // src/features/magic-context/smart-notes/compiler.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 
 // src/features/magic-context/smart-notes/sandbox-runner.ts
 var asyncModulePromise = null;
@@ -15080,7 +14897,7 @@ function manifestAdvisoryWarnings(code, manifest) {
   return warnings;
 }
 function hashCheck(surfaceCondition, compiledCheck, manifest, checkCron) {
-  return createHash3("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
+  return createHash4("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);
@@ -15778,8 +15595,8 @@ Output exactly JSON: {"met": false}`;
 }
 
 // src/features/magic-context/dreamer/maintain-docs-protected-enforcement.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join5 } from "node:path";
 
 // src/features/magic-context/dreamer/protected-regions.ts
 var PROTECTED_START_TOKEN = "mc:protected START";
@@ -15880,10 +15697,10 @@ var MAINTAIN_DOCS_SNAPSHOT_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function snapshotMaintainDocsFiles(docsDir) {
   const snapshot = new Map;
   for (const name of MAINTAIN_DOCS_SNAPSHOT_FILES) {
-    const path3 = join6(docsDir, name);
+    const path3 = join5(docsDir, name);
     try {
-      if (existsSync8(path3)) {
-        snapshot.set(name, readFileSync6(path3, "utf8"));
+      if (existsSync7(path3)) {
+        snapshot.set(name, readFileSync5(path3, "utf8"));
       }
     } catch {}
   }
@@ -15891,14 +15708,14 @@ function snapshotMaintainDocsFiles(docsDir) {
 }
 function enforceMaintainDocsProtectedRegions(args) {
   for (const [fileName, original] of args.snapshot) {
-    const path3 = join6(args.docsDir, fileName);
+    const path3 = join5(args.docsDir, fileName);
     try {
-      const current = readFileSync6(path3, "utf8");
+      const current = readFileSync5(path3, "utf8");
       const { text, violated } = enforceProtectedRegions(original, current);
       if (!violated) {
         continue;
       }
-      writeFileSync4(path3, text, "utf8");
+      writeFileSync3(path3, text, "utf8");
       log(`[dreamer] maintain-docs altered a protected region in ${fileName} — restored from pre-task snapshot`);
     } catch (error) {
       log(`[dreamer] maintain-docs protected-region enforcement failed for ${fileName}: ${error}`);
@@ -15907,10 +15724,10 @@ function enforceMaintainDocsProtectedRegions(args) {
 }
 
 // src/features/magic-context/dreamer/map-memories.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 
 // src/features/magic-context/dreamer/map-memories-prompt.ts
-import { existsSync as existsSync9, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync8, statSync as statSync2 } from "node:fs";
 import path3 from "node:path";
 var MAP_MEMORIES_SYSTEM_PROMPT = `You are a memory mapper for the magic-context system. You map project memories to the repository files that back them.
 
@@ -15948,7 +15765,7 @@ function extractMemoryCandidatePaths(content, repoDir) {
     if (!abs.startsWith(`${root}/`))
       continue;
     try {
-      if (existsSync9(abs) && statSync3(abs).isFile())
+      if (existsSync8(abs) && statSync2(abs).isFile())
         found.add(rel);
     } catch {}
     if (found.size >= MAX_SEED_PATHS_PER_MEMORY)
@@ -16168,7 +15985,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}:${createHash4("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash5("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -16954,6 +16771,19 @@ function countUnverifiedMappedMemories(db, projectPath) {
                 AND v.verified_at = 0`).get(projectPath);
   return row?.cnt ?? 0;
 }
+function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM memories m
+              WHERE m.project_path = ?
+                AND m.status IN ('active','permanent')
+                AND (
+                    SELECT MAX(v.verified_at)
+                      FROM memory_verifications v
+                     WHERE v.memory_id = m.id
+                       AND v.file_path <> ''
+                ) < ?`).get(projectPath, cycleStartAt);
+  return row?.cnt ?? 0;
+}
 function countCueCandidates(db, projectPath) {
   if (!hasMuralCueColumns(db))
     return countActiveMemories(db, projectPath);
@@ -17009,7 +16839,9 @@ function getDreamTaskBacklog(db, projectPath, task, options = {}) {
     }
     case "verify-broad": {
       const total = countMappedMemories(db, projectPath);
-      return { pending: total, total };
+      const cycleStartAt = getTaskScheduleState(db, projectPath, "verify-broad")?.lastBroadRunAt;
+      const pending = cycleStartAt == null ? total : countBroadCycleCandidates(db, projectPath, cycleStartAt);
+      return { pending, total };
     }
     case "curate": {
       const total = countActiveMemories(db, projectPath);
@@ -17068,7 +16900,7 @@ function evaluateTaskGate(task, ctx) {
     case "verify":
       return countActiveMemories(db, project) > 0;
     case "verify-broad":
-      return countActiveMemories(db, project) > 0;
+      return getTaskScheduleState(db, project, "verify-broad")?.lastBroadRunAt != null || countActiveMemories(db, project) > 0;
     case "curate":
       return countActiveMemories(db, project) > 0;
     case "compress-cues":
@@ -17095,13 +16927,99 @@ function evaluateTaskGate(task, ctx) {
 }
 
 // src/features/magic-context/dreamer/verify.ts
-import { createHash as createHash5 } from "node:crypto";
+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) {
   return values.reduce((acc, v) => v < acc ? v : acc, Number.POSITIVE_INFINITY);
 }
+function ensureBroadCycleStart(args) {
+  const current = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+  if (current?.lastBroadRunAt != null && current.lastBroadRunAt > 0) {
+    return current.lastBroadRunAt;
+  }
+  if (!current)
+    return args.runStartedAt;
+  if (!args.holderId || !args.leaseKey) {
+    throw new Error("verify-broad cycle opening requires the task lease");
+  }
+  return runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
+    const latest = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+    if (!latest)
+      return args.runStartedAt;
+    if (latest.lastBroadRunAt != null && latest.lastBroadRunAt > 0) {
+      return latest.lastBroadRunAt;
+    }
+    writeTaskScheduleState(args.db, {
+      ...latest,
+      lastBroadRunAt: args.runStartedAt
+    });
+    return args.runStartedAt;
+  });
+}
 async function partitionVerifyScope(args) {
   const runStartedAt = args.now ?? Date.now();
   const active = getMemoriesByProject(args.db, args.projectIdentity);
@@ -17113,6 +17031,29 @@ async function partitionVerifyScope(args) {
     content: m.content,
     mappedFiles: verById.get(m.id)?.files ?? []
   });
+  if (args.forceBroad) {
+    const broadCycleStartAt = ensureBroadCycleStart({
+      db: args.db,
+      projectIdentity: args.projectIdentity,
+      holderId: args.holderId,
+      leaseKey: args.leaseKey,
+      runStartedAt
+    });
+    const broadCandidates = candidates.filter((m) => (verById.get(m.id)?.verifiedAt ?? 0) < broadCycleStartAt).sort((a, b) => {
+      const verifiedAtA = verById.get(a.id)?.verifiedAt ?? 0;
+      const verifiedAtB = verById.get(b.id)?.verifiedAt ?? 0;
+      return verifiedAtA - verifiedAtB || a.id - b.id;
+    });
+    return {
+      runStartedAt,
+      mode: "broad",
+      inScope: broadCandidates.map(toPrompt),
+      inScopeIds: broadCandidates.map((m) => m.id),
+      skippedIds: candidates.filter((m) => !broadCandidates.some((candidate) => candidate.id === m.id)).map((m) => m.id),
+      broadCycleStartAt,
+      reason: `broad cycle (${broadCandidates.length} remain; started ${broadCycleStartAt})`
+    };
+  }
   if (candidates.length === 0) {
     return {
       runStartedAt,
@@ -17123,16 +17064,6 @@ async function partitionVerifyScope(args) {
       reason: "no file-mapped memories in scope"
     };
   }
-  if (args.forceBroad) {
-    return {
-      runStartedAt,
-      mode: "broad",
-      inScope: candidates.map(toPrompt),
-      inScopeIds: candidates.map((m) => m.id),
-      skippedIds: [],
-      reason: "broad full-pool verification of file-mapped memories"
-    };
-  }
   const allInScope = (mode, reason) => ({
     runStartedAt,
     mode,
@@ -17251,7 +17182,26 @@ function parseVerifyManifest(text) {
 
 // src/features/magic-context/dreamer/verify.ts
 var VERIFY_BATCH_SIZE = 50;
+var IDENTICAL_PROVIDER_FAILURE_BATCH_LIMIT = 2;
+function closeBroadCycle(args, cycleStartAt) {
+  if (!args.forceBroad || cycleStartAt === undefined)
+    return;
+  if (!getTaskScheduleState(args.db, args.projectIdentity, "verify-broad"))
+    return;
+  runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
+    const current = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+    if (current?.lastBroadRunAt !== cycleStartAt)
+      return;
+    if (!current)
+      return;
+    writeTaskScheduleState(args.db, {
+      ...current,
+      lastBroadRunAt: null
+    });
+  });
+}
 async function runVerify(args) {
+  const runStartedAt = Date.now();
   const result = {
     verified: 0,
     updated: 0,
@@ -17266,20 +17216,29 @@ async function runVerify(args) {
     db: args.db,
     projectIdentity: args.projectIdentity,
     projectDirectory: args.sessionDirectory,
-    forceBroad: args.forceBroad
+    forceBroad: args.forceBroad,
+    now: runStartedAt,
+    holderId: args.holderId,
+    leaseKey: args.leaseKey
   });
   result.mode = gate.mode;
+  result.broadCycleStartAt = gate.broadCycleStartAt;
   result.inScope = gate.inScope.length;
   result.remaining = gate.inScope.length;
   log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"} gate: mode=${gate.mode} in_scope=${gate.inScope.length} skipped=${gate.skippedIds.length} reason=${gate.reason}`);
-  if (gate.inScope.length === 0)
+  if (gate.inScope.length === 0) {
+    closeBroadCycle(args, gate.broadCycleStartAt);
     return result;
+  }
   const batches = [];
   for (let i = 0;i < gate.inScope.length; i += VERIFY_BATCH_SIZE) {
     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());
+  let consecutiveProviderFailures = 0;
+  let priorProviderFailureFingerprint = null;
+  let lastProviderFailure = null;
   try {
     for (let i = 0;i < batches.length; i += 1) {
       const remainingMs = Math.max(0, args.deadline - Date.now());
@@ -17294,8 +17253,28 @@ async function runVerify(args) {
       result.remaining -= counts.verified + counts.updated + counts.archived;
       result.batches += 1;
       args.onProgress?.(result.verified + result.updated + result.archived);
+      if (counts.providerFailure) {
+        lastProviderFailure = counts.providerFailure;
+        if (counts.providerFailure.fingerprint === priorProviderFailureFingerprint) {
+          consecutiveProviderFailures += 1;
+        } else {
+          priorProviderFailureFingerprint = counts.providerFailure.fingerprint;
+          consecutiveProviderFailures = 1;
+        }
+        if (consecutiveProviderFailures >= IDENTICAL_PROVIDER_FAILURE_BATCH_LIMIT) {
+          log(`[dreamer] verify run aborting after ${consecutiveProviderFailures} identical provider-failure batches`);
+          throw counts.providerFailure;
+        }
+      } else {
+        priorProviderFailureFingerprint = null;
+        consecutiveProviderFailures = 0;
+      }
     }
+    if (lastProviderFailure)
+      throw lastProviderFailure;
     result.complete = result.remaining === 0;
+    if (result.complete)
+      closeBroadCycle(args, gate.broadCycleStartAt);
     log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: verified=${result.verified} updated=${result.updated} archived=${result.archived} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}`);
     return result;
   } finally {
@@ -17350,7 +17329,14 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         const text = extractLatestAssistantText(messages);
         if (!text)
           throw new Error("verify returned no output");
-        parseVerifyManifest(text);
+        try {
+          parseVerifyManifest(text);
+        } catch (error) {
+          const providerFailure = providerOutputFailureFromInvalidManifest(messages, text);
+          if (providerFailure)
+            throw providerFailure;
+          throw error;
+        }
         return text;
       }
     });
@@ -17358,11 +17344,12 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     return await applyVerifyManifest(args, batch, run.validated);
   } catch (error) {
     const desc = describeError(error);
-    log(`[dreamer] verify batch failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
+    const providerFailure = error instanceof DreamerProviderOutputFailureError ? error : undefined;
+    log(`[dreamer] verify batch ${providerFailure ? "provider failure" : "failed"}: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
     recordInvocation4(args, startedAt, { status: "failed", error });
     if (error instanceof DreamerModuleFailureError || signal.aborted)
       throw error;
-    return { verified: 0, updated: 0, archived: 0 };
+    return { verified: 0, updated: 0, archived: 0, providerFailure };
   } finally {
     if (agentSessionId && !shouldKeepSubagents()) {
       await args.client.session.delete({
@@ -17434,7 +17421,7 @@ async function applyVerifyManifest(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}:${createHash7("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -17629,7 +17616,7 @@ function createDreamTaskExecutor(deps) {
               resultChars: 0,
               ...error ? { error } : {},
               backlog: (() => {
-                const end = getDreamTaskBacklog(db, projectIdentity, config.task);
+                const end = extra?.backlogAfter ?? getDreamTaskBacklog(db, projectIdentity, config.task);
                 const processed = processedDreamTaskItems(backlogAtStart.pending, end.pending);
                 const value = {
                   pendingAtStart: backlogAtStart.pending,
@@ -17678,12 +17665,6 @@ function createDreamTaskExecutor(deps) {
           recordRun("completed", null);
           return { status: "completed" };
         }
-        if (moduleRoute) {
-          const reason = "compress-cues parked: MODULE memory authority has no cue write facade";
-          log(`[dreamer] compress-cues: skipped (${reason})`);
-          recordRun("failed", reason);
-          return { status: "failed", transient: true, error: reason };
-        }
         const result = await runCompressCues({
           db,
           client: deps.client,
@@ -17695,6 +17676,7 @@ function createDreamTaskExecutor(deps) {
           deadline,
           model: config.model ?? deps.mural.model ?? deps.dreamerModel,
           fallbackModels: config.fallbackModels,
+          moduleRoute,
           onProgress: (processed) => reportProgress(processed)
         });
         log(`[dreamer] compress-cues: compressed=${result.compressed} skipped=${result.skipped} chunks=${result.chunks} remaining=${result.remaining}`);
@@ -17764,19 +17746,31 @@ function createDreamTaskExecutor(deps) {
           fallbackModels: config.fallbackModels,
           language: config.language ?? deps.language,
           moduleRoute,
-          onProgress: (processed) => reportProgress(processed)
+          onProgress: (processed2) => reportProgress(processed2)
         });
+        const processed = result.verified + result.updated + result.archived;
+        const broadProgress = config.task === "verify-broad" ? `verify-broad cycle ${result.broadCycleStartAt ?? "open"}: verified ${processed}, ${result.remaining} remain` : null;
+        const backlogAfter = config.task === "verify-broad" ? { pending: result.remaining, total: backlogAtStart.total } : undefined;
         if (!result.complete) {
+          if (broadProgress && processed > 0) {
+            recordRun("completed", broadProgress, {
+              memoryChanges: computeMemoryDelta(memoryBefore),
+              backlogAfter
+            });
+            return { status: "completed", error: broadProgress };
+          }
           const error = incompleteMessage(result.remaining);
           recordRun("failed", error, {
-            memoryChanges: computeMemoryDelta(memoryBefore)
+            memoryChanges: computeMemoryDelta(memoryBefore),
+            backlogAfter
           });
           return { status: "failed", transient: true, error };
         }
-        recordRun("completed", null, {
-          memoryChanges: computeMemoryDelta(memoryBefore)
+        recordRun("completed", broadProgress, {
+          memoryChanges: computeMemoryDelta(memoryBefore),
+          backlogAfter
         });
-        return { status: "completed" };
+        return broadProgress ? { status: "completed", error: broadProgress } : { status: "completed" };
       }
       if (config.task === "classify-memories") {
         let moduleArgs;
@@ -17964,7 +17958,7 @@ function parseFrictionGateVerdict(verdict) {
 }
 function computeRetrospectiveWindowKey(flagged) {
   const anchors = flagged.map((message) => `${message.sessionId}:${message.ts}`).sort().join("|");
-  return createHash6("sha256").update(anchors).digest("hex").slice(0, 32);
+  return createHash8("sha256").update(anchors).digest("hex").slice(0, 32);
 }
 function renderFrictionWindow(messages, flaggedOrdinals, radius = 2) {
   const flagged = new Set(flaggedOrdinals);
@@ -18197,8 +18191,8 @@ async function runAgenticTask(config, ctx, helpers) {
   const lastRunAt = getTaskScheduleState(db, projectIdentity, config.task)?.lastRunAt ?? null;
   const maintainDocsSnapshot = task === "maintain-docs" ? snapshotMaintainDocsFiles(docsDir) : undefined;
   const existingDocs = task === "maintain-docs" ? {
-    architecture: existsSync10(`${docsDir}/ARCHITECTURE.md`),
-    structure: existsSync10(`${docsDir}/STRUCTURE.md`)
+    architecture: existsSync9(`${docsDir}/ARCHITECTURE.md`),
+    structure: existsSync9(`${docsDir}/STRUCTURE.md`)
   } : undefined;
   const userMemories = task === "curate" ? getActiveUserMemories(db).map((um) => ({ id: um.id, content: um.content })) : undefined;
   let curateMemories;
@@ -18911,7 +18905,7 @@ var startupJitters = new Map;
 var nextStartupJitterSlot = 0;
 function directoryStillExists(directory) {
   try {
-    return statSync4(directory).isDirectory();
+    return statSync3(directory).isDirectory();
   } catch {
     return false;
   }
@@ -19234,7 +19228,7 @@ function createDreamTimerModuleClient(moduleClient) {
 }
 
 // src/plugin/embedding-bootstrap-helpers.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.api_key",
   "embedding.endpoint",
@@ -19280,7 +19274,7 @@ var EMBEDDING_WARNING_TERMS = [
 ];
 var loggedFailureSignatures = new Map;
 function sha256Prefix(value, length = 16) {
-  return createHash7("sha256").update(value).digest("hex").slice(0, length);
+  return createHash9("sha256").update(value).digest("hex").slice(0, length);
 }
 function warningLooksEmbeddingRelated(message) {
   const lower = message.toLowerCase();
@@ -19584,16 +19578,7 @@ function resolveCacheTtl(cacheTtl, modelKey) {
   if (typeof cacheTtl === "string") {
     return cacheTtl;
   }
-  if (modelKey && typeof cacheTtl[modelKey] === "string") {
-    return cacheTtl[modelKey];
-  }
-  if (modelKey) {
-    const bareModelId = modelKey.split("/").slice(1).join("/");
-    if (bareModelId && typeof cacheTtl[bareModelId] === "string") {
-      return cacheTtl[bareModelId];
-    }
-  }
-  return cacheTtl.default ?? "5m";
+  return resolveModelConfigOrDefault(cacheTtl, modelKey, cacheTtl.default ?? "5m");
 }
 var clampWarnSeen = new Set;
 function isFinitePositive(v) {
@@ -22620,7 +22605,7 @@ function replayCavemanCompression(sessionId, db, targets, tags) {
 }
 
 // src/hooks/magic-context/compaction-off-transition.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 var loggedUnverifiedMarkerCleanupRetry = false;
 var COMPACTION_OFF_FLIP_NOTICE = [
   "## Magic Context — compaction-off mode is now active",
@@ -22655,7 +22640,7 @@ function clearCachedM0Baseline(db, sessionId) {
   return (result.changes ?? 0) > 0;
 }
 function cleanupOffMarkers(sessionId) {
-  if (!existsSync11(getOpenCodeDbPath())) {
+  if (!existsSync10(getOpenCodeDbPath())) {
     return { verified: true, removedLineages: 0, removedRows: 0, retainedLineages: 0 };
   }
   return removeMcOwnedCompactionMarkers(sessionId, MARKER_SUMMARY_TEXT);
@@ -23749,7 +23734,7 @@ function createPassOutcome() {
 }
 
 // src/hooks/magic-context/rust-mode-transform.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 
 // src/hooks/magic-context/module-state-sync.ts
 import { createHmac, randomUUID as randomUUID5 } from "node:crypto";
@@ -25087,6 +25072,121 @@ async function syncModuleState(args) {
   }
 }
 
+// src/hooks/magic-context/todo-view.ts
+import { createHash as createHash11 } from "node:crypto";
+var TODO_STATUS_PENDING = "pending";
+var TODO_STATUS_IN_PROGRESS = "in_progress";
+var TODO_STATUS_COMPLETED = "completed";
+var TODO_STATUS_CANCELLED = "cancelled";
+var TODO_PRIORITY_HIGH = "high";
+var TODO_PRIORITY_MEDIUM = "medium";
+var TODO_PRIORITY_LOW = "low";
+var TODO_STATUSES = [
+  TODO_STATUS_PENDING,
+  TODO_STATUS_IN_PROGRESS,
+  TODO_STATUS_COMPLETED,
+  TODO_STATUS_CANCELLED
+];
+var TODO_PRIORITIES = [
+  TODO_PRIORITY_HIGH,
+  TODO_PRIORITY_MEDIUM,
+  TODO_PRIORITY_LOW
+];
+var TODO_STATUS_SET = new Set(TODO_STATUSES);
+var TODO_PRIORITY_SET = new Set(TODO_PRIORITIES);
+var TERMINAL_STATUSES = new Set([
+  TODO_STATUS_COMPLETED,
+  TODO_STATUS_CANCELLED
+]);
+var TITLE_DONE_STATUSES = new Set([TODO_STATUS_COMPLETED]);
+var SYNTHETIC_CALL_ID_PREFIX = "mc_synthetic_todo_";
+function normalizeTodoStateJson(todos) {
+  if (!Array.isArray(todos))
+    return null;
+  const normalized = [];
+  for (const todo of todos) {
+    if (!isTodoItem(todo))
+      return null;
+    normalized.push({
+      content: todo.content,
+      status: todo.status,
+      priority: todo.priority ?? TODO_PRIORITY_MEDIUM
+    });
+  }
+  return JSON.stringify(normalized);
+}
+function buildSyntheticTodoPart(stateJson) {
+  const todos = parseTodoState(stateJson);
+  if (todos === null || todos.length === 0)
+    return null;
+  if (todos.every((t) => TERMINAL_STATUSES.has(t.status)))
+    return null;
+  const callID = computeSyntheticCallId(stateJson);
+  const activeCount = todos.filter((t) => !TITLE_DONE_STATUSES.has(t.status)).length;
+  const output = JSON.stringify(todos, null, 2);
+  const ts = 0;
+  return {
+    type: "tool",
+    callID,
+    tool: "todowrite",
+    state: {
+      status: "completed",
+      input: { todos },
+      output,
+      title: `${activeCount} todos`,
+      metadata: { todos, truncated: false },
+      time: { start: ts, end: ts }
+    },
+    syntheticTodoMarker: true
+  };
+}
+function computeSyntheticCallId(stateJson) {
+  const hash = createHash11("sha256").update(stateJson).digest("hex").slice(0, 16);
+  return `${SYNTHETIC_CALL_ID_PREFIX}${hash}`;
+}
+function isSyntheticTodoPart(part) {
+  if (part === null || typeof part !== "object")
+    return false;
+  const p = part;
+  if (p.syntheticTodoMarker === true)
+    return true;
+  return p.type === "tool" && p.tool === "todowrite" && typeof p.callID === "string" && p.callID.startsWith(SYNTHETIC_CALL_ID_PREFIX);
+}
+function parseTodoState(stateJson) {
+  if (stateJson.length === 0)
+    return null;
+  try {
+    const parsed = JSON.parse(stateJson);
+    if (!Array.isArray(parsed))
+      return null;
+    const result = [];
+    for (const item of parsed) {
+      if (!isTodoItem(item))
+        return null;
+      result.push({
+        content: item.content,
+        status: item.status,
+        priority: item.priority ?? TODO_PRIORITY_MEDIUM
+      });
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function isTodoStatus(value) {
+  return typeof value === "string" && TODO_STATUS_SET.has(value);
+}
+function isTodoPriority(value) {
+  return typeof value === "string" && TODO_PRIORITY_SET.has(value);
+}
+function isTodoItem(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const todo = value;
+  return typeof todo.content === "string" && isTodoStatus(todo.status) && (todo.priority === undefined || isTodoPriority(todo.priority));
+}
+
 // src/hooks/magic-context/transform-context-state.ts
 function loadPersistedUsageWatermark(db, sessionId) {
   const result = db.prepare("SELECT last_response_time FROM session_meta WHERE session_id = ?").get(sessionId);
@@ -25110,7 +25210,8 @@ function loadContextUsage(contextUsageMap, db, sessionId) {
     if (persisted) {
       contextUsageMap.set(sessionId, {
         ...persisted,
-        lastResponseTime: persistedLastResponseTime ?? persisted.updatedAt
+        lastResponseTime: persistedLastResponseTime ?? persisted.updatedAt,
+        hasUsageTokens: false
       });
       return persisted.usage;
     }
@@ -25189,7 +25290,7 @@ function containsProbeVerbatim(text, probes) {
 }
 
 // src/features/magic-context/search-measurement.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function resultId(result) {
   switch (result.source) {
     case "memory":
@@ -25276,7 +25377,7 @@ async function recordShadowMeasurement(args) {
   }
 }
 function sha256(value) {
-  return createHash9("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 
 // src/features/magic-context/search.ts
@@ -27637,121 +27738,6 @@ function readFilePath(target) {
   return null;
 }
 
-// src/hooks/magic-context/todo-view.ts
-import { createHash as createHash10 } from "node:crypto";
-var TODO_STATUS_PENDING = "pending";
-var TODO_STATUS_IN_PROGRESS = "in_progress";
-var TODO_STATUS_COMPLETED = "completed";
-var TODO_STATUS_CANCELLED = "cancelled";
-var TODO_PRIORITY_HIGH = "high";
-var TODO_PRIORITY_MEDIUM = "medium";
-var TODO_PRIORITY_LOW = "low";
-var TODO_STATUSES = [
-  TODO_STATUS_PENDING,
-  TODO_STATUS_IN_PROGRESS,
-  TODO_STATUS_COMPLETED,
-  TODO_STATUS_CANCELLED
-];
-var TODO_PRIORITIES = [
-  TODO_PRIORITY_HIGH,
-  TODO_PRIORITY_MEDIUM,
-  TODO_PRIORITY_LOW
-];
-var TODO_STATUS_SET = new Set(TODO_STATUSES);
-var TODO_PRIORITY_SET = new Set(TODO_PRIORITIES);
-var TERMINAL_STATUSES = new Set([
-  TODO_STATUS_COMPLETED,
-  TODO_STATUS_CANCELLED
-]);
-var TITLE_DONE_STATUSES = new Set([TODO_STATUS_COMPLETED]);
-var SYNTHETIC_CALL_ID_PREFIX = "mc_synthetic_todo_";
-function normalizeTodoStateJson(todos) {
-  if (!Array.isArray(todos))
-    return null;
-  const normalized = [];
-  for (const todo of todos) {
-    if (!isTodoItem(todo))
-      return null;
-    normalized.push({
-      content: todo.content,
-      status: todo.status,
-      priority: todo.priority ?? TODO_PRIORITY_MEDIUM
-    });
-  }
-  return JSON.stringify(normalized);
-}
-function buildSyntheticTodoPart(stateJson) {
-  const todos = parseTodoState(stateJson);
-  if (todos === null || todos.length === 0)
-    return null;
-  if (todos.every((t) => TERMINAL_STATUSES.has(t.status)))
-    return null;
-  const callID = computeSyntheticCallId(stateJson);
-  const activeCount = todos.filter((t) => !TITLE_DONE_STATUSES.has(t.status)).length;
-  const output = JSON.stringify(todos, null, 2);
-  const ts = 0;
-  return {
-    type: "tool",
-    callID,
-    tool: "todowrite",
-    state: {
-      status: "completed",
-      input: { todos },
-      output,
-      title: `${activeCount} todos`,
-      metadata: { todos, truncated: false },
-      time: { start: ts, end: ts }
-    },
-    syntheticTodoMarker: true
-  };
-}
-function computeSyntheticCallId(stateJson) {
-  const hash = createHash10("sha256").update(stateJson).digest("hex").slice(0, 16);
-  return `${SYNTHETIC_CALL_ID_PREFIX}${hash}`;
-}
-function isSyntheticTodoPart(part) {
-  if (part === null || typeof part !== "object")
-    return false;
-  const p = part;
-  if (p.syntheticTodoMarker === true)
-    return true;
-  return p.type === "tool" && p.tool === "todowrite" && typeof p.callID === "string" && p.callID.startsWith(SYNTHETIC_CALL_ID_PREFIX);
-}
-function parseTodoState(stateJson) {
-  if (stateJson.length === 0)
-    return null;
-  try {
-    const parsed = JSON.parse(stateJson);
-    if (!Array.isArray(parsed))
-      return null;
-    const result = [];
-    for (const item of parsed) {
-      if (!isTodoItem(item))
-        return null;
-      result.push({
-        content: item.content,
-        status: item.status,
-        priority: item.priority ?? TODO_PRIORITY_MEDIUM
-      });
-    }
-    return result;
-  } catch {
-    return null;
-  }
-}
-function isTodoStatus(value) {
-  return typeof value === "string" && TODO_STATUS_SET.has(value);
-}
-function isTodoPriority(value) {
-  return typeof value === "string" && TODO_PRIORITY_SET.has(value);
-}
-function isTodoItem(value) {
-  if (value === null || typeof value !== "object")
-    return false;
-  const todo = value;
-  return typeof todo.content === "string" && isTodoStatus(todo.status) && (todo.priority === undefined || isTodoPriority(todo.priority));
-}
-
 // src/hooks/magic-context/tool-reclaim.ts
 function buildSyntheticToolReclaimOps(input) {
   const watermark = Math.max(0, input.watermark);
@@ -29265,7 +29251,9 @@ class MemoryAuthorityUnavailableError extends Error {
   }
 }
 var RUST_FAILURE_PARK_THRESHOLD = 3;
-var RUST_PROBE_INTERVAL = 5;
+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;
 function isRecord3(value) {
   return value !== null && typeof value === "object";
@@ -29426,10 +29414,10 @@ function messageCacheSignature(message) {
   const parts = Array.isArray(message.parts) ? message.parts : [];
   const serializedParts = JSON.stringify(parts) ?? "null";
   const serializedMessage = JSON.stringify(message) ?? "null";
-  return `${messageIdOf(message) ?? ""}:${parts.length}:${Buffer.byteLength(serializedParts)}:${createHash11("sha256").update(serializedMessage).digest("hex")}`;
+  return `${messageIdOf(message) ?? ""}:${parts.length}:${Buffer.byteLength(serializedParts)}:${createHash13("sha256").update(serializedMessage).digest("hex")}`;
 }
 function advanceWireFingerprint(previous, encoded) {
-  return createHash11("sha256").update(previous).update("\\0").update(JSON.stringify(encoded) ?? "null").digest("hex");
+  return createHash13("sha256").update(previous).update("\\0").update(JSON.stringify(encoded) ?? "null").digest("hex");
 }
 function buildWireFingerprint(encoded) {
   let fingerprint = "rust-wire-v1";
@@ -29467,7 +29455,8 @@ function formatRustPassLog(args) {
   const timings = args.timings ?? emptyRustPassTimings();
   const measured = timings.prefixGuard + timings.ordinalResolve + timings.stateSync + timings.clone + timings.wireBuild + timings.transport + timings.apply + timings.lkgSnapshot;
   const unattributed = Math.max(0, args.elapsedMs - measured);
-  return `rust pass: decision=${args.decision} reason=${args.reason} served_from=${args.servedFrom} in=${args.inputCount} out=${args.outputCount} applied=${args.applied} elapsed=${args.elapsedMs.toFixed(1)} ms module=${args.moduleElapsedMs.toFixed(1)} ms stages=prefix_guard:${timings.prefixGuard.toFixed(1)} ordinal_resolve:${timings.ordinalResolve.toFixed(1)} state_sync:${timings.stateSync.toFixed(1)} clone:${timings.clone.toFixed(1)} wire_build:${timings.wireBuild.toFixed(1)} wire_messages:${timings.wireMessages} transport:${timings.transport.toFixed(1)} transport_pages:${timings.transportPages} transport_bytes:${timings.transportBytes} apply:${timings.apply.toFixed(1)} lkg_snapshot:${timings.lkgSnapshot.toFixed(1)} other:${unattributed.toFixed(1)}`;
+  const rowVersion = Number.isSafeInteger(args.rowVersion) ? args.rowVersion : 0;
+  return `rust pass: decision=${args.decision} reason=${args.reason} served_from=${args.servedFrom} in=${args.inputCount} out=${args.outputCount} applied=${args.applied} row_version=${rowVersion} elapsed=${args.elapsedMs.toFixed(1)} ms module=${args.moduleElapsedMs.toFixed(1)} ms stages=prefix_guard:${timings.prefixGuard.toFixed(1)} ordinal_resolve:${timings.ordinalResolve.toFixed(1)} state_sync:${timings.stateSync.toFixed(1)} clone:${timings.clone.toFixed(1)} wire_build:${timings.wireBuild.toFixed(1)} wire_messages:${timings.wireMessages} transport:${timings.transport.toFixed(1)} transport_pages:${timings.transportPages} transport_bytes:${timings.transportBytes} apply:${timings.apply.toFixed(1)} lkg_snapshot:${timings.lkgSnapshot.toFixed(1)} other:${unattributed.toFixed(1)}`;
 }
 function isSyntheticUserMessage(message) {
   if (!message || messageInfo2(message).role !== "user" || !Array.isArray(message.parts)) {
@@ -29599,6 +29588,19 @@ function passUsage(usage, limit) {
     context_limit_tokens: limit
   };
 }
+function shouldDisarmRustEmergencyRecovery(input) {
+  if (input.finalWireEstimate?.trusted === true && input.providerProvenLimitTokens > 0 && input.finalWireEstimate.tokens < input.providerProvenLimitTokens * 0.8) {
+    return "trusted-final-wire";
+  }
+  if (!input.materialized || input.usagePercentage >= 80)
+    return null;
+  if (input.recoveryOrigin !== "provider_overflow")
+    return "fresh-usage";
+  if (input.usageEntry?.hasUsageTokens === true && (input.recoveryArmedAt === null || input.usageEntry.updatedAt > input.recoveryArmedAt)) {
+    return "fresh-usage";
+  }
+  return null;
+}
 function directiveTextOf(response) {
   const directives = isRecord3(response.host_directives) ? response.host_directives : undefined;
   const channel2 = isRecord3(directives?.channel2_nudge) ? directives.channel2_nudge : undefined;
@@ -29615,7 +29617,7 @@ function canonicalizeForChecksum(value) {
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalizeForChecksum(value[key])]));
 }
 function checksumSeedRows(rows) {
-  return createHash11("sha256").update(JSON.stringify(rows.map(canonicalizeForChecksum))).digest("hex");
+  return createHash13("sha256").update(JSON.stringify(rows.map(canonicalizeForChecksum))).digest("hex");
 }
 function authoritySeedRows(db, projectPath, domain) {
   const snapshots = domain === "memories" ? db.prepare("SELECT * FROM memories WHERE project_path = ? ORDER BY id ASC").all(projectPath) : db.prepare(`SELECT n.*
@@ -29756,6 +29758,35 @@ async function prepareRustMemoryAuthority(args) {
   state.memoryAuthorityReady = true;
   args.onProjectPrepared?.(projectPath);
 }
+var TODO_HEAD_ANCHOR_ID2 = "__magic_context_todo_head__";
+function syntheticTodoAnchorFromNative(messages) {
+  for (let index = 0;index < messages.length; index += 1) {
+    const message = messages[index];
+    if (!isRecord3(message) || !Array.isArray(message.parts))
+      continue;
+    const part = message.parts.find((candidate) => isRecord3(candidate) && candidate.syntheticTodoMarker === true);
+    if (!isRecord3(part) || typeof part.callID !== "string")
+      continue;
+    const state = isRecord3(part.state) ? part.state : undefined;
+    const input = state && isRecord3(state.input) ? state.input : undefined;
+    const stateJson = normalizeTodoStateJson(input?.todos);
+    if (stateJson === null || computeSyntheticCallId(stateJson) !== part.callID)
+      continue;
+    const previous = messages[index - 1];
+    const previousInfo = isRecord3(previous) && isRecord3(previous.info) ? previous.info : undefined;
+    const messageId2 = previousInfo && typeof previousInfo.id === "string" && previousInfo.id.length > 0 ? previousInfo.id : TODO_HEAD_ANCHOR_ID2;
+    return { callId: part.callID, messageId: messageId2, stateJson };
+  }
+  return null;
+}
+function mirrorRustSyntheticTodoAnchor(args) {
+  const anchor = syntheticTodoAnchorFromNative(args.messages);
+  if (anchor) {
+    setPersistedTodoSyntheticAnchor(args.db, args.sessionId, anchor.callId, anchor.messageId, anchor.stateJson);
+  } else if (args.cacheBustingPass) {
+    clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+  }
+}
 function applyNativeMessagesVerbatim(output, response) {
   const nativeMessages = response.native_messages;
   if (typeof nativeMessages === "string") {
@@ -29809,6 +29840,9 @@ function buildTransformBody(args) {
     model_key: args.modelKey,
     provider_id: args.providerId,
     tool_present: args.passInputs.tool_present === true,
+    prompt_surface_preset: args.passInputs.prompt_surface_preset ?? "full",
+    prompt_surface_model_key: args.passInputs.prompt_surface_model_key,
+    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,
     clear_reasoning_age: args.passInputs.clear_reasoning_age,
@@ -29855,7 +29889,7 @@ function createRustModeTransform(deps, options) {
     state.passesSincePark = 0;
     state.warningSent = true;
     const warning = "Rust Magic Context is unavailable for this session; retry after the module recovers.";
-    sessionLog(sessionId, "rust transform parked after three consecutive failures");
+    sessionLog(sessionId, `mc_rust_park_transition failure_passes=${state.consecutiveFailures} pass_count=${state.passCount} park_count=${state.parkCount}`);
     options.notifyParked?.(sessionId, warning);
   };
   const resetOrdinalMemo = (state) => {
@@ -29988,6 +30022,7 @@ function createRustModeTransform(deps, options) {
     let materializeReason = "none";
     let servedFrom = "none";
     let moduleElapsedMs = 0;
+    let rowVersion = 0;
     let appliedAt;
     let emergencyFailClosed = false;
     const passUsageSnapshot = loadContextUsage(deps.contextUsageMap, deps.db, sessionId);
@@ -30019,7 +30054,7 @@ function createRustModeTransform(deps, options) {
     } catch (error) {
       preflightError ??= error;
     }
-    emergencyFailClosed = passUsageSnapshot.percentage >= 95 && resolvedContextLimit !== undefined && resolvedContextLimit > 0;
+    emergencyFailClosed = passUsageSnapshot.percentage >= RUST_EMERGENCY_WALL_PCT && resolvedContextLimit !== undefined && resolvedContextLimit > 0;
     if (overflowState) {
       const detectedLimitMatchesModel = overflowState.detectedContextLimitModelKey === null || overflowState.detectedContextLimitModelKey === modelKey;
       const hasProviderProof = overflowState.detectedContextLimit > 0 && detectedLimitMatchesModel || isProviderOverflowReconfirmed(sessionId);
@@ -30037,6 +30072,7 @@ function createRustModeTransform(deps, options) {
         applied,
         elapsedMs,
         moduleElapsedMs,
+        rowVersion,
         timings
       }));
       if (served) {
@@ -30056,6 +30092,7 @@ function createRustModeTransform(deps, options) {
       const timings2 = isRecord3(response.timings) ? response.timings : undefined;
       const total = timings2?.total;
       moduleElapsedMs = typeof total === "number" && Number.isFinite(total) ? total : 0;
+      rowVersion = typeof response.row_version === "number" && Number.isSafeInteger(response.row_version) ? response.row_version : 0;
       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(" ");
         if (detail)
@@ -30064,7 +30101,7 @@ function createRustModeTransform(deps, options) {
     };
     if (state.parked) {
       state.passesSincePark += 1;
-      if (!emergencyFailClosed && passUsageSnapshot.percentage < 90 && state.passCount % RUST_PROBE_INTERVAL !== 0) {
+      if (!emergencyFailClosed && passUsageSnapshot.percentage < RUST_PARK_PROBE_PRESSURE_BYPASS_PCT && state.passCount % RUST_PARK_RETRY_INTERVAL !== 0) {
         decision = "parked";
         const replayed = replayLastGood(sessionId, messages, output, sessionMeta.systemPromptTokens);
         if (replayed) {
@@ -30078,6 +30115,7 @@ function createRustModeTransform(deps, options) {
       }
     }
     const reduceAvailability = resolveCtxReduceAvailability(sessionId);
+    resolveTodowriteAvailabilityFromMessages(sessionId, messages);
     const toolPresent = reduceAvailability.frozen && reduceAvailability.callable;
     try {
       if (preflightError)
@@ -30095,6 +30133,7 @@ function createRustModeTransform(deps, options) {
       const midTurn = isMidTurn(deps, sessionId);
       const requestObservedAtMs = Date.now();
       const recoveryNoHeadEscape = overflowState.needsEmergencyRecovery && loadProtectedTailMeta(deps.db, sessionId).recoveryNoEligibleHeadCount >= RECOVERY_NO_HEAD_LIMIT;
+      const promptSurface = resolvePromptSurface(deps.promptSurface, modelKey ?? undefined);
       const passInputs = {
         now_ms: requestObservedAtMs,
         model_key: modelKey,
@@ -30111,6 +30150,9 @@ function createRustModeTransform(deps, options) {
         system_prompt_hash: sessionMeta.systemPromptHash ?? "",
         upgrade_state: readUpgradeState(deps.db, sessionId),
         tool_present: toolPresent,
+        prompt_surface_preset: promptSurface.preset,
+        prompt_surface_model_key: modelKey,
+        prompt_surface_tool_descriptions: deps.promptSurface?.tool_descriptions ?? {},
         protected_tags: deps.protectedTags ?? DEFAULT_PROTECTED_TAGS,
         temporal_awareness: deps.experimentalTemporalAwareness === true,
         channel2_nudge_state: getChannel2NudgeState(deps.db, sessionId),
@@ -30337,6 +30379,7 @@ function createRustModeTransform(deps, options) {
       const pages = buildPagedModuleTransformPayloads(body);
       logStage(sessionId, "wireBuild", wireBuildStartedAt, timings, wireDelta ? `mode=tail_delta input=${encodedInput.length}` : "mode=full");
       let response;
+      let servedFinalWireEstimate;
       for (const [index, page] of pages.entries()) {
         timings.transportBytes += Buffer.byteLength(JSON.stringify(page));
         const transportStartedAt = performance.now();
@@ -30469,6 +30512,9 @@ function createRustModeTransform(deps, options) {
           });
         }
       };
+      const explicitDecision = typeof response.decision === "string" || typeof response.action === "string" || typeof response.cache_bust === "boolean";
+      const decisionUpper = decision.toUpperCase();
+      const cacheBustingPass = response.cache_bust === true || decisionUpper === "HARD" || decisionUpper === "MIGRATE_HARD" || decisionUpper === "EXECUTE" || decisionUpper === "SOFT" || !explicitDecision;
       let appliedMessages;
       const applyStartedAt = performance.now();
       try {
@@ -30484,11 +30530,25 @@ function createRustModeTransform(deps, options) {
         if (typeof boundaryId === "string" && boundaryId.length > 0) {
           assertNativeBoundary(appliedMessages, sessionId, boundaryId);
         }
+        if (!sessionMeta.isSubagent) {
+          mirrorRustSyntheticTodoAnchor({
+            db: deps.db,
+            sessionId,
+            messages: appliedMessages,
+            cacheBustingPass
+          });
+        }
+        if (passInputs.emergency_recovery_armed === true) {
+          servedFinalWireEstimate = estimateFinalWireInputTokens({
+            messages: appliedMessages,
+            systemPromptTokens: sessionMeta.systemPromptTokens,
+            providerID: model?.providerID,
+            modelID: model?.modelID,
+            agentName: deps.getNotificationParams?.(sessionId)?.agent
+          });
+        }
         logStage(sessionId, "apply", applyStartedAt, timings);
         const lkgSnapshotStartedAt = performance.now();
-        const explicitDecision = typeof response.decision === "string" || typeof response.action === "string" || typeof response.cache_bust === "boolean";
-        const decisionUpper = decision.toUpperCase();
-        const cacheBustingPass = response.cache_bust === true || decisionUpper === "HARD" || decisionUpper === "MIGRATE_HARD" || decisionUpper === "EXECUTE" || decisionUpper === "SOFT" || !explicitDecision;
         if (cacheBustingPass || !getSlot(sessionId)) {
           const captured = captureRustResponse(sessionId, messages, response);
           if (cacheBustingPass && !captured) {
@@ -30572,10 +30632,20 @@ function createRustModeTransform(deps, options) {
           sessionLog(sessionId, "rust compartment mirror-back failed (ignored):", error);
         }
       }
-      if (materializeReason !== "none" && passUsageSnapshot.percentage < 80 && getOverflowState(deps.db, sessionId).needsEmergencyRecovery) {
+      const currentOverflowState = getOverflowState(deps.db, sessionId, modelKey);
+      const disarmEvidence = currentOverflowState.needsEmergencyRecovery ? shouldDisarmRustEmergencyRecovery({
+        materialized: materializeReason !== "none",
+        usagePercentage: passUsageSnapshot.percentage,
+        recoveryOrigin: currentOverflowState.emergencyRecoveryOrigin,
+        recoveryArmedAt: getEmergencyRecoveryArmedAt(sessionId),
+        usageEntry: deps.contextUsageMap.get(sessionId),
+        finalWireEstimate: servedFinalWireEstimate,
+        providerProvenLimitTokens: currentOverflowState.detectedContextLimit
+      }) : null;
+      if (disarmEvidence) {
         try {
           clearEmergencyRecovery(deps.db, sessionId);
-          sessionLog(sessionId, `rust pass disarmed emergency recovery after ${materializeReason} at ${passUsageSnapshot.percentage.toFixed(1)}% usage`);
+          sessionLog(sessionId, `rust pass disarmed emergency recovery via ${disarmEvidence} after ${materializeReason} at ${passUsageSnapshot.percentage.toFixed(1)}% usage`);
         } catch {}
       }
       wireCaches.set(sessionId, pendingWireCache);
@@ -30586,6 +30656,7 @@ function createRustModeTransform(deps, options) {
         sessionLog(sessionId, "rust transform wire invariant failed; LKG replay required", error);
       }
       if (emergencyFailClosed) {
+        sessionLog(sessionId, "mc_rust_emergency_refusal before_lkg");
         markFailure(sessionId, state, error);
         finishPass(false, false);
         throw new EmergencyFailClosedError("Rust Magic Context was unavailable at a provider-proven context limit", { cause: error });
@@ -30605,10 +30676,17 @@ function createRustModeTransform(deps, options) {
   return {
     run,
     clearSession(sessionId) {
+      const projectRoot = states.get(sessionId)?.memoryAuthorityRoot ?? options.projectRoot ?? null;
       dropSlot(sessionId, "session-deleted");
       states.delete(sessionId);
       wireCaches.delete(sessionId);
-      options.moduleClient.closeSession?.(sessionId);
+      if (projectRoot && options.moduleClient.deleteSession) {
+        options.moduleClient.deleteSession(sessionId, projectRoot).catch((error) => {
+          sessionLog(sessionId, "rust module session deletion failed:", error);
+        }).finally(() => options.moduleClient.closeSession?.(sessionId));
+      } else {
+        options.moduleClient.closeSession?.(sessionId);
+      }
     },
     invalidateWireState,
     getState(sessionId) {
@@ -32143,7 +32221,8 @@ function createEventHandler2(deps) {
               inputTokens: totalInputTokens
             },
             updatedAt: now,
-            lastResponseTime: now
+            lastResponseTime: now,
+            hasUsageTokens: true
           });
           updates.lastContextPercentage = percentage;
           updates.lastInputTokens = totalInputTokens;
@@ -32942,7 +33021,7 @@ function createToolExecuteAfterHook(args) {
 }
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 
 // src/agents/magic-context-prompt.ts
 var LONG_TERM_PARTNER_FRAME = `### You are the user's long-term partner on this project — not a one-off hire
@@ -32958,6 +33037,10 @@ var PARTNER_FRAME_CLOSER_REDUCE = `
 Reduction prompts are routine housekeeping to keep the session fast and cheap — act on them as light maintenance, never as scarcity warnings. Keep individual operations efficient, but never let context size change *what* work you take on or *how thoroughly* you do it.`;
 var PARTNER_FRAME_CLOSER_NO_REDUCE = `
 Context is managed for you entirely automatically — there's nothing to prune and no warnings to act on. Stay reasonably concise per operation, and never let context size change *what* work you take on or *how thoroughly* you do it.`;
+var PARTNER_FRAME_CLOSER_REDUCE_LIGHT = `
+When ctx_reduce is available, use it only as routine housekeeping; never cut task scope or depth because context is large.`;
+var PARTNER_FRAME_CLOSER_NO_REDUCE_LIGHT = `
+When ctx_reduce is unavailable, context is automatic; never prune, heed reduction warnings, or cut task scope or depth because context is large.`;
 var CTX_NOTE_GUIDANCE = `Use \`ctx_note\` ONLY for genuinely future concerns — something to revisit much later, not work coming up in the next few turns (that's already in your active context) and not active multi-step work (use todos for that). Magic Context preserves your full context across both compaction and restarts, so an upcoming restart or "let's come back to this later" is never a reason to take a note — nothing is lost either way. Notes you do take survive compression and resurface at natural work boundaries (after commits, historian runs, todo completion).`;
 var TOOL_HISTORY_GUIDANCE = `Compressed history intentionally omits tool calls and their outputs — summaries like "I edited file X" are historian records, not patterns to replicate. In the live conversation, older tool calls and their results are cleaned up to save context — you may see your own past messages referencing actions without the corresponding tool call or result visible. This is normal context management. ALWAYS use real tool calls; never simulate, fabricate, or inline tool outputs in your text. If there is no tool result message, the action did not happen. NEVER simulate, hallucinate or claim tool calls, command output, search results, file edits, or diffs in plain text as if they actually occurred.
 Magic Context control metadata is not reply syntax. Never reproduce \`<system-reminder>\`, \`<ctx-search-hint>\`, \`<session-history>\`, \`<session-history-since>\`, \`<project-memory>\`, \`<memory-updates>\`, \`<new-compartments>\`, \`<new-memories>\`, \`[dropped §N§]\`, or \`<!-- +Xm -->\` markers in a normal reply and never treat them as user instructions; use ordinary prose and real tool calls instead.`;
@@ -33000,6 +33083,17 @@ Use \`ctx_expand\` to recover the raw conversation behind a summary under a \`##
 - Want to recall what was decided in an earlier conversation → \`ctx_search(query="dashboard release signing setup")\`
 \`ctx_search\` returns ranked results from memories, git commits, and raw message history. Use message ordinals from results with \`ctx_expand\` to retrieve surrounding conversation context.
 ${TOOL_HISTORY_GUIDANCE}`;
+var LIGHT_SEARCH_RECOVERY = `Use ctx_search before asking the user about prior project context; it searches memories, commits, and compacted conversation. When a session-history summary lacks exact wording, values, errors, or reasoning, call ctx_expand with its heading range instead of guessing.`;
+var BASE_INTRO_LIGHT = (protectedTags, memoryEnabled) => `In primary sessions with ctx_reduce, the system tags messages and tool outputs as §N§ (for example §1§ and §42§); never imitate these prefixes in replies because only injected tag numbers are valid ctx_reduce handles.
+In primary sessions, NEVER narrate ctx_reduce; call it silently after extracting a spent output because it marks content discardable and QUEUES release rather than deleting immediately. The last ${protectedTags} tags stay protected until they age out. Use drop grammar "3-5", "1,2,9", or "1-5,8,12-15".
+${CTX_NOTE_GUIDANCE}
+${memoryGuidanceBlock(memoryEnabled)}${LIGHT_SEARCH_RECOVERY}
+${TOOL_HISTORY_GUIDANCE}
+For primary ctx_reduce choices, NEVER blanket-drop a large range because mixed-value evidence may be lost: inspect every tag first. Drop only analyzed reads, searches, diagnostics, or build/test outputs after use. NEVER drop user directives or assistant prose unless exceptionally large; keep requirements, constraints, unresolved errors or decisions, exact wording, raw evidence, and active files or work. Only extracted pasted user payloads may go.
+Consider small targeted drops after acted-on reads or searches, completed logical steps, before context switches, and before the turn ends; this keeps the working set tidy without changing task scope.`;
+var BASE_INTRO_NO_REDUCE_LIGHT = (memoryEnabled) => `${CTX_NOTE_GUIDANCE}
+${memoryGuidanceBlock(memoryEnabled)}${LIGHT_SEARCH_RECOVERY}
+${TOOL_HISTORY_GUIDANCE}`;
 var GENERIC_SECTION = `
 ### Reduction Triggers
 - After reading files or search results you already acted on — drop raw outputs.
@@ -33016,21 +33110,27 @@ var GENERIC_SECTION = `
 - Your current task requirements and constraints.
 - Recent errors and unresolved decisions.
 - Active work context and files being edited.`;
+var SMART_NOTE_GUIDANCE_LIGHT = `
+surface_condition creates a smart note checked nightly against external signals on ctx_note write.`;
 var TEMPORAL_AWARENESS_GUIDANCE = `
 **Temporal awareness**: User messages may be preceded by HTML comments like \`<!-- +12m -->\`, \`<!-- +2h 15m -->\`, or \`<!-- +3d 4h -->\` indicating time elapsed since the previous message's completion. Compartments in \`<session-history>\` carry \`start-date\` and \`end-date\` attributes (YYYY-MM-DD) showing real-time boundaries. Use these when reasoning about workflow pacing, log durations, build times, or how long ago something happened.`;
 var SUBAGENT_REDUCE_INTRO = (protectedTags) => `Messages and tool outputs are tagged with §N§ identifiers (e.g., §1§, §42§).
 Use \`ctx_reduce\` to drop tool outputs you have already finished with, keeping your working context lean. Syntax: "3-5", "1,2,9", or "1-5,8,12-15". The last ${protectedTags} tags are protected.
 Drop silently — do not narrate it. NEVER drop large ranges blindly (e.g., "1-50"); review each tag first. Do not drop user or assistant text messages — only large tool outputs are worth dropping.
 Older tool calls may show \`[dropped §N§]\` sentinels; that is normal context management, not a pattern to copy. ALWAYS make fresh real tool calls when you need data again; never fabricate or inline tool output.`;
+var SUBAGENT_REDUCE_INTRO_LIGHT = (protectedTags) => `In bounded subagent sessions, the system tags messages and tool outputs as §N§; use only those IDs in ctx_reduce drop ranges such as "3-5", "1,2,9", or "1-5,8,12-15". The last ${protectedTags} tags stay protected.
+When dropping, do it silently and NEVER choose a large range before reviewing every tag; drop only finished large tool outputs, never user or assistant messages.
+If older calls show [dropped §N§], never copy that system sentinel because it is not reply syntax; make a fresh real tool call and never fabricate or inline output.`;
 var CAVEMAN_COMPRESSION_WARNING = `
 **BEWARE**: History compression is on; older user AND assistant text — including your own earlier responses — has been deterministically rewritten in a terse caveman style (dropped articles, missing auxiliaries, \`//\` instead of connectives like \`because\`). This is automatic context compression that runs after the fact, not your actual prior wording or the user's. **DO NOT mimic this style in new turns.** Write fresh responses in normal prose. If you notice your output drifting into caveman cadence, that drift is in-context-learning bleeding from the compressed history — consciously revert to full sentences.`;
-function buildMagicContextSection(_agent, protectedTags, ctxReduceCallable = true, dreamerEnabled = false, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false, subagentMode = false, language, memoryEnabled = true) {
+function buildMagicContextSection(_agent, protectedTags, ctxReduceCallable = true, dreamerEnabled = false, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false, subagentMode = false, language, memoryEnabled = true, preset = "full", primaryOverride) {
   if (subagentMode) {
+    const intro = preset === "light" ? SUBAGENT_REDUCE_INTRO_LIGHT(protectedTags) : SUBAGENT_REDUCE_INTRO(protectedTags);
     return `## Magic Context
 
-${SUBAGENT_REDUCE_INTRO(protectedTags)}`;
+${intro}`;
   }
-  const smartNoteGuidance = dreamerEnabled ? `
+  const smartNoteGuidance = dreamerEnabled ? preset === "light" ? SMART_NOTE_GUIDANCE_LIGHT : `
 When \`surface_condition\` is provided with \`write\`, the note becomes a project-scoped smart note.
 The dreamer evaluates smart note conditions during nightly runs and surfaces them when conditions are met.
 Example: \`ctx_note(action="write", content="Implement X because Y", surface_condition="When PR #42 is merged in this repo")\`` : "";
@@ -33040,13 +33140,32 @@ Example: \`ctx_note(action="write", content="Implement X because Y", surface_con
   const languageGuidance = languageDirective ? `
 
 ${languageDirective}` : "";
+  if (primaryOverride !== undefined) {
+    return `${primaryOverride}${temporalGuidance}${cavemanWarning}${languageGuidance}`;
+  }
   if (!ctxReduceCallable) {
+    if (preset === "light") {
+      return `## Magic Context
+
+${LONG_TERM_PARTNER_FRAME}
+${PARTNER_FRAME_CLOSER_NO_REDUCE_LIGHT}
+
+${BASE_INTRO_NO_REDUCE_LIGHT(memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}${languageGuidance}`;
+    }
     return `## Magic Context
 
 ${LONG_TERM_PARTNER_FRAME}
 ${PARTNER_FRAME_CLOSER_NO_REDUCE}
 
 ${BASE_INTRO_NO_REDUCE(memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}${languageGuidance}`;
+  }
+  if (preset === "light") {
+    return `## Magic Context
+
+${LONG_TERM_PARTNER_FRAME}
+${PARTNER_FRAME_CLOSER_REDUCE_LIGHT}
+
+${BASE_INTRO_LIGHT(protectedTags, memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}${languageGuidance}`;
   }
   return `## Magic Context
 
@@ -33072,6 +33191,11 @@ function isMagicContextInternalAgent(systemPromptContent) {
   return systemPromptContent.includes("You are Historian — the hippocampus of a long-running coding agent.") || systemPromptContent.includes("for the magic-context system") || systemPromptContent.includes("You are Sidekick, a focused memory-retrieval subagent for an AI coding assistant.");
 }
 function createSystemPromptHashHandler(deps) {
+  const promptSurfaceRuntime = deps.promptSurfaceRuntime ?? createPromptSurfaceRuntime({
+    userConfigDirectory: process.cwd(),
+    warn: (message) => console.warn(`[magic-context] config warning: ${message}`)
+  });
+  const guidanceEpochs = createPromptSurfaceGuidanceEpochCache(promptSurfaceRuntime);
   const stickyDateBySession = new Map;
   const handler = async (input, output) => {
     const sessionId = input.sessionID;
@@ -33109,10 +33233,14 @@ function createSystemPromptHashHandler(deps) {
     const subagentReduceMode = isSubagentSession2 && ctxReduceCallable;
     const effectiveCtxReduceEnabled = isSubagentSession2 ? false : ctxReduceCallable;
     const skipGuidanceForDisabledSubagent = isSubagentSession2 && !ctxReduceCallable;
+    const inputModel = input.model;
+    const liveModel = inputModel?.providerID && inputModel.modelID ? { providerID: inputModel.providerID, modelID: inputModel.modelID } : deps.resolveModel?.(sessionId);
+    const modelKey = liveModel?.providerID && liveModel.modelID ? `${liveModel.providerID}/${liveModel.modelID}` : undefined;
+    const promptSurface = guidanceEpochs.resolve(sessionId, deps.promptSurface, modelKey);
     const fullPrompt = output.system.join(`
 `);
     if (fullPrompt.length > 0 && !fullPrompt.includes(MAGIC_CONTEXT_MARKER) && !skipGuidanceForDisabledSubagent) {
-      const guidance = buildMagicContextSection(null, deps.protectedTags, effectiveCtxReduceEnabled, deps.dreamerEnabled, deps.experimentalTemporalAwareness, deps.experimentalCavemanTextCompression, subagentReduceMode, deps.language, deps.memoryEnabled !== false);
+      const guidance = buildMagicContextSection(null, deps.protectedTags, effectiveCtxReduceEnabled, deps.dreamerEnabled, deps.experimentalTemporalAwareness, deps.experimentalCavemanTextCompression, subagentReduceMode, deps.language, deps.memoryEnabled !== false, promptSurface.preset, promptSurface.primaryOverride);
       output.system.push(guidance);
       sessionLog(sessionId, `injected generic guidance into system prompt (ctxReduce=${effectiveCtxReduceEnabled}, subagent=${isSubagentSession2}, subagentReduceMode=${subagentReduceMode})`);
     }
@@ -33143,7 +33271,7 @@ function createSystemPromptHashHandler(deps) {
       return;
     if (!availability.frozen)
       return;
-    const currentHash = createHash12("md5").update(systemContent).digest("hex");
+    const currentHash = createHash14("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
     if (!sessionMetaEarly) {
       return;
     }
@@ -33181,6 +33309,7 @@ function createSystemPromptHashHandler(deps) {
   return {
     handler,
     clearSession: (sessionId) => {
+      guidanceEpochs.clear(sessionId);
       clearSystemPromptHashSession(sessionId, {
         stickyDateBySession,
         cachedDocsBySession: new Map
@@ -33335,11 +33464,13 @@ function createMagicContextHook(deps) {
       const fence = getSchemaFenceRejection();
       recordHookInitFailure({
         type: "storage",
-        reason: migration && blockingProcesses.length > 0 ? {
+        reason: migration && (blockingProcesses.length > 0 || migration.unreadableFile) ? {
           kind: "migration_guard",
           persistedVersion: migration.persistedVersion,
           supportedVersion: migration.supportedVersion,
-          blockingProcesses
+          blockingProcesses,
+          ...migration.unreadableFile ? { unreadableFile: migration.unreadableFile } : {},
+          ...migration.unreadableArm ? { unreadableArm: migration.unreadableArm } : {}
         } : fence ? {
           kind: "schema_fence",
           persistedVersion: fence.persistedVersion,
@@ -33631,6 +33762,7 @@ function createMagicContextHook(deps) {
     const client = {
       call: (args) => transport.call(args),
       stateSyncCapabilities: (args) => transport.stateSyncCapabilities(args),
+      deleteSession: (sessionId, projectRoot) => transport.deleteSession(sessionId, projectRoot),
       closeSession: (sessionId) => transport.closeSession(sessionId),
       authorityStatus: (args) => transport.authorityStatus(args),
       authorityPrepare: (args) => transport.authorityPrepare(args),
@@ -33659,6 +33791,23 @@ function createMagicContextHook(deps) {
     return client;
   })();
   const rustModeModuleClient = deps.config.transform_mode === "rust" ? authorityRecoveryModuleClient : undefined;
+  const syncModuleDomain = async (domain) => {
+    if (!rustModeModuleClient?.mirrorPull)
+      return;
+    for (;; ) {
+      const cursor = getMirrorCursor(db, domain);
+      const response = await rustModeModuleClient.mirrorPull({
+        domain,
+        cursor,
+        limit: 1000
+      });
+      const next = applyMirrorPage({ db, page: response.page });
+      if (!response.page.has_more || next === cursor)
+        break;
+    }
+  };
+  const syncModuleNotes = () => syncModuleDomain("notes");
+  const syncModuleMemories = () => syncModuleDomain("memories");
   const rustToolBackends = deps.config.transform_mode === "rust" && rustModeModuleClient ? {
     authorityState: async ({ projectPath: projectPath2, projectRoot, domain }) => {
       if (!rustModeModuleClient.authorityStatus)
@@ -33683,7 +33832,7 @@ function createMagicContextHook(deps) {
         command_id: commandId
       }
     }),
-    note: ({
+    note: async ({
       commandId,
       sessionId,
       projectRoot,
@@ -33695,26 +33844,30 @@ function createMagicContextHook(deps) {
       limit,
       offset,
       noteId
-    }) => rustModeModuleClient.call({
-      sessionId,
-      projectRoot,
-      method: "ctx_note",
-      body: {
-        name: "ctx_note",
-        arguments: {
-          ...commandId ? { command_id: commandId } : {},
-          action,
-          content,
-          memory_project: memoryProject,
-          surface_condition: surfaceCondition,
-          filter,
-          limit,
-          offset,
-          note_id: noteId
+    }) => {
+      const response = await rustModeModuleClient.call({
+        sessionId,
+        projectRoot,
+        method: "ctx_note",
+        body: {
+          name: "ctx_note",
+          arguments: {
+            ...commandId ? { command_id: commandId } : {},
+            action,
+            content,
+            memory_project: memoryProject,
+            surface_condition: surfaceCondition,
+            filter,
+            limit,
+            offset,
+            note_id: noteId
+          }
         }
-      }
-    }),
-    memory: ({
+      });
+      await syncModuleNotes();
+      return response;
+    },
+    memory: async ({
       commandId,
       sessionId,
       projectRoot,
@@ -33724,23 +33877,27 @@ function createMagicContextHook(deps) {
       category,
       ids,
       reason
-    }) => rustModeModuleClient.call({
-      sessionId,
-      projectRoot,
-      method: "ctx_memory",
-      body: {
-        name: "ctx_memory",
-        arguments: {
-          ...commandId ? { command_id: commandId } : {},
-          action,
-          content,
-          category,
-          ids,
-          reason,
-          memory_project: memoryProject
+    }) => {
+      const response = await rustModeModuleClient.call({
+        sessionId,
+        projectRoot,
+        method: "ctx_memory",
+        body: {
+          name: "ctx_memory",
+          arguments: {
+            ...commandId ? { command_id: commandId } : {},
+            action,
+            content,
+            category,
+            ids,
+            reason,
+            memory_project: memoryProject
+          }
         }
-      }
-    }),
+      });
+      await syncModuleMemories();
+      return response;
+    },
     noteEvaluationAvailable: (evaluationProjectPath) => getModuleNoteEvaluationBridge(evaluationProjectPath) !== undefined,
     memorySync: (sessionId) => {
       rustMemorySyncRequestedSessions.add(sessionId);
@@ -33751,21 +33908,6 @@ function createMagicContextHook(deps) {
       return;
     if (getModuleNoteEvaluationBridge(bridgeProjectPath))
       return;
-    const syncModuleNotes = async () => {
-      for (;; ) {
-        const cursor = getMirrorCursor(db, "notes");
-        const response = await rustModeModuleClient.mirrorPull?.({
-          domain: "notes",
-          cursor,
-          limit: 1000
-        });
-        if (!response)
-          throw new Error("mirror.pull is unavailable for notes");
-        const next = applyMirrorPage({ db, page: response.page });
-        if (!response.page.has_more || next === cursor)
-          break;
-      }
-    };
     registerModuleNoteEvaluationBridge(bridgeProjectPath, {
       sync: syncModuleNotes,
       async evaluate({ contextNoteId, sessionId, verdict }) {
@@ -33873,6 +34015,7 @@ function createMagicContextHook(deps) {
     } : undefined,
     maybeAutoEmbedSession,
     transformMode: deps.config.transform_mode,
+    promptSurface: deps.config.prompt_surface,
     rustModeModuleClient,
     tsAuthorityRecoveryModuleClient: authorityRecoveryModuleClient,
     rustMemorySyncRequestedSessions,
@@ -34054,6 +34197,9 @@ function createMagicContextHook(deps) {
     dreamerEnabled: dreamerRunnable,
     memoryEnabled: deps.config.memory?.enabled !== false,
     language: deps.config.language,
+    promptSurface: deps.config.prompt_surface,
+    promptSurfaceRuntime: deps.promptSurfaceRuntime,
+    resolveModel: resolveLiveModel,
     historyRefreshSessions,
     systemPromptRefreshSessions,
     pendingMaterializationSessions,
@@ -34194,6 +34340,7 @@ async function createSessionHooksAsync(args) {
     compactionHandler,
     liveSessionState,
     rustModeModuleClient: args.rustModeModuleClient,
+    promptSurfaceRuntime: args.promptSurfaceRuntime,
     config: buildMagicContextHookConfig(pluginConfig)
   });
   return {
@@ -35024,7 +35171,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-k72ejkkh.js");
+    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-zc915ceq.js");
     const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-6njqewzk.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -35040,7 +35187,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-k72ejkkh.js");
+    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-zc915ceq.js");
     const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-6njqewzk.js");
     log(`[rpc] session-upgrade requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -35057,7 +35204,7 @@ function registerRpcHandlers(rpcServer, args) {
     if (!db)
       return { ok: false, error: "db unavailable" };
     try {
-      const { updateSessionMeta: updateSessionMeta2 } = await import("./storage-meta-session-xt41zbw4.js");
+      const { updateSessionMeta: updateSessionMeta2 } = await import("./storage-meta-session-53cjs6mr.js");
       updateSessionMeta2(db, sessionId, { upgradeRemindedAt: Date.now() });
       return { ok: true };
     } catch (error) {
@@ -36343,7 +36490,7 @@ Mark discardable once processed: large outputs you've summarized, repeated or re
 Keep: user messages, unresolved errors, raw evidence you haven't extracted yet, and outputs whose exact wording may matter later.
 Never blanket-mark large ranges (e.g. "1-50") — review what each tag holds first.`;
 // src/tools/ctx-reduce/tools.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 import { tool as tool4 } from "@opencode-ai/plugin";
 
 // src/features/magic-context/range-parser.ts
@@ -36413,11 +36560,11 @@ function createCtxReduceTool(deps) {
       const stableId = `oc-${sessionId}-${callId}`;
       if (Buffer.byteLength(stableId) <= 128)
         return stableId;
-      return `oc-${createHash13("sha256").update(stableId).digest("hex")}`;
+      return `oc-${createHash15("sha256").update(stableId).digest("hex")}`;
     }
     fallbackCommandSequence += 1;
     const monotonicId = `oc-${sessionId}-${fallbackCommandSequence}`;
-    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash13("sha256").update(monotonicId).digest("hex")}`;
+    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash15("sha256").update(monotonicId).digest("hex")}`;
   };
   return tool4({
     description: CTX_REDUCE_DESCRIPTION,
@@ -36813,10 +36960,23 @@ function createToolRegistry(args) {
       rustToolBackends
     }) : {}
   };
-  for (const toolDefinition of Object.values(allTools)) {
+  const promptSurfaceRuntime = args.promptSurfaceRuntime ?? createPromptSurfaceRuntime({
+    harness: "opencode",
+    directory: ctx.directory,
+    warn: (message) => console.warn(`[magic-context] config warning: ${message}`)
+  });
+  const registration = promptSurfaceRuntime.resolveRegistration(args.registrationPromptSurface ?? pluginConfig.prompt_surface);
+  const surfacedTools = Object.fromEntries(Object.entries(allTools).map(([toolId, definition]) => [
+    toolId,
+    {
+      ...definition,
+      description: registration.descriptionFor(toolId, definition.description ?? "")
+    }
+  ]));
+  for (const toolDefinition of Object.values(surfacedTools)) {
     normalizeToolArgSchemas(toolDefinition);
   }
-  return allTools;
+  return surfacedTools;
 }
 
 // src/shared/exit-abort-registry.ts
@@ -36844,15 +37004,15 @@ function unregisterExitAbort(controller) {
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import {
   chmodSync,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync2,
   readdirSync,
-  readFileSync as readFileSync7,
-  renameSync as renameSync4,
-  rmSync as rmSync3,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync5
+  readFileSync as readFileSync6,
+  renameSync as renameSync3,
+  rmSync as rmSync2,
+  unlinkSync,
+  writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { dirname as dirname4 } from "node:path";
 var MAX_BODY_BYTES = 1048576;
 var WS_AUTH_TIMEOUT_MS = 5000;
 var WS_CLOSE_UNAUTHORIZED = 4401;
@@ -36926,28 +37086,28 @@ class MagicContextRpcServer {
     this.port = server.port ?? 0;
     try {
       this.warnIfOtherLiveInstance();
-      const dir = dirname5(this.portFilePath);
+      const dir = dirname4(this.portFilePath);
       const enforcePrivatePermissions = shouldEnforcePrivateStoragePermissions();
       if (enforcePrivatePermissions) {
-        mkdirSync3(dir, { recursive: true, mode: 448 });
+        mkdirSync2(dir, { recursive: true, mode: 448 });
         try {
           chmodSync(dir, 448);
         } catch {}
       } else {
-        mkdirSync3(dir, { recursive: true });
+        mkdirSync2(dir, { recursive: true });
       }
       const tmpPath = `${this.portFilePath}.tmp`;
       try {
-        rmSync3(tmpPath, { force: true });
+        rmSync2(tmpPath, { force: true });
       } catch {}
-      writeFileSync5(tmpPath, JSON.stringify({
+      writeFileSync4(tmpPath, JSON.stringify({
         port: this.port,
         pid: process.pid,
         started_at: this.startedAt,
         token: this.token,
         instance_id: this.instanceId
       }), enforcePrivatePermissions ? { encoding: "utf-8", mode: 384 } : { encoding: "utf-8" });
-      renameSync4(tmpPath, this.portFilePath);
+      renameSync3(tmpPath, this.portFilePath);
       if (enforcePrivatePermissions) {
         try {
           chmodSync(this.portFilePath, 384);
@@ -36974,7 +37134,7 @@ class MagicContextRpcServer {
       this.server = null;
     }
     try {
-      unlinkSync2(this.portFilePath);
+      unlinkSync(this.portFilePath);
     } catch {}
   }
   warnIfOtherLiveInstance() {
@@ -36982,7 +37142,7 @@ class MagicContextRpcServer {
       for (const entry of readdirSync(this.portDir)) {
         if (!entry.startsWith("port-") || !entry.endsWith(".json"))
           continue;
-        const record = parseRpcPortFile(readFileSync7(`${this.portDir}/${entry}`, "utf-8"));
+        const record = parseRpcPortFile(readFileSync6(`${this.portDir}/${entry}`, "utf-8"));
         if (!record || record.pid === process.pid || !isPidAlive(record.pid))
           continue;
         log(`[rpc] another Magic Context RPC server is active for this project (pid ${record.pid}, port ${record.port}); starting separate instance on a new port`);
@@ -37122,7 +37282,13 @@ var server = async (ctx) => {
     warn: (m) => log(`[magic-context] ${m}`),
     info: (m) => log(`[magic-context] ${m}`)
   });
-  const pluginConfig = loadPluginConfig(ctx.directory);
+  const loadedPluginConfig = loadPluginConfigDetailed(ctx.directory);
+  const pluginConfig = loadedPluginConfig.config;
+  const promptSurfaceRuntime = createPromptSurfaceRuntime({
+    harness: "opencode",
+    directory: ctx.directory,
+    warn: (message) => log(`[magic-context] config warning: ${message}`)
+  });
   if (configMigrationWarnings.length > 0) {
     pluginConfig.configWarnings = [
       ...configMigrationWarnings,
@@ -37182,7 +37348,8 @@ var server = async (ctx) => {
     ctx,
     pluginConfig,
     liveSessionState,
-    rustModeModuleClient
+    rustModeModuleClient,
+    promptSurfaceRuntime
   });
   const magicContextRuntime = {
     magicContext: hooks.magicContext,
@@ -37207,7 +37374,8 @@ var server = async (ctx) => {
         ctx,
         pluginConfig,
         liveSessionState,
-        rustModeModuleClient
+        rustModeModuleClient,
+        promptSurfaceRuntime
       });
       if (!reopened.magicContext)
         return false;
@@ -37224,7 +37392,9 @@ var server = async (ctx) => {
   const tools5 = createToolRegistry({
     ctx,
     pluginConfig,
-    rustToolBackends: magicContextRuntime.rustToolBackends
+    rustToolBackends: magicContextRuntime.rustToolBackends,
+    promptSurfaceRuntime,
+    registrationPromptSurface: loadedPluginConfig.registrationPromptSurface
   });
   if (pluginConfig.enabled && magicContextRuntime.magicContext) {
     try {
@@ -37330,7 +37500,7 @@ var server = async (ctx) => {
   {
     const fence = getSchemaFenceRejection();
     if (fence) {
-      import("./conflict-warning-hook-fvpfvt0w.js").then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence));
+      import("./conflict-warning-hook-p2pmhvn7.js").then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence));
     }
   }
   if (conflictResult?.hasConflict) {
@@ -37351,7 +37521,7 @@ var server = async (ctx) => {
       } = await import("./announcement-gms2nhya.js");
       if (shouldShowAnnouncement2()) {
         setTimeout(() => {
-          import("./conflict-warning-hook-fvpfvt0w.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION2, ANNOUNCEMENT_FEATURES2, ANNOUNCEMENT_FOOTER2, markAnnouncementSeen2)).catch(() => {});
+          import("./conflict-warning-hook-p2pmhvn7.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION2, ANNOUNCEMENT_FEATURES2, ANNOUNCEMENT_FOOTER2, markAnnouncementSeen2)).catch(() => {});
         }, 8000);
       }
     } catch {}