@cortexkit/opencode-magic-context 0.34.1 → 0.35.0

package/dist/{index-x8spt5wy.js → index-4anesz49.js}

@@ -13,11 +13,16 @@ import {
   sendIgnoredMessage
 } from "./index-cn960ffd.js";
 import {
+  buildToolArcs,
+  buildTrueRawTokenIndex,
   clearCachedM0M1,
   clearCompressionDepth,
   clearCompressionDepthRange,
+  completedToolArcCrossesBoundary,
+  computeRawRangeFingerprint,
   ensureSessionMetaRow,
   estimateTokens,
+  fenceBoundaryForToolArcs,
   getCachedAbsoluteMessageCount,
   getLegacyProtectedTailStartOrdinal,
   getRawSessionMessageCount,
@@ -28,14 +33,18 @@ import {
   persistCachedM0,
   readRawSessionMessages,
   readSessionChunk,
+  stableStringify,
   updateSessionMeta
-} from "./index-b563sga5.js";
+} from "./index-h8mk7vpa.js";
 import {
   Database,
   closeQuietly,
   getMessageTimesFromOpenCodeDb,
   withPrivilegedWriter
 } from "./index-fcyvznch.js";
+import {
+  detectConfigFile
+} from "./index-0c9dmw9m.js";
 import {
   pushNotification
 } from "./index-d62ypazr.js";
@@ -390,6 +399,7 @@ import {
   mkdtempSync,
   readdirSync,
   readFileSync as readFileSync2,
+  statSync as statSync2,
   unlinkSync
 } from "node:fs";
 import { basename, dirname, join as join3 } from "node:path";
@@ -1082,7 +1092,11 @@ var MEMORY_SNAPSHOT_COLUMNS = [
   "merged_from",
   "metadata_json",
   "context_store_uuid",
-  "context_row_id"
+  "context_row_id",
+  "mural_cue",
+  "mural_cue_hash",
+  "mural_cue_at",
+  "mural_cue_rejection_count"
 ];
 function hasSnapshotField(row, key) {
   return Object.prototype.hasOwnProperty.call(row, key);
@@ -1200,9 +1214,10 @@ function prepareMirrorPageStatements(db) {
     memoryById: db.prepare(`SELECT project_path, category, content, normalized_hash, importance, scope, shareable,
                     source_session_id, source_type, seen_count, retrieval_count, first_seen_at,
                     created_at, updated_at, last_seen_at, last_retrieved_at, status, expires_at,
-                    verification_status, verified_at, classified_at, superseded_by_memory_id,
-                    merged_from, metadata_json
-               FROM memories WHERE id = ?`),
+                     verification_status, verified_at, classified_at, superseded_by_memory_id,
+                     merged_from, metadata_json, mural_cue, mural_cue_hash, mural_cue_at,
+                     mural_cue_rejection_count
+                FROM memories WHERE id = ?`),
     memoryIdByStoreId: db.prepare("SELECT id FROM memories WHERE id = ? AND project_path = ?"),
     memoryCandidates: db.prepare("SELECT id FROM memories WHERE project_path = ? AND category = ? AND normalized_hash = ? ORDER BY id"),
     insertMemory: db.prepare("INSERT INTO memories (project_path, category, content, normalized_hash, first_seen_at, created_at, updated_at, last_seen_at) VALUES (?, ?, '', '', 0, 0, 0, 0)"),
@@ -1223,8 +1238,9 @@ function prepareMirrorPageStatements(db) {
              importance = ?, scope = ?, shareable = ?, source_session_id = ?, source_type = ?,
              seen_count = ?, retrieval_count = ?, first_seen_at = ?, created_at = ?, updated_at = ?,
              last_seen_at = ?, last_retrieved_at = ?, status = ?, expires_at = ?,
-             verification_status = ?, verified_at = ?, classified_at = ?, superseded_by_memory_id = ?,
-             merged_from = ?, metadata_json = ? WHERE id = ?`),
+              verification_status = ?, verified_at = ?, classified_at = ?, superseded_by_memory_id = ?,
+              merged_from = ?, metadata_json = ?, mural_cue = ?, mural_cue_hash = ?, mural_cue_at = ?,
+              mural_cue_rejection_count = ? WHERE id = ?`),
     updateSuperseded: db.prepare("UPDATE memories SET superseded_by_memory_id = ? WHERE id = ?"),
     deletePendingReference: db.prepare("DELETE FROM mirror_pending_references WHERE domain = 'memories' AND module_project = ? AND module_row_id = ?"),
     upsertPendingReference: db.prepare("INSERT INTO mirror_pending_references(domain, module_project, module_row_id, target_module_row_id) VALUES ('memories', ?, ?, ?) ON CONFLICT(domain, module_project, module_row_id) DO UPDATE SET target_module_row_id = excluded.target_module_row_id"),
@@ -1388,7 +1404,7 @@ function applyMemoryRow(db, feed, statements) {
   const nullableString = (key, previous) => has(key) ? rowNullableString(row, key) : previous ?? null;
   const hasSuperseded = has("superseded_by_memory_id");
   const previousHash = existing?.normalized_hash;
-  statements.updateMemory.run(has("project_path") ? rowString(row, "project_path") : existing?.project_path ?? moduleProject, has("category") ? rowString(row, "category", "CONSTRAINTS") : existing?.category ?? "CONSTRAINTS", has("content") ? rowString(row, "content") : existing?.content ?? "", has("normalized_hash") ? rowString(row, "normalized_hash") : existing?.normalized_hash ?? "", has("importance") ? typeof row.importance === "number" && Number.isFinite(row.importance) ? row.importance : null : existing?.importance ?? null, has("scope") ? rowString(row, "scope", "project") : existing?.scope ?? "project", has("shareable") ? rowNumber(row, "shareable") : existing?.shareable ?? 0, nullableString("source_session_id", existing?.source_session_id), nullableString("source_type", existing?.source_type), has("seen_count") ? rowNumber(row, "seen_count", 1) : existing?.seen_count ?? 1, has("retrieval_count") ? rowNumber(row, "retrieval_count") : existing?.retrieval_count ?? 0, has("first_seen_at") ? rowNumber(row, "first_seen_at") : existing?.first_seen_at ?? 0, has("created_at") ? rowNumber(row, "created_at") : existing?.created_at ?? 0, has("updated_at") ? rowNumber(row, "updated_at") : existing?.updated_at ?? 0, has("last_seen_at") ? rowNumber(row, "last_seen_at") : existing?.last_seen_at ?? 0, nullableNumber("last_retrieved_at", existing?.last_retrieved_at), has("status") ? rowString(row, "status", "active") : existing?.status ?? "active", nullableNumber("expires_at", existing?.expires_at), has("verification_status") ? rowString(row, "verification_status", "unverified") : existing?.verification_status ?? "unverified", nullableNumber("verified_at", existing?.verified_at), nullableNumber("classified_at", existing?.classified_at), hasSuperseded ? null : existing?.superseded_by_memory_id ?? null, nullableString("merged_from", existing?.merged_from), nullableString("metadata_json", existing?.metadata_json), contextId);
+  statements.updateMemory.run(has("project_path") ? rowString(row, "project_path") : existing?.project_path ?? moduleProject, has("category") ? rowString(row, "category", "CONSTRAINTS") : existing?.category ?? "CONSTRAINTS", has("content") ? rowString(row, "content") : existing?.content ?? "", has("normalized_hash") ? rowString(row, "normalized_hash") : existing?.normalized_hash ?? "", has("importance") ? typeof row.importance === "number" && Number.isFinite(row.importance) ? row.importance : null : existing?.importance ?? null, has("scope") ? rowString(row, "scope", "project") : existing?.scope ?? "project", has("shareable") ? rowNumber(row, "shareable") : existing?.shareable ?? 0, nullableString("source_session_id", existing?.source_session_id), nullableString("source_type", existing?.source_type), has("seen_count") ? rowNumber(row, "seen_count", 1) : existing?.seen_count ?? 1, has("retrieval_count") ? rowNumber(row, "retrieval_count") : existing?.retrieval_count ?? 0, has("first_seen_at") ? rowNumber(row, "first_seen_at") : existing?.first_seen_at ?? 0, has("created_at") ? rowNumber(row, "created_at") : existing?.created_at ?? 0, has("updated_at") ? rowNumber(row, "updated_at") : existing?.updated_at ?? 0, has("last_seen_at") ? rowNumber(row, "last_seen_at") : existing?.last_seen_at ?? 0, nullableNumber("last_retrieved_at", existing?.last_retrieved_at), has("status") ? rowString(row, "status", "active") : existing?.status ?? "active", nullableNumber("expires_at", existing?.expires_at), has("verification_status") ? rowString(row, "verification_status", "unverified") : existing?.verification_status ?? "unverified", nullableNumber("verified_at", existing?.verified_at), nullableNumber("classified_at", existing?.classified_at), hasSuperseded ? null : existing?.superseded_by_memory_id ?? null, nullableString("merged_from", existing?.merged_from), nullableString("metadata_json", existing?.metadata_json), nullableString("mural_cue", existing?.mural_cue), nullableString("mural_cue_hash", existing?.mural_cue_hash), nullableNumber("mural_cue_at", existing?.mural_cue_at), has("mural_cue_rejection_count") ? rowNumber(row, "mural_cue_rejection_count") : existing?.mural_cue_rejection_count ?? 0, contextId);
   if (hasSuperseded && typeof row.superseded_by_memory_id === "number") {
     const translated = mirrorIdentity(db, "memories", moduleProject, row.superseded_by_memory_id, statements);
     if (translated) {
@@ -4656,6 +4672,15 @@ var MIGRATIONS = [
         ensureColumn(db, "session_meta", "detected_context_limit_provenance", "TEXT NOT NULL DEFAULT 'unknown'");
       }
     }
+  },
+  {
+    version: 75,
+    description: "persist mural cue validation rejection latches",
+    up(db) {
+      if (!tableExists2(db, "memories"))
+        return;
+      ensureColumn(db, "memories", "mural_cue_rejection_count", "INTEGER NOT NULL DEFAULT 0");
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -4771,30 +4796,6 @@ async function runMigrationsWithRetry(db, options = {}) {
 
 // src/features/magic-context/tool-definition-tokens.ts
 import { createHash as createHash5 } from "node:crypto";
-
-// src/shared/stable-json.ts
-function stableStringify(value, seen = new WeakSet) {
-  if (value === undefined)
-    return "undefined";
-  if (value === null || typeof value !== "object")
-    return JSON.stringify(value) ?? String(value);
-  if (seen.has(value))
-    return '"[Circular]"';
-  seen.add(value);
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
-  }
-  const entries = Object.entries(value).sort(([a], [b]) => {
-    if (a < b)
-      return -1;
-    if (a > b)
-      return 1;
-    return 0;
-  });
-  return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child, seen)}`).join(",")}}`;
-}
-
-// src/features/magic-context/tool-definition-tokens.ts
 var measurements = new Map;
 var fingerprints = new Map;
 var persistenceDb = null;
@@ -5147,7 +5148,7 @@ function getSchemaFenceRejection() {
 function getMigrationOnOpenRefusal() {
   return lastMigrationOnOpenRefusal;
 }
-var LATEST_SUPPORTED_VERSION = 74;
+var LATEST_SUPPORTED_VERSION = 75;
 var PERMISSIONS_ENFORCEABLE = process.platform !== "win32";
 var defaultStoragePermissionFs = { chmodSync, mkdirSync };
 var storagePermissionFs = defaultStoragePermissionFs;
@@ -5269,24 +5270,65 @@ function enforceSchemaFence(db, dbPath, latestSupportedVersion) {
   log(`[magic-context] storage fatal: refusing to open ${dbPath}; upstream migration lane v${persistedVersion} is newer than this binary supports (max v${latestSupportedVersion}). A pinned or stale plugin is likely sharing this database with a newer instance; update or unpin Magic Context with 'npx @cortexkit/magic-context@latest doctor --force', then restart.`);
   return false;
 }
-function unreadableDiscovery(path2) {
+function unreadableDiscovery(path2, arm) {
   return {
     state: "unreadable",
     serverPids: [],
     staleFiles: [],
-    unreadableFile: path2
+    unreadableFile: path2,
+    unreadableArm: arm
   };
 }
+var RPC_DISCOVERY_PARSE_GRACE_MS = 10 * 60 * 1000;
+var defaultRpcDiscoveryFs = {
+  readdirSync: (path2, options) => options?.withFileTypes ? readdirSync(path2, { withFileTypes: true }) : readdirSync(path2),
+  readFileSync: (path2, encoding) => String(readFileSync2(path2, encoding)),
+  statSync: (path2) => ({ mtimeMs: statSync2(path2).mtimeMs }),
+  unlinkSync: (path2) => unlinkSync(path2)
+};
+var rpcDiscoveryFs = defaultRpcDiscoveryFs;
+function invalidDiscoveryReason(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if ("pid" in parsed) {
+        const pid = Number(parsed.pid);
+        if (!Number.isInteger(pid) || pid <= 0)
+          return "invalid-pid";
+      }
+    } catch {}
+  }
+  return "parse-invalid";
+}
+function classifyJunkDiscovery(portFile, raw, staleFiles) {
+  let mtimeMs;
+  try {
+    mtimeMs = rpcDiscoveryFs.statSync(portFile).mtimeMs;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    return unreadableDiscovery(portFile, "io");
+  }
+  const ageMs = Date.now() - mtimeMs;
+  if (!Number.isFinite(ageMs) || ageMs < RPC_DISCOVERY_PARSE_GRACE_MS) {
+    return unreadableDiscovery(portFile, "parse");
+  }
+  staleFiles.push(portFile);
+  const reason = invalidDiscoveryReason(raw);
+  log(`[magic-context] removing stale RPC discovery file ${portFile}: ${reason} record older than 10 minutes`);
+  return null;
+}
 function inspectRpcServerDiscovery(storageDir) {
   const rpcRoot = join3(storageDir, "rpc");
   let projectEntries;
   try {
-    projectEntries = readdirSync(rpcRoot, { withFileTypes: true });
+    projectEntries = rpcDiscoveryFs.readdirSync(rpcRoot, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") {
       return { state: "absent", serverPids: [], staleFiles: [] };
     }
-    return unreadableDiscovery(rpcRoot);
+    return unreadableDiscovery(rpcRoot, "io");
   }
   const portFiles = [];
   for (const projectEntry of projectEntries) {
@@ -5295,9 +5337,11 @@ function inspectRpcServerDiscovery(storageDir) {
     const projectDir = join3(rpcRoot, projectEntry.name);
     let entries;
     try {
-      entries = readdirSync(projectDir);
-    } catch {
-      return unreadableDiscovery(projectDir);
+      entries = rpcDiscoveryFs.readdirSync(projectDir);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        continue;
+      return unreadableDiscovery(projectDir, "io");
     }
     for (const entry of entries) {
       if (entry === "port" || entry.startsWith("port-") && entry.endsWith(".json")) {
@@ -5313,15 +5357,21 @@ function inspectRpcServerDiscovery(storageDir) {
   for (const portFile of portFiles) {
     let raw;
     try {
-      raw = readFileSync2(portFile, "utf8");
-    } catch {
-      return unreadableDiscovery(portFile);
+      raw = rpcDiscoveryFs.readFileSync(portFile, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        continue;
+      return unreadableDiscovery(portFile, "io");
     }
     const filename = basename(portFile);
     const pidFromName = /^port-(\d+)/.exec(filename)?.[1];
-    const record = parseRpcPortFile(raw, pidFromName ? Number(pidFromName) : 0);
+    const fallbackPid = pidFromName ? Number(pidFromName) : 0;
+    const record = parseRpcPortFile(raw, fallbackPid);
     if (!record || !Number.isInteger(record.pid) || record.pid <= 0) {
-      return unreadableDiscovery(portFile);
+      const junk = classifyJunkDiscovery(portFile, raw, staleFiles);
+      if (junk)
+        return junk;
+      continue;
     }
     if (isPidAlive(record.pid) && isPidIdentityPlausible(record))
       pids.add(record.pid);
@@ -5330,9 +5380,9 @@ function inspectRpcServerDiscovery(storageDir) {
   }
   for (const staleFile of staleFiles) {
     try {
-      unlinkSync(staleFile);
+      rpcDiscoveryFs.unlinkSync(staleFile);
     } catch {
-      return unreadableDiscovery(staleFile);
+      return unreadableDiscovery(staleFile, "io");
     }
   }
   const serverPids = [...pids].sort((a, b) => a - b);
@@ -5356,10 +5406,14 @@ function enforceMigrationOnOpenGuard(db, dbPath, dbDir, latestSupportedVersion)
     persistedVersion,
     supportedVersion: latestSupportedVersion,
     serverPids: discovery.serverPids,
-    ...discovery.unreadableFile ? { unreadableFile: discovery.unreadableFile } : {}
+    ...discovery.unreadableFile ? { unreadableFile: discovery.unreadableFile } : {},
+    ...discovery.unreadableArm ? { unreadableArm: discovery.unreadableArm } : {}
   };
   if (discovery.state === "unreadable") {
-    log(`[magic-context] storage fatal: refusing to migrate ${dbPath} from upstream migration v${persistedVersion} to v${latestSupportedVersion} because RPC discovery file ${discovery.unreadableFile ?? "<unknown>"} is unreadable or invalid, so the absence of a live OpenCode server cannot be proven. Restart OpenCode, remove or repair the named discovery file, then retry this process.`);
+    const unreadableFile = discovery.unreadableFile ?? "<unknown>";
+    const arm = discovery.unreadableArm ?? "io";
+    const recovery = arm === "io" ? `If no OpenCode server is running, it is safe to delete ${unreadableFile} and retry.` : `Retry after the file is older than the ten-minute grace window, or stop OpenCode before deleting it.`;
+    log(`[magic-context] storage fatal: refusing to migrate ${dbPath} from upstream migration v${persistedVersion} to v${latestSupportedVersion} because RPC discovery file ${unreadableFile} is uncertain (${arm} arm), so the absence of a live OpenCode server cannot be proven. ${recovery}`);
   } else {
     log(`[magic-context] storage fatal: refusing to migrate ${dbPath} from upstream migration v${persistedVersion} to v${latestSupportedVersion} while live OpenCode server PID(s) ${discovery.serverPids.join(", ")} may still use the old plugin build. Restart OpenCode, then retry this process.`);
   }
@@ -5653,6 +5707,7 @@ function initializeDatabase(db) {
       mural_cue TEXT,
       mural_cue_hash TEXT,
       mural_cue_at INTEGER,
+      mural_cue_rejection_count INTEGER NOT NULL DEFAULT 0,
       UNIQUE(project_path, category, normalized_hash)
     );
 
@@ -6676,7 +6731,7 @@ function probeChildSpawnFence(db) {
 }
 // src/features/magic-context/project-docs-hash.ts
 import { createHash as createHash6 } from "node:crypto";
-import { lstatSync, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { lstatSync, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
 import path2 from "node:path";
 var PROJECT_DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 var PROJECT_DOCS_DELIMITER = `
@@ -6707,7 +6762,7 @@ function fingerprintFile(filePath) {
 }
 function readDirectoryMtimeMs(projectDirectory) {
   try {
-    return statSync2(projectDirectory).mtimeMs;
+    return statSync3(projectDirectory).mtimeMs;
   } catch {
     return 0;
   }
@@ -7074,6 +7129,7 @@ function escalationBands(effectiveThresholdPercentage) {
 
 // src/features/magic-context/storage-meta-persisted.ts
 var emergencyRecoveryArmedSessions = new Set;
+var emergencyRecoveryArmedAtBySession = new Map;
 var providerOverflowReconfirmedSessions = new Set;
 function isEmergencyRecoveryArmed(sessionId) {
   return emergencyRecoveryArmedSessions.has(sessionId);
@@ -7081,6 +7137,9 @@ function isEmergencyRecoveryArmed(sessionId) {
 function isProviderOverflowReconfirmed(sessionId) {
   return providerOverflowReconfirmedSessions.has(sessionId);
 }
+function getEmergencyRecoveryArmedAt(sessionId) {
+  return emergencyRecoveryArmedAtBySession.get(sessionId) ?? null;
+}
 var CAS_RETRY_LIMIT = 5;
 var AUTO_SEARCH_NO_HINT_REASONS = new Set([
   "below-threshold",
@@ -7942,6 +8001,7 @@ function getOverflowState(db, sessionId, modelKey) {
 }
 function recordOverflowDetected(db, sessionId, reportedLimit, modelKey, origin = "provider_overflow", provenance = "unknown") {
   emergencyRecoveryArmedSessions.add(sessionId);
+  emergencyRecoveryArmedAtBySession.set(sessionId, Date.now());
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
     const prior = db.prepare("SELECT needs_emergency_recovery FROM session_meta WHERE session_id = ?").get(sessionId);
@@ -7973,6 +8033,7 @@ function clearEmergencyRecovery(db, sessionId) {
     }
   })();
   emergencyRecoveryArmedSessions.delete(sessionId);
+  emergencyRecoveryArmedAtBySession.delete(sessionId);
   providerOverflowReconfirmedSessions.delete(sessionId);
 }
 function clearDetectedContextLimit(db, sessionId) {
@@ -9702,6 +9763,583 @@ function normalizeSDKResponse(response, fallback, options) {
   }
   return fallback;
 }
+// src/shared/prompt-surface.ts
+function isValidPromptSurfaceModelKey(key) {
+  if (key.length === 0 || key.trim() !== key)
+    return false;
+  const slash = key.indexOf("/");
+  if (slash <= 0 || slash === key.length - 1)
+    return false;
+  const provider = key.slice(0, slash);
+  const modelID = key.slice(slash + 1);
+  if (provider.trim() !== provider || modelID.trim() !== modelID || provider.includes("*") || modelID.includes("*") && modelID !== "*") {
+    return false;
+  }
+  if (modelID === "*")
+    return true;
+  return modelID.length > 0 && !modelID.startsWith("/") && !modelID.endsWith("/") && !modelID.includes("//");
+}
+function modelKeyLookupOrder(modelKey) {
+  if (!modelKey)
+    return [];
+  const slash = modelKey.indexOf("/");
+  if (slash <= 0 || slash === modelKey.length - 1)
+    return [];
+  const provider = modelKey.slice(0, slash);
+  let modelID = modelKey.slice(slash + 1);
+  const candidates = [];
+  while (modelID.length > 0) {
+    candidates.push({ key: `${provider}/${modelID}`, source: "exact" });
+    candidates.push({ key: modelID, source: "bare" });
+    const lastDash = modelID.lastIndexOf("-");
+    if (lastDash <= 0)
+      break;
+    modelID = modelID.slice(0, lastDash);
+  }
+  candidates.push({ key: `${provider}/*`, source: "wildcard" });
+  const seen = new Set;
+  return candidates.filter((candidate) => {
+    if (seen.has(candidate.key))
+      return false;
+    seen.add(candidate.key);
+    return true;
+  });
+}
+function resolveModelConfigValue(values, modelKey) {
+  if (!values)
+    return;
+  for (const candidate of modelKeyLookupOrder(modelKey)) {
+    const value = values[candidate.key];
+    if (value !== undefined) {
+      return { value, source: candidate.source };
+    }
+  }
+  return;
+}
+function resolvePromptSurface(config, modelKey) {
+  const fallback = config?.default ?? "full";
+  const match = resolveModelConfigValue(config?.models, modelKey);
+  if (match && match.source !== "bare") {
+    return { preset: match.value, source: match.source };
+  }
+  return { preset: fallback, source: "default" };
+}
+function resolveModelConfigOrDefault(values, modelKey, fallback) {
+  return resolveModelConfigValue(values, modelKey)?.value ?? fallback;
+}
+// src/shared/prompt-surface-runtime.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, statSync as statSync5 } from "node:fs";
+import { dirname as dirname3, isAbsolute as isAbsolute2, resolve } from "node:path";
+
+// src/config/migrate-config-location.ts
+import {
+  closeSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readFileSync as readFileSync4,
+  renameSync,
+  rmSync,
+  statSync as statSync4,
+  unlinkSync as unlinkSync2,
+  writeFileSync
+} from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join4 } 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 || homedir2();
+  }
+  return process.env.HOME || homedir2();
+}
+function configHome() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg && isAbsolute(xdg))
+    return xdg;
+  return join4(homeDir(), ".config");
+}
+function cortexKitUserConfigBasePath() {
+  return join4(configHome(), "cortexkit", CONFIG_FILE_BASENAME);
+}
+function cortexKitProjectConfigBasePath(directory) {
+  return join4(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`,
+    join4(configHome(), "opencode", `${CONFIG_FILE_BASENAME}.jsonc`),
+    join4(configHome(), "opencode", `${CONFIG_FILE_BASENAME}.json`),
+    join4(homeDir(), ".pi", "agent", `${CONFIG_FILE_BASENAME}.jsonc`),
+    join4(homeDir(), ".pi", "agent", `${CONFIG_FILE_BASENAME}.json`)
+  ]);
+}
+function resolveLegacyConfigSources(directory) {
+  const userPaths = userScopeConfigPaths();
+  return {
+    user: [
+      ...legacySourcesForBase(join4(configHome(), "opencode", CONFIG_FILE_BASENAME), "OpenCode user"),
+      ...legacySourcesForBase(join4(homeDir(), ".pi", "agent", CONFIG_FILE_BASENAME), "Pi user")
+    ],
+    project: [
+      ...legacySourcesForBase(join4(directory, CONFIG_FILE_BASENAME), "project root"),
+      ...legacySourcesForBase(join4(directory, ".opencode", CONFIG_FILE_BASENAME), "OpenCode project"),
+      ...legacySourcesForBase(join4(directory, ".pi", CONFIG_FILE_BASENAME), "Pi project")
+    ].filter((source) => !userPaths.has(source.path))
+  };
+}
+function resolveLegacyConfigSourcesForHarness(directory, harness) {
+  if (harness === "pi") {
+    return {
+      user: legacySourcesForBase(join4(homeDir(), ".pi", "agent", CONFIG_FILE_BASENAME), "Pi user"),
+      project: legacySourcesForBase(join4(directory, ".pi", CONFIG_FILE_BASENAME), "Pi project")
+    };
+  }
+  return {
+    user: legacySourcesForBase(join4(configHome(), "opencode", CONFIG_FILE_BASENAME), "OpenCode user"),
+    project: [
+      ...legacySourcesForBase(join4(directory, CONFIG_FILE_BASENAME), "project root"),
+      ...legacySourcesForBase(join4(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 {
+      mkdirSync2(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() - statSync4(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) {
+  mkdirSync2(dirname2(targetPath), { recursive: true });
+  const tmpPath = join4(dirname2(targetPath), `.${basename2(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  let fd = null;
+  try {
+    fd = openSync(tmpPath, "wx", 384);
+    writeFileSync(fd, readFileSync4(sourcePath));
+    closeSync(fd);
+    fd = null;
+    renameSync(tmpPath, targetPath);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+    try {
+      unlinkSync2(tmpPath);
+    } catch {}
+    throw err;
+  }
+}
+function atomicWriteConfigFile(targetPath, content) {
+  mkdirSync2(dirname2(targetPath), { recursive: true });
+  const tmpPath = join4(dirname2(targetPath), `.${basename2(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 {
+      unlinkSync2(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 = readFileSync4(source.path, "utf-8");
+      atomicWriteConfigFile(markerPath, movedMarkerContent(targetPath, basename2(source.path), original));
+      unlinkSync2(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) => existsSync4(source.path));
+  const info = opts.logger?.info ?? opts.logger?.log;
+  if (existingSources.length === 0) {
+    return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
+  }
+  mkdirSync2(dirname2(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: readFileSync4(source.path, "utf-8")
+    }));
+    if (existsSync4(opts.targetPath)) {
+      const targetContent = readFileSync4(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/tools/light-descriptions.ts
+var CTX_REDUCE_LIGHT_DESCRIPTION = `For ctx_reduce users, mark spent §N§ outputs discardable; release is QUEUED, not immediate, so content stays visible until space is needed. Newest tags stay protected until they age out. Released content becomes a placeholder; recover it only by rerunning the source or recovery tool, so mark only genuinely finished material. Mark analyzed, redundant, persisted, or merely confirmatory outputs; keep user messages, unresolved errors, unextracted evidence, and exact wording. NEVER blanket-mark a large range: review every tag first.`;
+var CTX_EXPAND_LIGHT_DESCRIPTION = `For ctx_expand users, recover compacted conversation by passing a session-history heading's inclusive start/end ordinals. Results are raw [N] U:/A: transcript capped near 15K tokens; oversized ranges return the head and a continuation. Use verbose=true to list each message ordinal, part previews, and tool-output sizes; use message=N for one complete stored message and its tool exchanges. NEVER expand ranges after the last compartment because that live tail is already visible.`;
+var CTX_NOTE_LIGHT_DESCRIPTION = `For ctx_note users, write saves, read lists, update changes, and dismiss retires future session notes; surface_condition creates a smart note. For smart notes, NEVER use a condition tied to this conversation or an unobservable future action because the background checker can inspect only external GitHub, disk, git, or web signals.`;
+var CTX_MEMORY_LIGHT_DESCRIPTION = `For ctx_memory users, write one standalone durable fact with category and content; update one ID, archive one or more IDs, merge two or more IDs, or get one to twenty numeric IDs. get reads memories in every status; list remains dreamer-only, so primary agents must NEVER assume bulk-list access.`;
+var CTX_SEARCH_LIGHT_DESCRIPTION = `For ctx_search users, retrieve only hidden recall: memories not already in <project-memory>, compacted messages outside the live tail, commits, and notes. Omit sources for broad search; select memory, message, git_commit, or note to target a source, or pass memory IDs to bypass text search. Message hits continue through ctx_expand.`;
+
+// src/shared/prompt-surface-runtime.ts
+var GUIDANCE_MARKER = "## Magic Context";
+var GUIDANCE_MARKER_LINE = /^## Magic Context[\t ]*\r?$/gm;
+var PROMPT_SURFACE_TOOL_IDS = [
+  "ctx_reduce",
+  "ctx_expand",
+  "ctx_note",
+  "ctx_memory",
+  "ctx_search"
+];
+var LIGHT_TOOL_DESCRIPTIONS = {
+  ctx_reduce: CTX_REDUCE_LIGHT_DESCRIPTION,
+  ctx_expand: CTX_EXPAND_LIGHT_DESCRIPTION,
+  ctx_note: CTX_NOTE_LIGHT_DESCRIPTION,
+  ctx_memory: CTX_MEMORY_LIGHT_DESCRIPTION,
+  ctx_search: CTX_SEARCH_LIGHT_DESCRIPTION
+};
+function promptSurfaceHashMaterial(systemContent, preset = "full") {
+  return preset === "full" ? systemContent : `${systemContent}
+\x00magic-context-prompt-surface:${preset}`;
+}
+var PROMPT_SURFACE_TOOL_ID_SET = new Set(PROMPT_SURFACE_TOOL_IDS);
+function resolveUserConfigDirectory(options) {
+  if (options.userConfigDirectory)
+    return resolve(options.userConfigDirectory);
+  const sharedBase = cortexKitUserConfigBasePath();
+  const shared = detectConfigFile(sharedBase);
+  if (shared.format !== "none")
+    return dirname3(shared.path);
+  if (options.harness) {
+    const legacy = resolveLegacyConfigSourcesForHarness(options.directory ?? process.cwd(), options.harness).user.find((source) => existsSync5(source.path));
+    if (legacy)
+      return dirname3(legacy.path);
+  }
+  return dirname3(sharedBase);
+}
+function markerCount(content) {
+  return content.match(GUIDANCE_MARKER_LINE)?.length ?? 0;
+}
+function createPromptSurfaceRuntime(options) {
+  const userConfigDirectory = resolveUserConfigDirectory(options);
+  const warned = new Set;
+  const warnOnce = (key, message) => {
+    if (warned.has(key))
+      return;
+    warned.add(key);
+    options.warn(message);
+  };
+  const readGuidanceOverride = (configuredPath) => {
+    if (!configuredPath)
+      return;
+    const path3 = isAbsolute2(configuredPath) ? configuredPath : resolve(userConfigDirectory, configuredPath);
+    let content;
+    try {
+      if (!statSync5(path3).isFile()) {
+        warnOnce(`guidance-not-file:${path3}`, `prompt_surface.guidance_override_path (${path3}) is not a file; using built-in guidance.`);
+        return;
+      }
+      content = readFileSync5(path3, "utf8");
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      warnOnce(`guidance-unreadable:${path3}:${reason}`, `prompt_surface.guidance_override_path (${path3}) could not be read (${reason}); using built-in guidance.`);
+      return;
+    }
+    if (content.trim().length === 0) {
+      warnOnce(`guidance-empty:${path3}`, `prompt_surface.guidance_override_path (${path3}) is empty; using built-in guidance.`);
+      return;
+    }
+    const markers = markerCount(content);
+    if (markers !== 1) {
+      warnOnce(`guidance-marker-count:${path3}:${markers}`, `prompt_surface.guidance_override_path (${path3}) must contain exactly one ${JSON.stringify(GUIDANCE_MARKER)} section marker; found ${markers}. Using built-in guidance.`);
+      return;
+    }
+    return content;
+  };
+  return {
+    resolveRegistration(config) {
+      const { preset } = resolvePromptSurface(config, undefined);
+      const overrides = config?.tool_descriptions ?? {};
+      for (const [toolId, description] of Object.entries(overrides)) {
+        if (!PROMPT_SURFACE_TOOL_ID_SET.has(toolId)) {
+          warnOnce(`unknown-tool:${toolId}`, `prompt_surface.tool_descriptions.${toolId} is not a known ctx_* tool ID; the override was ignored.`);
+        } else if (description.trim().length === 0) {
+          warnOnce(`empty-tool:${toolId}`, `prompt_surface.tool_descriptions.${toolId} is empty; the override was ignored.`);
+        }
+      }
+      return {
+        preset,
+        descriptionFor(toolId, fullDescription) {
+          if (!PROMPT_SURFACE_TOOL_ID_SET.has(toolId))
+            return fullDescription;
+          const override = overrides[toolId];
+          if (override !== undefined && override.trim().length > 0)
+            return override;
+          return preset === "light" ? LIGHT_TOOL_DESCRIPTIONS[toolId] : fullDescription;
+        }
+      };
+    },
+    resolveGuidance(config, modelKey) {
+      const { preset } = resolvePromptSurface(config, modelKey);
+      return {
+        preset,
+        primaryOverride: readGuidanceOverride(config?.guidance_override_path)
+      };
+    }
+  };
+}
+function createPromptSurfaceGuidanceEpochCache(runtime) {
+  const epochs = new Map;
+  return {
+    resolve(sessionId, config, modelKey) {
+      const cached = epochs.get(sessionId);
+      if (cached && cached.config === config && cached.modelKey === modelKey) {
+        return cached.selection;
+      }
+      const selection = runtime.resolveGuidance(config, modelKey);
+      epochs.set(sessionId, { config, modelKey, selection });
+      return selection;
+    },
+    clear(sessionId) {
+      epochs.delete(sessionId);
+    }
+  };
+}
 // src/shared/assistant-message-extractor.ts
 function asSessionMessage(value) {
   if (!isRecord(value))
@@ -9837,6 +10475,7 @@ function computeCueContentHash(content) {
   return createHash8("sha256").update(content).digest("hex");
 }
 var muralCueColumnCache = new WeakMap;
+var muralCueRejectionColumnCache = new WeakMap;
 function hasMuralCueColumns(db) {
   const cached = muralCueColumnCache.get(db);
   if (cached !== undefined)
@@ -9846,6 +10485,15 @@ function hasMuralCueColumns(db) {
   muralCueColumnCache.set(db, present);
   return present;
 }
+function hasMuralCueRejectionCountColumn(db) {
+  const cached = muralCueRejectionColumnCache.get(db);
+  if (cached !== undefined)
+    return cached;
+  const columns = db.prepare("PRAGMA table_info(memories)").all();
+  const present = columns.some((column) => column.name === "mural_cue_rejection_count");
+  muralCueRejectionColumnCache.set(db, present);
+  return present;
+}
 function getMuralCueState(db, memoryIds) {
   const out = new Map;
   if (!hasMuralCueColumns(db))
@@ -9854,9 +10502,14 @@ function getMuralCueState(db, memoryIds) {
   if (ids.length === 0)
     return out;
   const placeholders3 = ids.map(() => "?").join(", ");
-  const rows = db.prepare(`SELECT id, mural_cue, mural_cue_hash FROM memories WHERE id IN (${placeholders3})`).all(...ids);
+  const rejectionCountColumn = hasMuralCueRejectionCountColumn(db) ? "COALESCE(mural_cue_rejection_count, 0) AS mural_cue_rejection_count" : "0 AS mural_cue_rejection_count";
+  const rows = db.prepare(`SELECT id, mural_cue, mural_cue_hash, ${rejectionCountColumn} FROM memories WHERE id IN (${placeholders3})`).all(...ids);
   for (const row of rows) {
-    out.set(row.id, { cue: row.mural_cue ?? null, hash: row.mural_cue_hash ?? null });
+    out.set(row.id, {
+      cue: row.mural_cue ?? null,
+      hash: row.mural_cue_hash ?? null,
+      ...row.mural_cue_rejection_count > 0 ? { rejectionCount: row.mural_cue_rejection_count } : {}
+    });
   }
   return out;
 }
@@ -9873,8 +10526,24 @@ function setMuralCue(db, projectPath, id, cue, contentHash) {
     if (!owned) {
       throw new Error(`Memory ${id} does not belong to project ${projectPath}`);
     }
-    db.prepare("UPDATE memories SET mural_cue = ?, mural_cue_hash = ?, mural_cue_at = ? WHERE id = ? AND project_path = ?").run(cue, contentHash, Date.now(), id, projectPath);
+    const rejectionReset = hasMuralCueRejectionCountColumn(db) ? ", mural_cue_rejection_count = 0" : "";
+    db.prepare(`UPDATE memories SET mural_cue = ?, mural_cue_hash = ?, mural_cue_at = ?${rejectionReset} WHERE id = ? AND project_path = ?`).run(cue, contentHash, Date.now(), id, projectPath);
+  });
+}
+function recordMuralCueRejection(db, projectPath, id, contentHash) {
+  if (!hasMuralCueColumns(db) || !hasMuralCueRejectionCountColumn(db))
+    return 0;
+  let count = 0;
+  withPrivilegedWriter(db, () => {
+    const owned = db.prepare("SELECT 1 FROM memories WHERE id = ? AND project_path = ?").get(id, projectPath);
+    if (!owned) {
+      throw new Error(`Memory ${id} does not belong to project ${projectPath}`);
+    }
+    const row = db.prepare("SELECT mural_cue_hash, mural_cue_rejection_count FROM memories WHERE id = ?").get(id);
+    count = row?.mural_cue_hash === contentHash ? (row.mural_cue_rejection_count ?? 0) + 1 : 1;
+    db.prepare("UPDATE memories SET mural_cue = NULL, mural_cue_hash = ?, mural_cue_at = ?, mural_cue_rejection_count = ? WHERE id = ? AND project_path = ?").run(contentHash, Date.now(), count, id, projectPath);
   });
+  return count;
 }
 
 // src/features/magic-context/memory/storage-memory-embeddings.ts
@@ -11655,7 +12324,7 @@ function countSessionCompartmentEmbedCoverage(db, projectPath, sessionId, modelI
 import { createHash as createHash12, randomUUID as randomUUID2 } from "node:crypto";
 
 // src/config/schema/magic-context.ts
-import { homedir as homedir2 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -26112,6 +26781,23 @@ var PiThinkingLevelSchema = exports_external.enum(["off", "minimal", "low", "med
 var PiConfigSchema = exports_external.object({
   subagent_extensions: exports_external.array(exports_external.string().trim().min(1)).optional().describe("User-only allowlist of Pi extensions for Magic Context subagent children. When set, children use --no-extensions and load only these entries (plus Magic Context's scoped child extension where applicable). Relative paths resolve from ~/.pi/agent, matching Pi's settings.json package location. Unset preserves normal Pi extension discovery.")
 }).optional();
+var PromptSurfacePresetSchema = exports_external.enum(["full", "light"]);
+var PromptSurfaceModelKeySchema = exports_external.string().refine(isValidPromptSurfaceModelKey, {
+  message: "Use a non-empty provider/model key or the literal provider/* wildcard; model IDs may contain additional slashes and matching is case-sensitive."
+});
+var PromptSurfaceToolKeySchema = exports_external.string().refine((value) => value.trim().length > 0, {
+  message: "tool description keys must not be empty or whitespace-only"
+});
+var PromptSurfaceConfigSchema = exports_external.object({
+  default: PromptSurfacePresetSchema.default("full").describe('Fallback prompt-surface preset ("full" or "light").'),
+  models: exports_external.record(PromptSurfaceModelKeySchema, PromptSurfacePresetSchema).optional().describe("Literal per-model routing. Keys are provider/model or provider/*; matching is case-sensitive and preserves additional slashes in model IDs."),
+  guidance_override_path: exports_external.string().refine((value) => value.trim().length > 0, {
+    message: "guidance_override_path must not be empty or whitespace-only"
+  }).optional().describe("USER-LEVEL ONLY path to a complete primary guidance section. Relative paths resolve from the user config file."),
+  tool_descriptions: exports_external.record(PromptSurfaceToolKeySchema, exports_external.string().refine((value) => value.trim().length > 0, {
+    message: "tool description values must not be empty or whitespace-only"
+  })).optional().describe("USER-LEVEL ONLY top-level description overrides keyed by ctx_* tool ID; parameter schemas and descriptions are unchanged.")
+}).describe("Prompt-surface preset routing. Project config may select default/models, while guidance_override_path and tool_descriptions are user-level only.");
 var CronScheduleSchema = exports_external.string().refine((s) => s.trim() === "" || isValidCron(s), {
   message: 'Invalid schedule: use a 5-field cron expression (e.g. "0 3 * * *" for 3am daily, "0 3 * * 0" for Sunday 3am, "0 */6 * * *" every 6h) or "" to disable.'
 }).describe('5-field cron schedule (e.g. "0 3 * * *"), or "" to disable this task.');
@@ -26188,9 +26874,9 @@ var EmbeddingFallbackProviderSchema = exports_external.enum(["local", "openai-co
 function expandConfigPath(value) {
   const trimmed = value.trim();
   if (trimmed === "~")
-    return homedir2();
+    return homedir3();
   if (trimmed.startsWith("~/"))
-    return `${homedir2()}/${trimmed.slice(2)}`;
+    return `${homedir3()}/${trimmed.slice(2)}`;
   return trimmed;
 }
 var BaseEmbeddingConfigSchema = exports_external.object({
@@ -26294,6 +26980,7 @@ var MagicContextConfigSchema = exports_external.object({
   historian: HistorianConfigSchema.describe("Historian agent configuration (model, fallback_models, variant, temperature, maxTokens, permission, two_pass, etc.)"),
   dreamer: DreamerConfigSchema.optional().describe("Dreamer agent + scheduling configuration (model, fallback_models, disable, schedule, tasks, etc.)"),
   cache_ttl: exports_external.union([exports_external.string(), exports_external.object({ default: exports_external.string() }).catchall(exports_external.string())]).default("5m").describe('Cache TTL: string (e.g. "5m", "1h", "30s") or per-model object ({ default: "5m", "model-id": "10m" }). Set to "never" for lanes kept warm by an external keepwarm proxy — disables the idle-TTL heuristic so MC never initiates a rebuild based on elapsed time.'),
+  prompt_surface: PromptSurfaceConfigSchema.default({ default: "full" }).describe("Prompt-surface presets: default is full; models use the literal provider/model or provider/* routing grammar. Guidance and tool-description overrides are user-level only. On OpenCode and Pi, per-model routing applies to the guidance block only: tool descriptions are registered once per process, so they follow the default preset (a v1 plugin-surface limitation; per-model tool descriptions are planned for the OpenCode v2 plugin API once the SDK stabilizes)."),
   output_reserve: exports_external.union([
     exports_external.number().min(0),
     exports_external.object({ default: exports_external.number().min(0) }).catchall(exports_external.number().min(0))
@@ -26342,7 +27029,7 @@ var MagicContextConfigSchema = exports_external.object({
   keep_subagents: exports_external.boolean().default(false).describe("Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, sidekick, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect."),
   fail_closed_blocking: exports_external.boolean().default(true).describe("When Magic Context cannot operate (schema fence mismatch, storage open/migration failure), block the primary-session prompt with a loud recovery error instead of silently degrading to native compaction. Default true. Set false only to restore the old degrade-silently behavior (not recommended). USER-LEVEL ONLY — ignored in project config for security. Requires a restart."),
   compaction: exports_external.object({
-    enabled: exports_external.boolean().default(true).describe("When false, Magic Context stops managing the context window and keeps its knowledge layer: memory and docs/user-profile/key-files injection through additive m[0]/m[1], raw-message FTS indexing, dreamer, notes, ctx_search, ctx_expand, ctx_memory, and /ctx-embed remain available. MC's historian/compartment preparation, tagging, markers, pruning, folding, drops, strips, splicing, synthetic context-management todos, temporal markers, nudges, and fail-closed blocking stop; ctx_expand remains a knowledge-surface tool. fail_closed_blocking is inert: a transform failure passes the input messages through without blocking or cancelling. This setting does not enable native compaction: OpenCode's compaction.auto / compaction.prune or Pi's equivalent owns the window, or nothing does. MC's compaction.enabled in magic-context.jsonc is distinct from OpenCode's compaction.auto / compaction.prune in opencode.jsonc; they are different files and different owners. On the first turn after disabling, a long session may trigger one native compaction cycle; MC removes only its own marker boundary, leaves native boundaries and stored compartments intact, and does no pre-trimming mitigation. Marker cleanup is lazy per session, so an unresumed session is cleaned when it is next resumed. If compaction is enabled again, run /ctx-wrapup when the historian is runnable to catch up. OpenCode peer verification against v1.18.4 confirms native compaction covers child sessions: subagents receive additive memory/docs injection and no MC reclaim in this mode, so keep subagent tasks small or leave compaction.enabled on for long subagent runs. If transform_mode is rust, compaction-off resolves to the TypeScript transform and emits one frozen boot warning because there is no Rust reduced-mode contract. This is boot-resolved and requires a process restart; project-tier compaction.enabled is stripped so a cloned repository cannot disable the user's setting. The sidebar reports raw usage as Context: <pct>% · native compaction or Context: <pct>% · no active compaction and does not show an MC execute-threshold fill. /ctx-wrapup, /ctx-recomp, /ctx-flush, and /ctx-session-upgrade refuse without context-management side effects; /ctx-embed remains functional. Raw content hidden by a native boundary before Magic Context's first pass is not retroactively indexed.")
+    enabled: exports_external.boolean().default(true).describe("When false, Magic Context stops managing the context window and keeps its knowledge layer: memory and docs/user-profile/key-files injection through additive m[0]/m[1], raw-message FTS indexing, dreamer, notes, ctx_search, ctx_expand, ctx_memory, and /ctx-embed remain available. MC's historian/compartment preparation, tagging, markers, pruning, folding, drops, strips, splicing, synthetic context-management todos, temporal markers, nudges, and fail-closed blocking stop; ctx_expand remains a knowledge-surface tool. fail_closed_blocking is inert: a transform failure passes the input messages through without blocking or cancelling. This setting does not enable native compaction: OpenCode's compaction.auto / compaction.prune or Pi's equivalent owns the window, or nothing does. MC's compaction.enabled in magic-context.jsonc is distinct from OpenCode's compaction.auto / compaction.prune in opencode.jsonc; they are different files and different owners. On the first turn after disabling, a long session may trigger one native compaction cycle; MC removes only its own marker boundary, leaves native boundaries and stored compartments intact, and does no pre-trimming mitigation. Marker cleanup is lazy per session, so an unresumed session is cleaned when it is next resumed. If compaction is enabled again, run /ctx-wrapup when the historian is runnable to catch up. OpenCode peer verification against v1.18.4 confirms native compaction covers child sessions: subagents receive additive memory/docs injection and no MC reclaim in this mode, so keep subagent tasks small or leave compaction.enabled on for long subagent runs. This is boot-resolved and requires a process restart; project-tier compaction.enabled is stripped so a cloned repository cannot disable the user's setting. The sidebar reports raw usage as Context: <pct>% · native compaction or Context: <pct>% · no active compaction and does not show an MC execute-threshold fill. /ctx-wrapup, /ctx-recomp, /ctx-flush, and /ctx-session-upgrade refuse without context-management side effects; /ctx-embed remains functional. Raw content hidden by a native boundary before Magic Context's first pass is not retroactively indexed.")
   }).default({ enabled: true }).describe("Compaction-off mode gate. Default true (MC manages the context window as today). Set compaction.enabled=false to keep the knowledge layer while letting native compaction (or nothing) own the window. Boot-resolved; requires a restart to change."),
   todowrite: exports_external.object({
     enabled: exports_external.boolean().default(true).describe("Pi only: register Magic Context's todowrite task-list tool. Disable if you use your own todo extension. OpenCode ships its own built-in todowrite; this setting has no effect there."),
@@ -27075,7 +27762,7 @@ class SubcSocket {
     return this.sock.localPort ?? null;
   }
   static connect(host, port, deadlineMs) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const sock = net.connect({ host, port });
       sock.setNoDelay(true);
       const timer = setTimeout(() => {
@@ -27084,7 +27771,7 @@ class SubcSocket {
       }, Math.max(0, deadlineMs - Date.now()));
       sock.once("connect", () => {
         clearTimeout(timer);
-        resolve(new SubcSocket(sock));
+        resolve2(new SubcSocket(sock));
       });
       sock.once("error", (err) => {
         clearTimeout(timer);
@@ -27116,7 +27803,7 @@ class SubcSocket {
     }
     if (n === 0)
       return Promise.resolve(new Uint8Array(0));
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let timer = null;
       if (Number.isFinite(deadlineMs)) {
         const remaining = deadlineMs - Date.now();
@@ -27129,7 +27816,7 @@ class SubcSocket {
           reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
         }, remaining);
       }
-      this.waiter = { need: n, resolve, reject, timer };
+      this.waiter = { need: n, resolve: resolve2, reject, timer };
       this.tryServe();
     });
   }
@@ -27153,7 +27840,7 @@ class SubcSocket {
     let queued = false;
     let settled = false;
     let timer = null;
-    const completed = new Promise((resolve, reject) => {
+    const completed = new Promise((resolve2, reject) => {
       const settle = (run) => {
         if (settled)
           return;
@@ -27177,7 +27864,7 @@ class SubcSocket {
             if (err) {
               reject(new SocketWriteQueuedError("subc socket reported a write error after bytes were handed to the socket", err instanceof Error ? err : new Error(String(err))));
             } else {
-              resolve();
+              resolve2();
             }
           });
         });
@@ -27393,14 +28080,14 @@ class SubcClient {
     const admission = opts.admissionClass ?? AdmissionClass.Normal;
     const corr = this.allocateCorr();
     const key = pendingKey(handle, corr);
-    const closed = new Promise((resolve, reject) => {
+    const closed = new Promise((resolve2, reject) => {
       if (this.closedErr) {
         reject(this.closedErr);
         return;
       }
       this.pending.set(key, {
         handle,
-        resolve: () => resolve(),
+        resolve: () => resolve2(),
         reject,
         onProgress: onEvent,
         timer: null,
@@ -27485,11 +28172,11 @@ class SubcClient {
     const waiters = [];
     for (const pending of this.pending.values()) {
       if (pending.handle === handle && !pending.subscription) {
-        waiters.push(new Promise((resolve) => {
+        waiters.push(new Promise((resolve2) => {
           const previous = pending.onSettle;
           pending.onSettle = () => {
             previous?.();
-            resolve();
+            resolve2();
           };
         }));
       }
@@ -27545,11 +28232,11 @@ class SubcClient {
     const channel = handle?.channel ?? 0;
     const epoch = handle?.epoch ?? 0;
     const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), channel, epoch, corr, body);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
       const pending = {
         handle,
-        resolve,
+        resolve: resolve2,
         reject,
         onProgress,
         timer: null,
@@ -27623,11 +28310,11 @@ class SubcClient {
       }
       return this.outcomeUnknownCallError("connection dropped before the managed call returned a response", error51);
     };
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
       const pending = {
         handle,
-        resolve,
+        resolve: resolve2,
         reject,
         onProgress,
         timer: null,
@@ -28015,7 +28702,7 @@ function normalizeConnectOptions(opts) {
     identity: opts.identity,
     targetKind: opts.targetKind ?? DEFAULT_MANAGED_TARGET_KIND,
     reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
-    sleep: opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+    sleep: opts.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms))),
     timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS
   };
 }
@@ -28072,8 +28759,8 @@ class AsyncPermitPool {
       this.available -= 1;
       return this.releaseOnce();
     }
-    await new Promise((resolve) => {
-      this.waiters.push(resolve);
+    await new Promise((resolve2) => {
+      this.waiters.push(resolve2);
     });
     return this.releaseOnce();
   }
@@ -28129,8 +28816,8 @@ class SubcProvider {
     this.currentConn = currentConn;
     this.opts = opts;
     this.storage = storage;
-    this.closed = new Promise((resolve) => {
-      this.resolveClosed = resolve;
+    this.closed = new Promise((resolve2) => {
+      this.resolveClosed = resolve2;
     });
     this.readLoop(sock, this.generation);
     this.enqueueConnectionState({ state: "connected", epoch: this.connectionEpoch });
@@ -28150,13 +28837,13 @@ class SubcProvider {
     const key = routeKey(handle, corr);
     const timeoutMs = opts.timeoutMs ?? WRITE_TIMEOUT_MS;
     const frame = buildFrame(FrameType.Request, buildFlags(false, opts.priority ?? Priority.Interactive, false, opts.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, corr, body);
-    return await new Promise((resolve, reject) => {
+    return await new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         if (this.pending.delete(key))
           reject(new SubcProviderError("reverse request timed out", "request_timeout"));
       }, timeoutMs);
       this.pending.set(key, {
-        resolve: (response) => resolve(response.body),
+        resolve: (response) => resolve2(response.body),
         reject,
         timer
       });
@@ -28628,7 +29315,7 @@ function normalizeProviderConnectOptions(opts) {
     onBound: opts.onBound,
     onRouteGone: opts.onRouteGone,
     reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
-    sleep: opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+    sleep: opts.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms))),
     restoredDebounceMs: opts.restoredDebounceMs ?? DEFAULT_RESTORED_DEBOUNCE_MS,
     onConnectionState: opts.onConnectionState,
     launchNonce: opts.launchNonce
@@ -28673,7 +29360,7 @@ function errorCode2(err) {
   return;
 }
 async function pauseBeforeStateRetry() {
-  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve2) => setTimeout(resolve2, 0));
 }
 function controlFlags() {
   return buildFlags(false, Priority.Passive, false);
@@ -28911,7 +29598,7 @@ function classifyError(value) {
   });
 }
 function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function sha256(value) {
   return createHash11("sha256").update(value).digest("hex");
@@ -29378,9 +30065,9 @@ function getEmbeddingProviderIdentity(config2) {
 }
 
 // src/features/magic-context/memory/embedding-local.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync3 } from "node:fs";
 import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { dirname as dirname4, join as join5 } from "node:path";
 import { pathToFileURL } from "node:url";
 var LOCK_POLL_MS = 150;
 var STALE_LOCK_MS = 3 * 60000;
@@ -29420,7 +30107,7 @@ async function acquireModelLoadLock(lockPath) {
       if (Date.now() - waitStart > MAX_LOCK_WAIT_MS) {
         throw new Error(`[magic-context] embedding-load lock wait exceeded ${MAX_LOCK_WAIT_MS}ms; another process is still loading the model. Skipping this init attempt to avoid an unsynchronized native load.`);
       }
-      await new Promise((resolve) => setTimeout(resolve, LOCK_POLL_MS));
+      await new Promise((resolve2) => setTimeout(resolve2, LOCK_POLL_MS));
     }
   }
 }
@@ -29444,7 +30131,7 @@ async function injectWasmOrtForElectron() {
       const { createRequire: createRequireFn } = await import("node:module");
       const requireFn = createRequireFn(import.meta.url);
       const mainEntry = requireFn.resolve("onnxruntime-web");
-      const distDir = dirname2(mainEntry);
+      const distDir = dirname4(mainEntry);
       const wasmPathsPrefix = `${pathToFileURL(distDir).href}/`;
       if (ortWeb.env?.wasm) {
         ortWeb.env.wasm.wasmPaths = wasmPathsPrefix;
@@ -29581,24 +30268,24 @@ class LocalEmbeddingProvider {
         if (LogLevel && "ERROR" in LogLevel) {
           env.logLevel = LogLevel.ERROR;
         }
-        const modelCacheDir = join4(getMagicContextStorageDir(), "models");
+        const modelCacheDir = join5(getMagicContextStorageDir(), "models");
         try {
           if (shouldEnforcePrivateStoragePermissions()) {
-            mkdirSync2(modelCacheDir, { recursive: true, mode: 448 });
+            mkdirSync3(modelCacheDir, { recursive: true, mode: 448 });
             if (process.platform !== "win32") {
               try {
                 chmodSync2(modelCacheDir, 448);
               } catch {}
             }
           } else {
-            mkdirSync2(modelCacheDir, { recursive: true });
+            mkdirSync3(modelCacheDir, { recursive: true });
           }
           env.cacheDir = modelCacheDir;
         } catch {
           log("[magic-context] could not create model cache dir, using library default");
         }
         const createPipeline = transformersModule.pipeline;
-        const lockPath = join4(modelCacheDir, ".load.lock");
+        const lockPath = join5(modelCacheDir, ".load.lock");
         const releaseLock = await acquireModelLoadLock(lockPath);
         const stopHeartbeat = startLockHeartbeat(lockPath);
         try {
@@ -29625,7 +30312,7 @@ class LocalEmbeddingProvider {
               }
               const delayMs = 300 * attempt + Math.floor(Math.random() * 200);
               log(`[magic-context] embedding model load attempt ${attempt}/${MAX_ATTEMPTS} failed transiently, retrying in ${delayMs}ms`);
-              await new Promise((resolve) => setTimeout(resolve, delayMs));
+              await new Promise((resolve2) => setTimeout(resolve2, delayMs));
             }
           }
           if (this.pipeline) {
@@ -29658,8 +30345,8 @@ class LocalEmbeddingProvider {
     if (this.inFlight === 0) {
       return Promise.resolve();
     }
-    return new Promise((resolve) => {
-      this.inFlightWaiters.push(resolve);
+    return new Promise((resolve2) => {
+      this.inFlightWaiters.push(resolve2);
     });
   }
   finishInFlight() {
@@ -31035,7 +31722,7 @@ async function runShadowWorker() {
     }
     processed += item.ids.length;
     processedBytes += itemBytes;
-    await new Promise((resolve) => setTimeout(resolve, 0));
+    await new Promise((resolve2) => setTimeout(resolve2, 0));
   }
 }
 function registerProjectInObservationMode(db, projectIdentity, sourceDirectory, failedConfig, failureSummary) {
@@ -31396,7 +32083,7 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
       if (Date.now() - attemptStart >= EMBED_SLOW_FAILURE_NO_RETRY_MS)
         break;
       if (attempt < EMBED_SLICE_RETRY_ATTEMPTS - 1) {
-        await new Promise((resolve) => setTimeout(resolve, EMBED_SLICE_RETRY_BASE_MS * 2 ** attempt));
+        await new Promise((resolve2) => setTimeout(resolve2, EMBED_SLICE_RETRY_BASE_MS * 2 ** attempt));
       }
     }
     embedded += persistedIds.size;
@@ -31481,7 +32168,7 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
       }
       embedded += n;
       options?.onProgress?.({ embedded: Math.min(embedded, total), total });
-      await new Promise((resolve) => setTimeout(resolve, 0));
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
     }
   } finally {
     clearInterval(renewal);
@@ -31625,12 +32312,12 @@ function parseFields(json2) {
 }
 
 // src/hooks/magic-context/historian-state-file.ts
-import { mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
+import { mkdirSync as mkdirSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
 function cleanupHistorianStateFile(path3) {
   if (!path3)
     return;
   try {
-    unlinkSync2(path3);
+    unlinkSync3(path3);
   } catch {}
 }
 // src/features/magic-context/memory/cosine-similarity.ts
@@ -31952,7 +32639,7 @@ function getMemoryVerifications(db, memoryIds) {
 }
 // src/features/magic-context/memory/verification-paths.ts
 import { execFile } from "node:child_process";
-import { existsSync as existsSync4, realpathSync as realpathSync2, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync6, realpathSync as realpathSync2, statSync as statSync6 } from "node:fs";
 import path3 from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
@@ -32059,7 +32746,7 @@ function verificationFileExists(baseRoot, filePath) {
     return false;
   const root = path3.resolve(baseRoot);
   const candidate = path3.resolve(root, filePath);
-  return isWithin(root, candidate) && existsSync4(candidate);
+  return isWithin(root, candidate) && existsSync6(candidate);
 }
 async function normalizeVerificationFiles(args) {
   const cwd = path3.resolve(args.cwd);
@@ -32092,9 +32779,9 @@ async function normalizeVerificationFiles(args) {
       warnings.push(`Skipped verification path "${value}" because it is the repo/project root.`);
       continue;
     }
-    if (existsSync4(candidate)) {
+    if (existsSync6(candidate)) {
       try {
-        if (statSync3(candidate).isDirectory()) {
+        if (statSync6(candidate).isDirectory()) {
           warnings.push(`Skipped verification path "${value}" because it is a directory.`);
           continue;
         }
@@ -32123,7 +32810,7 @@ async function normalizeVerificationFiles(args) {
       }
       normalized.push(tracked);
     } else {
-      if (!existsSync4(candidate)) {
+      if (!existsSync6(candidate)) {
         warnings.push(`Skipped verification path "${value}" because it does not exist.`);
         continue;
       }
@@ -32183,12 +32870,12 @@ function tallyFactsByCategory(facts) {
 }
 
 // src/hooks/magic-context/compaction-marker-manager.ts
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // src/features/magic-context/compaction-marker.ts
 import { createHash as createHash13 } from "node:crypto";
-import { existsSync as existsSync5 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join6 } from "node:path";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 var ID_PREFIX_HEX_LENGTH = 12;
 var ID_SUFFIX_LENGTH = 14;
@@ -32214,7 +32901,7 @@ function generatePartId(timestampMs, counter = 0n, identity = "") {
   return generateId("prt", timestampMs, counter, identity);
 }
 function getOpenCodeDbPath() {
-  return join5(getDataDir(), "opencode", "opencode.db");
+  return join6(getDataDir(), "opencode", "opencode.db");
 }
 var cachedWriteDb = null;
 var REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
@@ -32259,7 +32946,7 @@ function getWritableOpenCodeDb() {
       closeQuietly(cachedWriteDb.db);
     } catch {}
   }
-  if (!existsSync5(dbPath)) {
+  if (!existsSync7(dbPath)) {
     throw new Error(`OpenCode database not found at ${dbPath} (is OpenCode installed?)`);
   }
   const db = new Database(dbPath);
@@ -32882,7 +33569,7 @@ function reconcileForkOrphanedCompactionMarkers(db, sessionId) {
   }
 }
 function checkCompactionMarkerConsistency(db) {
-  const opencodeDbPath = join6(getDataDir(), "opencode", "opencode.db");
+  const opencodeDbPath = join7(getDataDir(), "opencode", "opencode.db");
   let opencodeDb;
   try {
     opencodeDb = new Database(opencodeDbPath, { readonly: true });
@@ -33860,8 +34547,8 @@ function queueDropsForCompartmentalizedMessages(db, sessionId, upToMessageIndex)
 }
 
 // src/hooks/magic-context/compartment-runner-historian.ts
-import { mkdirSync as mkdirSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join7 } from "node:path";
+import { mkdirSync as mkdirSync5, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // src/features/magic-context/subagent-token-capture.ts
 function asNumber(value) {
@@ -33991,6 +34678,7 @@ function mapParsedCompartmentsToChunk(compartments, chunk, sequenceOffset) {
 
 // src/hooks/magic-context/compartment-runner-validation.ts
 var MIN_RECOMP_CHUNK_TOKEN_BUDGET = 20;
+var HISTORIAN_BOUNDARY_HEALING_SLACK = 2;
 function healCompartmentGaps(compartments, toolOnlyRanges = []) {
   for (let i = 1;i < compartments.length; i++) {
     const prev = compartments[i - 1];
@@ -34006,6 +34694,36 @@ function healCompartmentGaps(compartments, toolOnlyRanges = []) {
     }
   }
 }
+function boundarySplitsCompletedToolArc(boundary, arcs = []) {
+  return arcs.some((arc) => completedToolArcCrossesBoundary(arc.start, arc.end, boundary));
+}
+function healTerminalCompletedToolArc(compartments, unprocessedFrom, arcs = [], chunkEnd) {
+  const last = compartments[compartments.length - 1];
+  if (!last)
+    return unprocessedFrom;
+  const originalEnd = last.endMessage;
+  for (let pass = 0;pass <= arcs.length; pass += 1) {
+    const boundary = last.endMessage + 1;
+    let nextEnd = last.endMessage;
+    for (const arc of arcs) {
+      if (arc.end <= chunkEnd && completedToolArcCrossesBoundary(arc.start, arc.end, boundary)) {
+        nextEnd = Math.max(nextEnd, arc.end);
+      }
+    }
+    if (nextEnd === last.endMessage)
+      break;
+    last.endMessage = nextEnd;
+  }
+  return last.endMessage !== originalEnd && unprocessedFrom !== null ? last.endMessage + 1 : unprocessedFrom;
+}
+function shouldDiscardLastHistorianCompartment(compartments, chunk) {
+  if (compartments.length < 2)
+    return false;
+  const last = compartments[compartments.length - 1];
+  const previous = compartments[compartments.length - 2];
+  const lookaheadMargin = chunk.endIndex - last.endMessage;
+  return lookaheadMargin <= HISTORIAN_BOUNDARY_HEALING_SLACK && !boundarySplitsCompletedToolArc(previous.endMessage + 1, chunk.completedToolArcs);
+}
 function validateHistorianOutput(text, _sessionId, chunk, _priorCompartments, sequenceOffset) {
   const parsed = parseCompartmentOutput(text);
   if (parsed.compartments.length === 0) {
@@ -34015,6 +34733,7 @@ function validateHistorianOutput(text, _sessionId, chunk, _priorCompartments, se
     };
   }
   healCompartmentGaps(parsed.compartments, chunk.toolOnlyRanges);
+  parsed.unprocessedFrom = healTerminalCompletedToolArc(parsed.compartments, parsed.unprocessedFrom, chunk.completedToolArcs, chunk.endIndex);
   const mapped = mapParsedCompartmentsToChunk(parsed.compartments, chunk, sequenceOffset);
   if (!mapped.ok) {
     return {
@@ -34029,6 +34748,13 @@ function validateHistorianOutput(text, _sessionId, chunk, _priorCompartments, se
       error: `Historian returned invalid compartment output: ${parsedValidationError}`
     };
   }
+  const last = parsed.compartments[parsed.compartments.length - 1];
+  if (last && boundarySplitsCompletedToolArc(last.endMessage + 1, chunk.completedToolArcs)) {
+    return {
+      ok: false,
+      error: "Historian terminal boundary splits a completed tool invocation/result arc"
+    };
+  }
   return {
     ok: true,
     compartments: mapped.compartments,
@@ -34471,15 +35197,15 @@ function isTransientHistorianPromptError(message) {
   ].some((token) => normalized.includes(token));
 }
 function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
   });
 }
 function cleanupHistorianDump(sessionId, dumpPath) {
   if (!dumpPath)
     return;
   try {
-    unlinkSync3(dumpPath);
+    unlinkSync4(dumpPath);
   } catch (error51) {
     sessionLog(sessionId, "compartment agent: failed to remove historian response dump", {
       dumpPath,
@@ -34490,12 +35216,12 @@ function cleanupHistorianDump(sessionId, dumpPath) {
 function dumpHistorianResponse(sessionId, directory, label, text) {
   try {
     const dumpDir = historianResponseDumpDir(directory);
-    mkdirSync4(dumpDir, { recursive: true });
+    mkdirSync5(dumpDir, { recursive: true });
     ensureCortexKitArtifactGitignore(directory);
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join7(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
-    writeFileSync2(dumpPath, text, "utf8");
+    const dumpPath = join8(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    writeFileSync3(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
       dumpPath
@@ -37453,513 +38179,6 @@ function clearNoteNudgeTriggerOnly(db, sessionId) {
   db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 0, note_nudge_trigger_message_id = '' WHERE session_id = ?").run(sessionId);
 }
 
-// src/hooks/magic-context/read-session-true-raw-tokens.ts
-var MAX_MESSAGE_CACHE_ENTRIES = 1e5;
-var MAX_MESSAGE_CACHE_KEY_BYTES = 64 * 1024 * 1024;
-var FNV1A_32_OFFSET = 2166136261;
-var FNV1A_32_PRIME = 16777619;
-var messageEstimateCache = new Map;
-var messageEstimateCacheBytes = 0;
-var EMPTY_BREAKDOWN = {
-  text: 0,
-  reasoning: 0,
-  toolInput: 0,
-  toolOutput: 0,
-  image: 0,
-  other: 0,
-  total: 0
-};
-function addBreakdown(target, kind, value) {
-  if (kind === "total")
-    return;
-  const safeValue = Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
-  target[kind] += safeValue;
-  target.total += safeValue;
-}
-function estimateStructured(value) {
-  if (typeof value === "string")
-    return estimateTokens(value);
-  if (value === undefined || value === null)
-    return 0;
-  return estimateTokens(stableStringify(value));
-}
-function firstStringField(record2, fields) {
-  for (const field of fields) {
-    const value = record2[field];
-    if (typeof value === "string" && value.length > 0)
-      return value;
-  }
-  return null;
-}
-function stringValue(value) {
-  if (typeof value === "string")
-    return value;
-  if (value === undefined || value === null)
-    return "";
-  return stableStringify(value);
-}
-function textFromToolResultContent(content) {
-  if (typeof content === "string")
-    return content;
-  if (Array.isArray(content)) {
-    const pieces = [];
-    for (const entry of content) {
-      if (typeof entry === "string") {
-        pieces.push(entry);
-      } else if (isRecord(entry)) {
-        const text = firstStringField(entry, ["text", "content", "value"]);
-        pieces.push(text ?? stableStringify(entry));
-      } else if (entry !== null && entry !== undefined) {
-        pieces.push(String(entry));
-      }
-    }
-    return pieces.join(`
-`);
-  }
-  return stringValue(content);
-}
-function looksImageLike(part) {
-  const type = typeof part.type === "string" ? part.type.toLowerCase() : "";
-  const mime = typeof part.mime === "string" ? part.mime.toLowerCase() : "";
-  const mediaType = typeof part.mediaType === "string" ? part.mediaType.toLowerCase() : "";
-  return type.includes("image") || mime.startsWith("image/") || mediaType.startsWith("image/") || part.image_url !== undefined || part.imageUrl !== undefined || part.image !== undefined;
-}
-function defaultImageTokenHeuristic(part) {
-  if (isRecord(part)) {
-    const width = part.width;
-    const height = part.height;
-    if (typeof width === "number" && typeof height === "number" && width > 0 && height > 0) {
-      return Math.max(256, Math.min(4096, Math.ceil(width * height / 750)));
-    }
-  }
-  return 1024;
-}
-function partType(part) {
-  return typeof part.type === "string" ? part.type : "";
-}
-function hasOwn(record2, key) {
-  return Object.hasOwn(record2, key);
-}
-function recursiveByteLength(value) {
-  if (value === null || value === undefined)
-    return 0;
-  if (typeof value === "string")
-    return value.length;
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value).length;
-  }
-  if (Array.isArray(value)) {
-    return value.reduce((sum, item) => sum + recursiveByteLength(item), value.length);
-  }
-  if (isRecord(value)) {
-    let total = Object.keys(value).length;
-    for (const [key, child] of Object.entries(value)) {
-      total += key.length + recursiveByteLength(child);
-    }
-    return total;
-  }
-  return String(value).length;
-}
-function updateFnv1a32(hash2, text) {
-  let next = hash2;
-  for (let index = 0;index < text.length; index += 1) {
-    next ^= text.charCodeAt(index);
-    next = Math.imul(next, FNV1A_32_PRIME) >>> 0;
-  }
-  return next;
-}
-function contentStringsHash(fields) {
-  let hash2 = FNV1A_32_OFFSET;
-  for (const field of fields) {
-    hash2 = updateFnv1a32(hash2, `${field.length}:`);
-    hash2 = updateFnv1a32(hash2, field);
-    hash2 = updateFnv1a32(hash2, "\x00");
-  }
-  return hash2.toString(16).padStart(8, "0");
-}
-function rawPartVersion(part) {
-  return part.__magicContextPartUpdatedAt ?? part.updated_at ?? part.updatedAt ?? part.version ?? part.revision ?? "";
-}
-function callIdFromPart(part) {
-  const direct = firstStringField(part, ["callID", "callId", "toolCallId", "tool_call_id", "id"]);
-  if (direct)
-    return direct;
-  const state2 = isRecord(part.state) ? part.state : null;
-  return state2 ? firstStringField(state2, ["callID", "callId", "toolCallId", "tool_call_id", "id"]) ?? "" : "";
-}
-function toolSignalFromPart(part) {
-  if (!isRecord(part))
-    return null;
-  const type = partType(part);
-  const state2 = isRecord(part.state) ? part.state : null;
-  const callId = callIdFromPart(part);
-  if (!callId && type !== "tool")
-    return null;
-  if (type === "tool") {
-    const hasInput = state2 !== null && hasOwn(state2, "input");
-    const outputKey = state2 ? hasOwn(state2, "output") ? "output" : hasOwn(state2, "error") ? "error" : hasOwn(state2, "result") ? "result" : null : null;
-    const hasOutput = outputKey !== null;
-    const outputValue = outputKey && state2 ? state2[outputKey] : undefined;
-    const providerExecuted = part.providerExecuted === true;
-    const openInvocation = !providerExecuted && !hasOutput;
-    return {
-      callId,
-      hasInput: hasInput || openInvocation,
-      hasOutput,
-      inputText: hasInput && state2 ? stringValue(state2.input) : "",
-      outputText: hasOutput ? stringValue(outputValue) : ""
-    };
-  }
-  if (type === "tool-invocation") {
-    const args = part.args ?? part.input;
-    return {
-      callId,
-      hasInput: args !== undefined,
-      hasOutput: false,
-      inputText: args !== undefined ? stringValue(args) : "",
-      outputText: ""
-    };
-  }
-  if (type === "tool_use") {
-    const input = part.input;
-    return {
-      callId,
-      hasInput: input !== undefined,
-      hasOutput: false,
-      inputText: input !== undefined ? stringValue(input) : "",
-      outputText: ""
-    };
-  }
-  if (type === "tool_result") {
-    const content = part.content ?? part.output ?? part.result;
-    return {
-      callId,
-      hasInput: false,
-      hasOutput: content !== undefined,
-      inputText: "",
-      outputText: content !== undefined ? textFromToolResultContent(content) : ""
-    };
-  }
-  return null;
-}
-function partCheapFingerprint(part) {
-  if (!isRecord(part))
-    return `${typeof part}:${recursiveByteLength(part)}`;
-  const version2 = rawPartVersion(part);
-  const type = typeof part.type === "string" ? part.type : "";
-  return `${type}:${String(version2)}:${recursiveByteLength(part)}`;
-}
-function messageCacheKey(message, options) {
-  const namespace = "cacheNamespace" in options ? options.cacheNamespace : "estimate";
-  const cheapFingerprint = message.parts.map(partCheapFingerprint).join("|");
-  return [
-    namespace,
-    options.providerShapeVersion,
-    message.id || `ordinal:${message.ordinal}`,
-    message.role,
-    message.parts.length,
-    cheapFingerprint
-  ].join("\x00");
-}
-function setCachedEstimate(key, breakdown) {
-  const keyEstimateBytes = key.length * 2 + 64;
-  const existing = messageEstimateCache.get(key);
-  if (existing)
-    messageEstimateCacheBytes -= existing.keyEstimateBytes;
-  messageEstimateCache.set(key, { breakdown, keyEstimateBytes });
-  messageEstimateCacheBytes += keyEstimateBytes;
-  while (messageEstimateCache.size > MAX_MESSAGE_CACHE_ENTRIES || messageEstimateCacheBytes > MAX_MESSAGE_CACHE_KEY_BYTES) {
-    const first = messageEstimateCache.keys().next().value;
-    if (typeof first !== "string")
-      break;
-    const removed = messageEstimateCache.get(first);
-    if (removed)
-      messageEstimateCacheBytes -= removed.keyEstimateBytes;
-    messageEstimateCache.delete(first);
-  }
-}
-function cloneBreakdown(value) {
-  return { ...value };
-}
-function estimateNonToolPart(part, options, breakdown) {
-  if (!isRecord(part)) {
-    if (part !== null && part !== undefined)
-      addBreakdown(breakdown, "other", estimateStructured(part));
-    return true;
-  }
-  const type = partType(part);
-  if (type === "step-start" || type === "step-finish" || type === "meta" && Object.keys(part).length <= 1) {
-    return true;
-  }
-  if (type === "text") {
-    const text = firstStringField(part, ["text", "content"]);
-    if (text)
-      addBreakdown(breakdown, "text", estimateTokens(text));
-    return true;
-  }
-  if (type === "reasoning" || type === "thinking" || type === "redacted_thinking") {
-    const text = firstStringField(part, ["thinking", "text", "content", "reasoning"]);
-    if (text) {
-      addBreakdown(breakdown, "reasoning", estimateTokens(text));
-    } else {
-      addBreakdown(breakdown, "other", estimateStructured(part));
-    }
-    return true;
-  }
-  const reasoningText = firstStringField(part, ["thinking", "reasoning"]);
-  if (reasoningText && type.length === 0) {
-    addBreakdown(breakdown, "reasoning", estimateTokens(reasoningText));
-    return true;
-  }
-  if (looksImageLike(part)) {
-    addBreakdown(breakdown, "image", options.imageTokenHeuristic?.(part) ?? defaultImageTokenHeuristic(part));
-    const altText = firstStringField(part, ["alt", "text", "description"]);
-    if (altText)
-      addBreakdown(breakdown, "text", estimateTokens(altText));
-    return true;
-  }
-  if (type.includes("file") || type === "source") {
-    const content = firstStringField(part, ["content", "text", "source"]);
-    if (content)
-      addBreakdown(breakdown, "text", estimateTokens(content));
-    else
-      addBreakdown(breakdown, "other", estimateStructured(part));
-    return true;
-  }
-  return false;
-}
-function estimateTrueRawMessageTokens(message, options) {
-  const breakdown = cloneBreakdown(EMPTY_BREAKDOWN);
-  const countedInput = new Set;
-  const countedOutput = new Set;
-  let ordinalToolIndex = 0;
-  for (const part of message.parts) {
-    const signal = toolSignalFromPart(part);
-    if (signal) {
-      const localKey = `${signal.callId || "tool"}:${message.ordinal}:${ordinalToolIndex}`;
-      ordinalToolIndex += 1;
-      if (signal.hasInput) {
-        const key = `${signal.callId}:input:${message.ordinal}`;
-        if (!countedInput.has(key)) {
-          countedInput.add(key);
-          addBreakdown(breakdown, "toolInput", estimateTokens(signal.inputText));
-        }
-      }
-      if (signal.hasOutput) {
-        const key = `${signal.callId}:output:${message.ordinal}:${localKey}`;
-        if (!countedOutput.has(key)) {
-          countedOutput.add(key);
-          addBreakdown(breakdown, "toolOutput", estimateTokens(signal.outputText));
-        }
-      }
-      continue;
-    }
-    if (!estimateNonToolPart(part, options, breakdown)) {
-      addBreakdown(breakdown, "other", estimateStructured(part));
-    }
-  }
-  return breakdown;
-}
-function buildToolArcs(messages) {
-  const openQueues = new Map;
-  const arcs = [];
-  for (const message of messages) {
-    for (const part of message.parts) {
-      const signal = toolSignalFromPart(part);
-      if (!signal || signal.callId.length === 0)
-        continue;
-      if (signal.hasInput && signal.hasOutput) {
-        arcs.push({
-          callId: signal.callId,
-          invOrdinal: message.ordinal,
-          resOrdinal: message.ordinal
-        });
-        continue;
-      }
-      if (signal.hasInput) {
-        const queue = openQueues.get(signal.callId) ?? [];
-        queue.push(message.ordinal);
-        openQueues.set(signal.callId, queue);
-        continue;
-      }
-      if (signal.hasOutput) {
-        const queue = openQueues.get(signal.callId) ?? [];
-        const invOrdinal = queue.shift();
-        if (queue.length === 0)
-          openQueues.delete(signal.callId);
-        else
-          openQueues.set(signal.callId, queue);
-        if (invOrdinal !== undefined) {
-          arcs.push({ callId: signal.callId, invOrdinal, resOrdinal: message.ordinal });
-        }
-      }
-    }
-  }
-  for (const [callId, queue] of openQueues) {
-    for (const invOrdinal of queue) {
-      arcs.push({ callId, invOrdinal, resOrdinal: null });
-    }
-  }
-  return arcs.sort((a, b) => a.invOrdinal - b.invOrdinal || (a.resOrdinal ?? Number.MAX_SAFE_INTEGER) - (b.resOrdinal ?? Number.MAX_SAFE_INTEGER));
-}
-function fenceBoundaryForToolArcs(candidate, arcs, lastCompartmentEndOrdinal, recentOpenArcCutoff) {
-  let boundary = candidate;
-  for (const arc of arcs) {
-    if (arc.resOrdinal !== null) {
-      if (arc.invOrdinal < boundary && boundary <= arc.resOrdinal) {
-        boundary = arc.resOrdinal + 1;
-      }
-      continue;
-    }
-    if (arc.invOrdinal < recentOpenArcCutoff)
-      continue;
-    if (arc.invOrdinal >= lastCompartmentEndOrdinal + 1 && arc.invOrdinal < boundary) {
-      return arc.invOrdinal;
-    }
-    if (arc.invOrdinal >= boundary) {
-      return arc.invOrdinal;
-    }
-  }
-  return boundary;
-}
-function tokenForMessage(message, options) {
-  const key = messageCacheKey(message, options);
-  const cached2 = messageEstimateCache.get(key);
-  if (cached2)
-    return cloneBreakdown(cached2.breakdown);
-  const breakdown = estimateTrueRawMessageTokens(message, options);
-  setCachedEstimate(key, breakdown);
-  return cloneBreakdown(breakdown);
-}
-function buildTrueRawTokenIndex(sessionId, messages, options) {
-  const ordered = [...messages].sort((a, b) => a.ordinal - b.ordinal);
-  const sliceCount = ordered.length;
-  const firstOrdinal = ordered.length > 0 ? ordered[0].ordinal : 1;
-  const terminalOrdinal = ordered.length > 0 ? ordered[ordered.length - 1].ordinal : 0;
-  const rawMessageCount = Math.max(sliceCount, terminalOrdinal, options.absoluteMessageCount ?? sliceCount);
-  const ordinalSpan = terminalOrdinal >= firstOrdinal ? terminalOrdinal - firstOrdinal + 1 : 0;
-  const tokensByOrdinal = new Map;
-  const idsByOrdinal = new Map;
-  const prefix = new Array(ordinalSpan + 1).fill(0);
-  for (const message of ordered) {
-    const stored = options.storedTotalForMessage?.(message);
-    const total = stored !== undefined && stored !== null ? stored : tokenForMessage(message, options).total;
-    tokensByOrdinal.set(message.ordinal, total);
-    idsByOrdinal.set(message.ordinal, message.id);
-    const relative = message.ordinal - firstOrdinal + 1;
-    if (relative >= 1 && relative <= ordinalSpan) {
-      prefix[relative] = total;
-    }
-  }
-  for (let k = 1;k <= ordinalSpan; k += 1) {
-    prefix[k] += prefix[k - 1];
-  }
-  const ordinalToIndex = (ordinal) => Math.max(0, Math.min(ordinalSpan, ordinal - firstOrdinal));
-  return {
-    sessionId,
-    providerShapeVersion: options.providerShapeVersion,
-    rawMessageCount,
-    tokenForOrdinal(ordinal) {
-      return tokensByOrdinal.get(ordinal) ?? 0;
-    },
-    messageIdAtOrdinal(ordinal) {
-      return idsByOrdinal.get(ordinal) ?? null;
-    },
-    suffixTokensFromOrdinal(ordinal) {
-      if (ordinal <= firstOrdinal)
-        return prefix[ordinalSpan];
-      if (ordinal > terminalOrdinal)
-        return 0;
-      return prefix[ordinalSpan] - prefix[ordinalToIndex(ordinal)];
-    },
-    rangeTokens(startInclusive, endExclusive) {
-      const start = Math.max(firstOrdinal, startInclusive);
-      const end = Math.max(start, Math.min(terminalOrdinal + 1, endExclusive));
-      return prefix[end - firstOrdinal] - prefix[start - firstOrdinal];
-    },
-    findSuffixStartForTokens(tokens) {
-      if (!Number.isFinite(tokens) || tokens <= 0)
-        return terminalOrdinal + 1;
-      const target = Math.max(0, Math.floor(tokens));
-      const total = prefix[ordinalSpan];
-      if (total < target)
-        return firstOrdinal;
-      const cut = total - target;
-      let lo = 0;
-      let hi = ordinalSpan;
-      let best = 0;
-      while (lo <= hi) {
-        const mid = lo + hi >> 1;
-        if (prefix[mid] <= cut) {
-          best = mid;
-          lo = mid + 1;
-        } else {
-          hi = mid - 1;
-        }
-      }
-      return firstOrdinal + best;
-    },
-    findHeadEndForCap(startInclusive, endExclusive, capTokens) {
-      const start = Math.max(firstOrdinal, Math.min(terminalOrdinal + 1, startInclusive));
-      const end = Math.max(start, Math.min(terminalOrdinal + 1, endExclusive));
-      if (!Number.isFinite(capTokens) || capTokens <= 0)
-        return start;
-      const startIndex = start - firstOrdinal;
-      const endIndex = end - firstOrdinal;
-      const cut = prefix[startIndex] + Math.floor(capTokens);
-      let lo = startIndex + 1;
-      let hi = endIndex;
-      let bestEndIndex = startIndex;
-      while (lo <= hi) {
-        const mid = lo + hi >> 1;
-        if (prefix[mid] <= cut) {
-          bestEndIndex = mid;
-          lo = mid + 1;
-        } else {
-          hi = mid - 1;
-        }
-      }
-      let bestEnd = firstOrdinal + bestEndIndex;
-      if (bestEnd === start && start < end)
-        bestEnd = start + 1;
-      return Math.min(bestEnd, end);
-    }
-  };
-}
-function partContentFingerprint(part) {
-  if (!isRecord(part))
-    return `${typeof part}:${recursiveByteLength(part)}`;
-  const tool = toolSignalFromPart(part);
-  if (tool) {
-    return contentStringsHash([tool.inputText, tool.outputText]);
-  }
-  const text = firstStringField(part, ["text", "thinking", "reasoning", "content", "url"]) ?? "";
-  return contentStringsHash([text]);
-}
-function computeRawRangeFingerprint(messages, startInclusive, endExclusive) {
-  const pieces = [];
-  for (const message of messages) {
-    if (message.ordinal < startInclusive || message.ordinal >= endExclusive)
-      continue;
-    const partFingerprint = message.parts.map(partContentFingerprint).join(",");
-    pieces.push(`${message.ordinal}:${message.id}:${message.parts.length}:${partFingerprint}`);
-  }
-  return pieces.join("|");
-}
-function invalidateTrueRawTokenCache(args) {
-  const sessionNeedle = args.sessionId ? `${args.sessionId}` : null;
-  const messageNeedle = args.messageId ? `\x00${args.messageId}\x00` : null;
-  for (const [key, value] of messageEstimateCache) {
-    const sessionMatches = sessionNeedle === null || key.includes(sessionNeedle);
-    const messageMatches = messageNeedle === null || key.includes(messageNeedle);
-    if (sessionMatches && messageMatches) {
-      messageEstimateCache.delete(key);
-      messageEstimateCacheBytes -= value.keyEstimateBytes;
-    }
-  }
-  args.reason;
-}
-
 // src/hooks/magic-context/protected-tail-boundary.ts
 var ALPHA = 0.3;
 var FLOOR_RATIO = 0.08;
@@ -38081,7 +38300,7 @@ function fenceWrapupBoundaryForToolArcs(args) {
       if (arc.resOrdinal === null) {
         continue;
       }
-      if (arc.invOrdinal >= args.lastCompartmentEndOrdinal + 1 && arc.invOrdinal < next && next <= arc.resOrdinal) {
+      if (arc.invOrdinal >= args.lastCompartmentEndOrdinal + 1 && completedToolArcCrossesBoundary(arc.invOrdinal, arc.resOrdinal, next)) {
         next = arc.invOrdinal;
       }
     }
@@ -40601,17 +40820,14 @@ ${chunkText}`,
     }
     retainDrainReservationForRetryThrottle = false;
     const emittedCompartments = validatedPass.compartments;
-    const BOUNDARY_HEALING_SLACK = 2;
     const inEmergency = getOverflowState(db, sessionId).needsEmergencyRecovery;
     let persistedCompartments = emittedCompartments;
-    if (!inEmergency && !forceKeepLastCompartmentForChunk && emittedCompartments.length >= 2) {
+    if (!inEmergency && !forceKeepLastCompartmentForChunk && shouldDiscardLastHistorianCompartment(emittedCompartments, chunk)) {
       const lastEmitted = emittedCompartments[emittedCompartments.length - 1];
       const lookaheadMargin = chunk.endIndex - lastEmitted.endMessage;
-      if (lookaheadMargin <= BOUNDARY_HEALING_SLACK) {
-        persistedCompartments = emittedCompartments.slice(0, -1);
-        telemetry.discardedLast = true;
-        sessionLog(sessionId, `historian discard-last: dropped provisional compartment ${lastEmitted.startMessage}-${lastEmitted.endMessage} (lookaheadMargin=${lookaheadMargin} <= ${BOUNDARY_HEALING_SLACK}); will re-derive from raw next run`);
-      }
+      persistedCompartments = emittedCompartments.slice(0, -1);
+      telemetry.discardedLast = true;
+      sessionLog(sessionId, `historian discard-last: dropped provisional compartment ${lastEmitted.startMessage}-${lastEmitted.endMessage} (lookaheadMargin=${lookaheadMargin} <= ${HISTORIAN_BOUNDARY_HEALING_SLACK}); will re-derive from raw next run`);
     }
     const newCompartments = persistedCompartments;
     const lastNewEnd = newCompartments[newCompartments.length - 1]?.endMessage ?? 0;
@@ -42088,4 +42304,4 @@ async function runUpgradeMemoryMigration(ctx, sessionId, migrationDirectory) {
   }
 }
 
-export { withContentLanguageDirective, buildPrimaryLanguageDirective, exports_external, DEFAULT_PROTECTED_TAGS, parseCron, nextOccurrence, nextDueAtMs, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, DEFAULT_HISTORIAN_TIMEOUT_MS, DEFAULT_LOCAL_EMBEDDING_MODEL, MagicContextConfigSchema, getOpenCodeDbPath, removeMcOwnedCompactionMarkers, ProjectIdentityError, resolveProjectIdentityStrict, takeDubiousOwnershipProjectIdentityWarning, resolveProjectIdentity, resolveProjectIdentityForSession, normalizeStoredProjectPath, storedPathBelongsToIdentity, recordSessionProjectIdentity, beginBootQuietPeriod, bootQuietRemainingMs, scheduleAfterBootQuiet, rpcPortDir, rpcPortFilePath, isPidAlive, parseRpcPortFile, registerModuleNoteEvaluationBridge, getModuleNoteEvaluationBridge, getContextStoreUuid, ensureContextStoreUuid, getAuthorityManagedMarker, reconcileAuthorityProject, checksumAuthoritySeedRows, prepareAuthority, drainAuthority, getMirrorCursor, applyMirrorPage, pullMemoryMirrorOnce, V2_MEMORY_CATEGORIES, CATEGORY_PRIORITY, resolveWorkspaceShareCategories, resolveWorkspaceIdentitySet, expandWorkspaceIdentitySetWithAliases, resolveStoredPathWorkspaceIdentity, storedPathBelongsToWorkspace, sourceNameForMemory, computeWorkspaceEpochFingerprint, recordToolDefinition, getMeasuredToolDefinitionTokens, getSchemaFenceRejection, getMigrationOnOpenRefusal, LATEST_SUPPORTED_VERSION, getDatabasePath, getPersistedSchemaVersion, setSqlitePragmaConfig, runSqliteOptimize, openDatabase, openDatabaseAsync, isDatabasePersisted, getDatabasePersistenceError, COMPARTMENT_LEASE_RENEWAL_MS, acquireCompartmentLease, renewCompartmentLease, releaseCompartmentLease, getCompartments, getLastCompartmentEndMessage, getLastCompartmentEndMessageId, clearRecompStaging, recordEmbeddingMeasurement, getMaxM0MutationId, queueMemoryMutation, getMemoryMutationsForRenderByProjects, getMaxMemoryMutationIdForProjects, MAX_EXECUTE_THRESHOLD, escalationBands, isEmergencyRecoveryArmed, isProviderOverflowReconfirmed, loadPersistedUsage, loadProtectedTailMeta, resetProtectedTailNoEligibleHead, getWrapupInProgressState, acquireWrapupInProgress, updateWrapupInProgress, releaseWrapupInProgress, resolveCompactionModeRecord, getCompactionModeRecord, setCompactionModeRecord, getPersistedReasoningWatermark, setPersistedReasoningWatermark, clearPersistedReasoningWatermark, getEmergencyInputSample, setEmergencyDropSample, clearEmergencyDropSample, getLastNudgeUndropped, setLastNudgeUndropped, getLastNudgeLevel, setLastNudgeLevel, resetLastNudgeCycle, resetLastNudgeCycleIfTailShrank, getChannel2NudgeState, getChannel2NudgeClaim, setChannel2NudgeState, casChannel2NudgeState, claimChannel2NudgeState, casChannel2NudgeClaim, getPersistedNoteNudge, getNoteNudgeAnchors, getAutoSearchHintDecisions, appendAutoSearchHintDecision, pruneNoteNudgeAnchors, pruneAutoSearchHintDecisions, removeNoteNudgeAnchorByMessageId, removeAutoSearchHintDecisionByMessageId, getPersistedTodoPermissionDenied, setPersistedTodoPermissionDenied, getPersistedTodoSyntheticAnchor, setPersistedTodoSyntheticAnchor, clearPersistedTodoSyntheticAnchor, setNoteLastReadAt, getHistorianFailureState, clearHistorianFailureState, getOverflowState, recordOverflowDetected, recordDetectedContextLimit, clearEmergencyRecovery, clearDetectedContextLimit, getPersistedCompactionMarkerState, setPersistedCompactionMarkerState, getStrippedPlaceholderIds, applyStrippedPlaceholderDelta, removeStrippedPlaceholderId, getStaleReduceStrippedIds, addStaleReduceStrippedIds, getProcessedImageStrippedIds, addProcessedImageStrippedIds, getPendingCompactionMarkerState, clearPendingCompactionMarkerStateIf, peekDeferredExecutePending, setDeferredExecutePendingIfAbsent, clearDeferredExecutePendingIfMatches, getSessionsWithPendingMarker, setSessionWorkMetrics, getNotes, addNote, getSessionNotes, getPendingSmartNotes, getReadySmartNotes, updateNote, dismissNote, markNoteReady, markNoteChecked, queuePendingOp, getPendingOps, clearPendingOps, removePendingOp, PRIMER_CANDIDATE_TTL_MS, PRIMER_CANDIDATE_MAX_AGE_MS, primerOccurrenceKey, primerOccurrenceUtcDay, updatePrimerCandidateEmbedding, getPrimerCandidatesByIds, getPrimerCandidatesForPromotion, countPrimerCandidatesForProject, getActivePrimers, createPrimer, updatePrimerSupport, updatePrimerAnswer, GLOBAL_USER_PROFILE_PROJECT_PATH, getProjectState, bumpProjectMemoryEpoch, bumpProjectUserProfileVersion, saveSourceContent, replaceSourceContent, getSourceContents, getActiveTagTokenAggregate, AGE_RECLAIM_MIN_TOKENS, getOldestActiveUnprotectedToolTags, getActiveToolTagsForAgeReclaim, getTriggerTagTokenUpperBound, getActiveTagTokenTotalsByMessage, tagTokenCountIsNull, backfillTagTokenCounts, insertTag, updateTagStatus, updateTagDropMode, updateCavemanDepth, updateTagMessageId, deleteTagsByMessageId, getMaxTagNumberBySession, getTagNumberByMessageId, deriveTagLoadFloor, getTagsBySession, getActiveTagsBySession, getDroppedTagsBySession, getTagsByNumbers, getMaxDroppedTagNumber, getToolTagNumberByOwner, getNullOwnerToolTag, adoptNullOwnerToolTag, getCandidateToolOwners, pickNearestPriorOwner, createChildSessionWithFence, detectOverflow, promptSyncWithValidatedOutputRetry, normalizeSDKResponse, extractLatestAssistantText, hasLengthCappedOutput, setKeepSubagents, shouldKeepSubagents, recordChildInvocation, COMPARTMENT_AGENT_SYSTEM_PROMPT, HISTORIAN_EDITOR_SYSTEM_PROMPT, COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT, Priority, AdmissionClass, StaleRouteHandleError, SocketClosedError, SocketTimeoutError, SubcClient, isConsumerReconnectTransient, getCompartmentEvents, loadCompartmentChunkEmbeddingsForSearch, cosineSimilarity, SYNAPSE_DEFAULT_MODEL, SynapseEmbeddingProvider, computeNormalizedHash, saveCommitEmbedding, loadProjectCommitEmbeddings, loadUnembeddedCommits, countEmbeddedCommits, upsertCommits, getLatestIndexedCommitTimeMs, enforceProjectCap, GIT_SWEEP_LEASE_RENEWAL_MS, acquireGitSweepLease, renewGitSweepLease, markGitSweepSuccessAndRelease, parkGitSweepNonIndexable, releaseGitSweepLease, saveEmbeddingIfHashMatches, getProjectEmbeddings, peekProjectEmbeddings, invalidateProject, invalidateMemory, markProjectLoadUntrusted, contentSha256, sweepStaleEmbeddingIdentitiesForProject, registerProjectEmbedding, registerProjectShadowEmbedding, getShadowEmbeddingMeasurementCohort, getPrimaryEmbeddingMeasurementCohort, embedShadowTextForProject, enqueueShadowEmbeddingItems, registerProjectInObservationMode, getProjectEmbeddingSnapshot, embedTextForProject, embedBatchForProject, embedItemsForProject, embedUnembeddedMemoriesForProject, drainCommitBacklogForProject, embedSessionCompartmentChunks, getEmbeddingCoverageStatus, isEmbeddingEnabled, embedText, ensureMemoryEmbeddings, computeCueContentHash, hasMuralCueColumns, getMuralCueState, memoryNeedsCue, setMuralCue, hasMemoryShareableColumn, hasMemoryClassifiedAtColumn, getUnclassifiedMemoryIds, ModuleMemoryAuthorityError, insertMemory, insertMemoryIdempotent, getMemoryByHash, getMemoriesByProject, buildWorkspaceMemorySqlFilter, getMemoriesByProjects, getMaxMemoryIdForProjects, readNewMemoriesForM1Union, getMemoryById, getMemoriesByIds, updateMemorySeenCount, updateMemoryRetrievalCount, setMemoryClassification, supersededMemory, mergeMemoryStats, archiveMemory, getMemoryCountsByStatus, sanitizeFtsQuery, searchMemoriesFTS, searchMemoriesFTSUnion, recordMemoryMapping, recordMemoryVerifications, getUnmappedMemoryIds, clearMemoryVerifications, getMemoryVerifications, resolveGitTopLevel, readGitHead, readGitChangedFilesSince, readGitFileChangeTimesSince, verificationFileExists, normalizeVerificationFiles, USER_MEMORY_CANDIDATE_TTL_MS, insertUserMemoryCandidates, getUserMemoryCandidates, deleteUserMemoryCandidates, pruneExpiredUserMemoryCandidates, insertUserMemory, getActiveUserMemories, updateUserMemoryContent, dismissUserMemory, MARKER_SUMMARY_TEXT, applyDeferredCompactionMarker, removeCompactionMarkerForSession, checkCompactionMarkerConsistency, getMural, BoundedSessionMap, extractM0Block, formatDate, injectTemporalMarkers, clearInjectionCache, getVisibleMemoryIds, prepareCompartmentInjection, renderCompartmentInjection, mustMaterialize, trimMemoriesToBudgetV2, renderMemoryBlockV2, injectM0M1, onNoteTrigger, peekNoteNudgeText, markNoteNudgeDelivered, clearNoteNudgeTriggerAndCooldown, resetNoteNudgeCooldownOnly, clearNoteNudgeTriggerOnly, estimateTrueRawMessageTokens, invalidateTrueRawTokenCache, RECOVERY_NO_HEAD_LIMIT, resolveOpenCodeProtectedTailBoundary, resolveWrapupProtectedTailBoundary, getRawHistoryEligibility, hasRunnableCompartmentWindow, recordHighPressureNoEligibleHead, runCompartmentAgent, snapRangeToCompartments, lkgContentDigest, captureSlot, getSlot, dropSlot, noteEntry, getActiveCompartmentRun, markActiveCompartmentRunPublished, registerActiveCompartmentRun, startCompartmentAgent, isRecompFailure, isRecompSkip, isRecompComplete, extractRecompReason, contextualizeUpgradeReason, setRecompStarting, setRecompNote, setRecompTerminal, runManagedRecomp, runManagedUpgrade };
+export { withContentLanguageDirective, buildPrimaryLanguageDirective, cortexKitUserConfigBasePath, cortexKitProjectConfigBasePath, resolveLegacyConfigSources, resolveLegacyConfigSourcesForHarness, migrateMagicContextConfigLocations, exports_external, DEFAULT_PROTECTED_TAGS, parseCron, nextOccurrence, nextDueAtMs, resolvePromptSurface, resolveModelConfigOrDefault, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, DEFAULT_HISTORIAN_TIMEOUT_MS, DEFAULT_LOCAL_EMBEDDING_MODEL, MagicContextConfigSchema, getOpenCodeDbPath, removeMcOwnedCompactionMarkers, ProjectIdentityError, resolveProjectIdentityStrict, takeDubiousOwnershipProjectIdentityWarning, resolveProjectIdentity, resolveProjectIdentityForSession, normalizeStoredProjectPath, storedPathBelongsToIdentity, recordSessionProjectIdentity, beginBootQuietPeriod, bootQuietRemainingMs, scheduleAfterBootQuiet, rpcPortDir, rpcPortFilePath, isPidAlive, parseRpcPortFile, registerModuleNoteEvaluationBridge, getModuleNoteEvaluationBridge, getContextStoreUuid, ensureContextStoreUuid, getAuthorityManagedMarker, reconcileAuthorityProject, checksumAuthoritySeedRows, prepareAuthority, drainAuthority, getMirrorCursor, applyMirrorPage, pullMemoryMirrorOnce, V2_MEMORY_CATEGORIES, CATEGORY_PRIORITY, resolveWorkspaceShareCategories, resolveWorkspaceIdentitySet, expandWorkspaceIdentitySetWithAliases, resolveStoredPathWorkspaceIdentity, storedPathBelongsToWorkspace, sourceNameForMemory, computeWorkspaceEpochFingerprint, recordToolDefinition, getMeasuredToolDefinitionTokens, getSchemaFenceRejection, getMigrationOnOpenRefusal, LATEST_SUPPORTED_VERSION, getDatabasePath, getPersistedSchemaVersion, setSqlitePragmaConfig, runSqliteOptimize, openDatabase, openDatabaseAsync, isDatabasePersisted, getDatabasePersistenceError, COMPARTMENT_LEASE_RENEWAL_MS, acquireCompartmentLease, renewCompartmentLease, releaseCompartmentLease, getCompartments, getLastCompartmentEndMessage, getLastCompartmentEndMessageId, clearRecompStaging, recordEmbeddingMeasurement, getMaxM0MutationId, queueMemoryMutation, getMemoryMutationsForRenderByProjects, getMaxMemoryMutationIdForProjects, MAX_EXECUTE_THRESHOLD, escalationBands, isEmergencyRecoveryArmed, isProviderOverflowReconfirmed, getEmergencyRecoveryArmedAt, loadPersistedUsage, loadProtectedTailMeta, resetProtectedTailNoEligibleHead, getWrapupInProgressState, acquireWrapupInProgress, updateWrapupInProgress, releaseWrapupInProgress, resolveCompactionModeRecord, getCompactionModeRecord, setCompactionModeRecord, getPersistedReasoningWatermark, setPersistedReasoningWatermark, clearPersistedReasoningWatermark, getEmergencyInputSample, setEmergencyDropSample, clearEmergencyDropSample, getLastNudgeUndropped, setLastNudgeUndropped, getLastNudgeLevel, setLastNudgeLevel, resetLastNudgeCycle, resetLastNudgeCycleIfTailShrank, getChannel2NudgeState, getChannel2NudgeClaim, setChannel2NudgeState, casChannel2NudgeState, claimChannel2NudgeState, casChannel2NudgeClaim, getPersistedNoteNudge, getNoteNudgeAnchors, getAutoSearchHintDecisions, appendAutoSearchHintDecision, pruneNoteNudgeAnchors, pruneAutoSearchHintDecisions, removeNoteNudgeAnchorByMessageId, removeAutoSearchHintDecisionByMessageId, getPersistedTodoPermissionDenied, setPersistedTodoPermissionDenied, getPersistedTodoSyntheticAnchor, setPersistedTodoSyntheticAnchor, clearPersistedTodoSyntheticAnchor, setNoteLastReadAt, getHistorianFailureState, clearHistorianFailureState, getOverflowState, recordOverflowDetected, recordDetectedContextLimit, clearEmergencyRecovery, clearDetectedContextLimit, getPersistedCompactionMarkerState, setPersistedCompactionMarkerState, getStrippedPlaceholderIds, applyStrippedPlaceholderDelta, removeStrippedPlaceholderId, getStaleReduceStrippedIds, addStaleReduceStrippedIds, getProcessedImageStrippedIds, addProcessedImageStrippedIds, getPendingCompactionMarkerState, clearPendingCompactionMarkerStateIf, peekDeferredExecutePending, setDeferredExecutePendingIfAbsent, clearDeferredExecutePendingIfMatches, getSessionsWithPendingMarker, setSessionWorkMetrics, getNotes, addNote, getSessionNotes, getPendingSmartNotes, getReadySmartNotes, updateNote, dismissNote, markNoteReady, markNoteChecked, queuePendingOp, getPendingOps, clearPendingOps, removePendingOp, PRIMER_CANDIDATE_TTL_MS, PRIMER_CANDIDATE_MAX_AGE_MS, primerOccurrenceKey, primerOccurrenceUtcDay, updatePrimerCandidateEmbedding, getPrimerCandidatesByIds, getPrimerCandidatesForPromotion, countPrimerCandidatesForProject, getActivePrimers, createPrimer, updatePrimerSupport, updatePrimerAnswer, GLOBAL_USER_PROFILE_PROJECT_PATH, getProjectState, bumpProjectMemoryEpoch, bumpProjectUserProfileVersion, saveSourceContent, replaceSourceContent, getSourceContents, getActiveTagTokenAggregate, AGE_RECLAIM_MIN_TOKENS, getOldestActiveUnprotectedToolTags, getActiveToolTagsForAgeReclaim, getTriggerTagTokenUpperBound, getActiveTagTokenTotalsByMessage, tagTokenCountIsNull, backfillTagTokenCounts, insertTag, updateTagStatus, updateTagDropMode, updateCavemanDepth, updateTagMessageId, deleteTagsByMessageId, getMaxTagNumberBySession, getTagNumberByMessageId, deriveTagLoadFloor, getTagsBySession, getActiveTagsBySession, getDroppedTagsBySession, getTagsByNumbers, getMaxDroppedTagNumber, getToolTagNumberByOwner, getNullOwnerToolTag, adoptNullOwnerToolTag, getCandidateToolOwners, pickNearestPriorOwner, createChildSessionWithFence, detectOverflow, promptSyncWithValidatedOutputRetry, normalizeSDKResponse, promptSurfaceHashMaterial, createPromptSurfaceRuntime, createPromptSurfaceGuidanceEpochCache, extractLatestAssistantText, hasLengthCappedOutput, setKeepSubagents, shouldKeepSubagents, recordChildInvocation, COMPARTMENT_AGENT_SYSTEM_PROMPT, HISTORIAN_EDITOR_SYSTEM_PROMPT, COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT, Priority, AdmissionClass, StaleRouteHandleError, SocketClosedError, SocketTimeoutError, SubcClient, isConsumerReconnectTransient, getCompartmentEvents, loadCompartmentChunkEmbeddingsForSearch, cosineSimilarity, SYNAPSE_DEFAULT_MODEL, SynapseEmbeddingProvider, computeNormalizedHash, saveCommitEmbedding, loadProjectCommitEmbeddings, loadUnembeddedCommits, countEmbeddedCommits, upsertCommits, getLatestIndexedCommitTimeMs, enforceProjectCap, GIT_SWEEP_LEASE_RENEWAL_MS, acquireGitSweepLease, renewGitSweepLease, markGitSweepSuccessAndRelease, parkGitSweepNonIndexable, releaseGitSweepLease, saveEmbeddingIfHashMatches, getProjectEmbeddings, peekProjectEmbeddings, invalidateProject, invalidateMemory, markProjectLoadUntrusted, contentSha256, sweepStaleEmbeddingIdentitiesForProject, registerProjectEmbedding, registerProjectShadowEmbedding, getShadowEmbeddingMeasurementCohort, getPrimaryEmbeddingMeasurementCohort, embedShadowTextForProject, enqueueShadowEmbeddingItems, registerProjectInObservationMode, getProjectEmbeddingSnapshot, embedTextForProject, embedBatchForProject, embedItemsForProject, embedUnembeddedMemoriesForProject, drainCommitBacklogForProject, embedSessionCompartmentChunks, getEmbeddingCoverageStatus, isEmbeddingEnabled, embedText, ensureMemoryEmbeddings, computeCueContentHash, hasMuralCueColumns, getMuralCueState, memoryNeedsCue, setMuralCue, recordMuralCueRejection, hasMemoryShareableColumn, hasMemoryClassifiedAtColumn, getUnclassifiedMemoryIds, ModuleMemoryAuthorityError, insertMemory, insertMemoryIdempotent, getMemoryByHash, getMemoriesByProject, buildWorkspaceMemorySqlFilter, getMemoriesByProjects, getMaxMemoryIdForProjects, readNewMemoriesForM1Union, getMemoryById, getMemoriesByIds, updateMemorySeenCount, updateMemoryRetrievalCount, setMemoryClassification, supersededMemory, mergeMemoryStats, archiveMemory, getMemoryCountsByStatus, sanitizeFtsQuery, searchMemoriesFTS, searchMemoriesFTSUnion, recordMemoryMapping, recordMemoryVerifications, getUnmappedMemoryIds, clearMemoryVerifications, getMemoryVerifications, resolveGitTopLevel, readGitHead, readGitChangedFilesSince, readGitFileChangeTimesSince, verificationFileExists, normalizeVerificationFiles, USER_MEMORY_CANDIDATE_TTL_MS, insertUserMemoryCandidates, getUserMemoryCandidates, deleteUserMemoryCandidates, pruneExpiredUserMemoryCandidates, insertUserMemory, getActiveUserMemories, updateUserMemoryContent, dismissUserMemory, MARKER_SUMMARY_TEXT, applyDeferredCompactionMarker, removeCompactionMarkerForSession, checkCompactionMarkerConsistency, getMural, BoundedSessionMap, extractM0Block, formatDate, injectTemporalMarkers, clearInjectionCache, getVisibleMemoryIds, prepareCompartmentInjection, renderCompartmentInjection, mustMaterialize, trimMemoriesToBudgetV2, renderMemoryBlockV2, injectM0M1, onNoteTrigger, peekNoteNudgeText, markNoteNudgeDelivered, clearNoteNudgeTriggerAndCooldown, resetNoteNudgeCooldownOnly, clearNoteNudgeTriggerOnly, RECOVERY_NO_HEAD_LIMIT, resolveOpenCodeProtectedTailBoundary, resolveWrapupProtectedTailBoundary, getRawHistoryEligibility, hasRunnableCompartmentWindow, recordHighPressureNoEligibleHead, runCompartmentAgent, snapRangeToCompartments, lkgContentDigest, captureSlot, getSlot, dropSlot, noteEntry, getActiveCompartmentRun, markActiveCompartmentRunPublished, registerActiveCompartmentRun, startCompartmentAgent, isRecompFailure, isRecompSkip, isRecompComplete, extractRecompReason, contextualizeUpgradeReason, setRecompStarting, setRecompNote, setRecompTerminal, runManagedRecomp, runManagedUpgrade };