@cortexkit/opencode-magic-context 0.36.1 → 0.38.0

package/dist/{index-1skzp4dc.js → index-mmvhrqqb.js}

@@ -1,9 +1,8 @@
 import {
   deriveTriggerBudget,
   modelSupportsVision,
-  piModelRefToCanonical,
   shouldEnforcePrivateStoragePermissions
-} from "./index-wgvxkqpx.js";
+} from "./index-9zhhvr4w.js";
 import {
   parseProviderModel
 } from "./index-td9depx5.js";
@@ -11,10 +10,11 @@ import {
   describeError,
   getErrorMessage,
   sendIgnoredMessage
-} from "./index-nsx2n9eg.js";
+} from "./index-4cz5nfxf.js";
 import {
   buildToolArcs,
   buildTrueRawTokenIndex,
+  byteSize,
   clearCachedM0M1,
   clearCompressionDepth,
   clearCompressionDepthRange,
@@ -35,13 +35,17 @@ import {
   readSessionChunk,
   stableStringify,
   updateSessionMeta
-} from "./index-3zqcdwqr.js";
+} from "./index-crke4z5j.js";
+import {
+  modelRefLookupOrder,
+  piModelRefToCanonical
+} from "./index-cgyfn1s2.js";
 import {
   Database,
   closeQuietly,
   getMessageTimesFromOpenCodeDb,
   withPrivilegedWriter
-} from "./index-3tnkymva.js";
+} from "./index-sw8gnq34.js";
 import {
   detectConfigFile
 } from "./index-8mtsfhyg.js";
@@ -51,7 +55,7 @@ import {
 import {
   log,
   sessionLog
-} from "./index-f1tnb3vm.js";
+} from "./index-8pqfcghm.js";
 import {
   ensureCortexKitArtifactGitignore,
   getDataDir,
@@ -414,24 +418,44 @@ function isMagicContextHiddenAgentName(agent) {
   return false;
 }
 var MAX_FORMATTED_BLOCKING_PROCESSES = 8;
+function normalizeFailClosedProcessKind(process2) {
+  switch (process2.kind) {
+    case "OpenCode server":
+    case "OpenCode instance (TUI/CLI)":
+    case "Pi":
+    case "process":
+      return process2.kind;
+  }
+  switch (process2.harness?.trim().toLowerCase()) {
+    case "opencode server":
+      return "OpenCode server";
+    case "opencode instance (tui/cli)":
+    case "opencode instance":
+      return "OpenCode instance (TUI/CLI)";
+    case "pi":
+    case "pi harness":
+    case "omp":
+      return "Pi";
+    default:
+      return "process";
+  }
+}
 function formatFailClosedBlockingProcesses(processes) {
   const uniqueProcesses = new Map;
   for (const process2 of processes) {
-    if (!process2.harness.trim() || !Number.isInteger(process2.pid) || process2.pid <= 0)
+    if (!Number.isInteger(process2.pid) || process2.pid <= 0)
       continue;
-    uniqueProcesses.set(`${process2.harness}\x00${process2.pid}`, {
-      harness: process2.harness.trim(),
-      pid: process2.pid
-    });
+    const kind = normalizeFailClosedProcessKind(process2);
+    uniqueProcesses.set(`${kind}\x00${process2.pid}`, { kind, pid: process2.pid });
   }
   const entries = [...uniqueProcesses.values()];
   const visible = entries.slice(0, MAX_FORMATTED_BLOCKING_PROCESSES);
-  const rendered = visible.map(({ harness, pid }) => `${harness} (PID ${pid})`);
+  const rendered = visible.map(({ kind, pid }) => `${kind} (PID ${pid})`);
   const omitted = entries.length - visible.length;
   if (omitted > 0)
     rendered.push(`${omitted} more blocking process(es)`);
   if (rendered.length === 0)
-    return "a live harness process";
+    return "a live process";
   if (rendered.length === 1)
     return rendered[0];
   const last = rendered.pop();
@@ -441,9 +465,9 @@ function formatFailClosedBlockingMessage(reason) {
   if (reason.kind === "migration_guard") {
     if (reason.unreadableFile) {
       const arm = reason.unreadableArm ?? "io";
-      const recovery = arm === "io" ? `If no OpenCode server is running, it is safe to delete ${reason.unreadableFile} and retry.` : `The file may be a recent incomplete write; retry after the file is older than the ten-minute grace window, or stop OpenCode before deleting it.`;
+      const recovery = arm === "io" ? `If none of these processes are running, it is safe to delete ${reason.unreadableFile} and retry.` : `The file may be a recent incomplete write; retry after the file is older than the ten-minute grace window, or stop the relevant process before deleting it.`;
       return [
-        `Magic Context cannot migrate the shared database because RPC discovery file ${reason.unreadableFile} is uncertain (${arm} arm), so the absence of a live OpenCode server cannot be proven.`,
+        `Magic Context cannot migrate the shared database because RPC discovery file ${reason.unreadableFile} is uncertain (${arm} arm), so the absence of a live process cannot be proven.`,
         recovery,
         `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
       ].join(" ");
@@ -566,7 +590,7 @@ import {
   statSync as statSync2,
   unlinkSync
 } from "node:fs";
-import { basename, dirname, join as join3 } from "node:path";
+import { basename, dirname, join as join3, resolve } from "node:path";
 
 // src/plugin/boot-quiet.ts
 var BOOT_QUIET_MS = 120000;
@@ -602,20 +626,24 @@ function rpcPortFilePath(storageDir, directory, pid = process.pid, instanceId) {
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
-    return false;
+    return "dead";
+  if (rpcIdentityPlatform === "win32")
+    return readWindowsProcess(pid).state;
   try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
+    rpcIdentityProcessKill(pid, 0);
+    return "alive";
+  } catch (error) {
+    return error.code === "ESRCH" ? "dead" : "inconclusive";
   }
 }
 var RPC_IDENTITY_SKEW_TOLERANCE_MS = 120000;
 var LINUX_CLOCK_TICKS_PER_SECOND = 100;
 var PS_PROBE_TIMEOUT_MS = 1000;
 var OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
+var TASKLIST_NO_TASKS_PATTERN = /^INFO:\s+No tasks are running which match the specified criteria\.?$/im;
 var rpcIdentityReadFileSync = readFileSync;
 var rpcIdentityExecFileSync = execFileSync;
+var rpcIdentityProcessKill = process.kill;
 var rpcProcessListExecFileSync = execFileSync;
 var rpcIdentityPlatform = process.platform;
 var rpcIdentityNowMs = () => Date.now();
@@ -645,7 +673,8 @@ function readPsProcessStartTime(pid) {
   try {
     const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
       encoding: "utf8",
-      timeout: PS_PROBE_TIMEOUT_MS
+      timeout: PS_PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
     });
     const processStartTime = Date.parse(String(output).trim());
     return Number.isFinite(processStartTime) ? processStartTime : null;
@@ -653,6 +682,70 @@ function readPsProcessStartTime(pid) {
     return null;
   }
 }
+function parseCsvLine(line) {
+  const fields = [];
+  let field = "";
+  let quoted = false;
+  for (let index = 0;index < line.length; index += 1) {
+    const character = line[index];
+    if (character === '"') {
+      if (quoted && line[index + 1] === '"') {
+        field += '"';
+        index += 1;
+      } else {
+        quoted = !quoted;
+      }
+    } else if (character === "," && !quoted) {
+      fields.push(field);
+      field = "";
+    } else {
+      field += character;
+    }
+  }
+  if (quoted)
+    return null;
+  fields.push(field);
+  return fields;
+}
+function parseTasklistOutput(output) {
+  const entries = [];
+  let sawHeader = false;
+  for (const rawLine of output.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    if (TASKLIST_NO_TASKS_PATTERN.test(line))
+      return [];
+    const fields = parseCsvLine(line);
+    if (!fields)
+      continue;
+    if (fields[1]?.trim().toLowerCase() === "pid") {
+      sawHeader = true;
+      continue;
+    }
+    const pid = Number(fields[1]);
+    if (!Number.isInteger(pid) || pid <= 0 || !fields[0])
+      continue;
+    entries.push({ pid, command: fields[0] });
+  }
+  return entries.length > 0 || sawHeader ? entries : null;
+}
+function readWindowsProcess(pid) {
+  try {
+    const output = rpcIdentityExecFileSync("tasklist", ["/FO", "CSV", "/FI", `PID eq ${pid}`], {
+      encoding: "utf8",
+      timeout: PS_PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const entries = parseTasklistOutput(String(output));
+    if (entries === null)
+      return { state: "inconclusive" };
+    const process2 = entries.find((entry) => entry.pid === pid);
+    return process2 ? { state: "alive", command: process2.command } : { state: "dead" };
+  } catch {
+    return { state: "inconclusive" };
+  }
+}
 function readLinuxProcessCommand(pid) {
   try {
     return String(rpcIdentityReadFileSync(`/proc/${pid}/cmdline`, "utf8"));
@@ -664,40 +757,86 @@ function readPsProcessCommand(pid) {
   try {
     const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "command="], {
       encoding: "utf8",
-      timeout: PS_PROBE_TIMEOUT_MS
+      timeout: PS_PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
     });
     return String(output);
   } catch {
     return null;
   }
 }
+function readProcessCommand(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return null;
+  return rpcIdentityPlatform === "linux" ? readLinuxProcessCommand(pid) : rpcIdentityPlatform === "win32" ? readWindowsProcess(pid).command ?? null : readPsProcessCommand(pid);
+}
+function executableName(token) {
+  return (token ?? "").replace(/^['"]|['"]$/g, "").split("/").at(-1) ?? "";
+}
+function commandTokens(command) {
+  return command.toLowerCase().replaceAll("\\", "/").replaceAll("\x00", " ").split(/\s+/).map((token) => token.replace(/^['"]|['"]$/g, "")).filter(Boolean);
+}
+function commandHasOpenCodeExecutable(tokens) {
+  return tokens.findIndex((token) => {
+    const executable = executableName(token).replace(/\.(?:exe|cmd)$/, "");
+    return executable === "opencode" || executable.endsWith("/opencode");
+  });
+}
+function commandHasPiExecutable(tokens) {
+  for (let index = 0;index < tokens.length; index += 1) {
+    const executable = executableName(tokens[index]).replace(/\.(?:exe|cmd)$/, "");
+    if (["pi", "omp", "oh-my-pi"].includes(executable))
+      return true;
+    if (["node", "bun", "deno"].includes(executable)) {
+      const script = executableName(tokens[index + 1]).replace(/\.(?:exe|cmd)$/, "");
+      if (["pi", "pi.js", "pi.mjs", "pi.cjs"].includes(script) || tokens[index + 1]?.includes("pi-coding-agent")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function classifyProcessKind(command) {
+  if (!command)
+    return "process";
+  const tokens = commandTokens(command);
+  const openCodeIndex = commandHasOpenCodeExecutable(tokens);
+  if (openCodeIndex >= 0) {
+    const args = tokens.slice(openCodeIndex + 1);
+    if (args.some((token) => token === "serve" || token === "--serve" || token.startsWith("--serve="))) {
+      return "OpenCode server";
+    }
+    return "OpenCode instance (TUI/CLI)";
+  }
+  return commandHasPiExecutable(tokens) ? "Pi" : "process";
+}
 function commandLooksLikeOpenCode(command) {
   const normalized = command.toLowerCase();
   return OPEN_CODE_COMMAND_MARKERS.some((marker) => normalized.includes(marker));
 }
 function isPidIdentityPlausible(record) {
   if (!Number.isInteger(record.pid) || record.pid <= 0)
-    return false;
+    return "implausible";
   if (Number.isFinite(record.started_at) && record.started_at > 0) {
-    const processStartTime = rpcIdentityPlatform === "linux" ? readLinuxProcessStartTime(record.pid) : readPsProcessStartTime(record.pid);
+    const processStartTime = rpcIdentityPlatform === "linux" ? readLinuxProcessStartTime(record.pid) : rpcIdentityPlatform === "win32" ? null : readPsProcessStartTime(record.pid);
     if (processStartTime === null)
-      return true;
-    return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS;
+      return "inconclusive";
+    return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS ? "plausible" : "implausible";
   }
-  const command = rpcIdentityPlatform === "linux" ? readLinuxProcessCommand(record.pid) : readPsProcessCommand(record.pid);
+  const command = rpcIdentityPlatform === "linux" ? readLinuxProcessCommand(record.pid) : rpcIdentityPlatform === "win32" ? readWindowsProcess(record.pid).command ?? null : readPsProcessCommand(record.pid);
   if (command === null)
-    return true;
-  return commandLooksLikeOpenCode(command);
+    return "inconclusive";
+  return commandLooksLikeOpenCode(command) ? "plausible" : "implausible";
 }
 function commandLooksLikePi(command) {
   const normalized = command.trim().toLowerCase().replaceAll("\\", "/");
   const tokens = normalized.split(/\s+/).filter(Boolean);
-  const executableName = (token) => (token ?? "").split("/").at(-1) ?? "";
-  const first = executableName(tokens[0]).replace(/\.exe$/, "");
+  const executableName2 = (token) => (token ?? "").split("/").at(-1) ?? "";
+  const first = executableName2(tokens[0]).replace(/\.exe$/, "");
   if (["pi", "pi.cmd", "omp", "oh-my-pi"].includes(first))
     return true;
   if (["node", "bun", "deno"].includes(first)) {
-    const script = executableName(tokens[1]);
+    const script = executableName2(tokens[1]);
     return ["pi", "pi.js", "pi.mjs", "pi.cjs"].includes(script) || normalized.includes("pi-coding-agent");
   }
   return false;
@@ -705,20 +844,39 @@ function commandLooksLikePi(command) {
 function inspectLivePiProcesses() {
   if (false) {}
   try {
-    const output = String(rpcProcessListExecFileSync("ps", ["-axo", "pid=,command="], {
+    const isWindows = rpcIdentityPlatform === "win32";
+    const output = String(rpcProcessListExecFileSync(isWindows ? "tasklist" : "ps", isWindows ? ["/FO", "CSV"] : ["-axo", "pid=,command="], {
       encoding: "utf8",
-      timeout: PS_PROBE_TIMEOUT_MS
+      timeout: PS_PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
     }));
     const pids = new Set;
-    for (const line of output.split(/\r?\n/)) {
-      const match = /^\s*(\d+)\s+(.+)$/.exec(line);
-      if (!match)
-        continue;
-      const pid = Number(match[1]);
-      if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid)
-        continue;
-      if (commandLooksLikePi(match[2]))
-        pids.add(pid);
+    if (isWindows) {
+      const entries = parseTasklistOutput(output);
+      if (entries === null) {
+        return {
+          state: "unreadable",
+          processIds: [],
+          error: "tasklist output unavailable"
+        };
+      }
+      for (const entry of entries) {
+        if (entry.pid === process.pid)
+          continue;
+        if (commandLooksLikePi(entry.command))
+          pids.add(entry.pid);
+      }
+    } else {
+      for (const line of output.split(/\r?\n/)) {
+        const match = /^\s*(\d+)\s+(.+)$/.exec(line);
+        if (!match)
+          continue;
+        const pid = Number(match[1]);
+        if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid)
+          continue;
+        if (commandLooksLikePi(match[2]))
+          pids.add(pid);
+      }
     }
     return { state: "known", processIds: [...pids].sort((left, right) => left - right) };
   } catch (error) {
@@ -729,9 +887,6 @@ function inspectLivePiProcesses() {
     };
   }
 }
-function discoverLivePiProcessIds() {
-  return inspectLivePiProcesses().processIds;
-}
 function parseRpcPortFile(content, fallbackPid = 0) {
   const trimmed = content.trim();
   if (!trimmed)
@@ -748,6 +903,8 @@ function parseRpcPortFile(content, fallbackPid = 0) {
         port: port2,
         pid,
         started_at: Number.isFinite(startedAt) ? startedAt : 0,
+        kind: typeof parsed.kind === "string" ? parsed.kind : undefined,
+        harness: typeof parsed.harness === "string" ? parsed.harness : undefined,
         token: typeof parsed.token === "string" ? parsed.token : undefined,
         instance_id: typeof parsed.instance_id === "string" ? parsed.instance_id : undefined
       };
@@ -1415,6 +1572,7 @@ function prepareMirrorPageStatements(db) {
   return {
     identityByModule: db.prepare("SELECT context_row_id FROM mirror_identity WHERE domain = ? AND module_project = ? AND module_row_id = ?"),
     insertIdentity: db.prepare("INSERT OR IGNORE INTO mirror_identity(domain, module_project, module_row_id, context_row_id) VALUES (?, ?, ?, ?)"),
+    deleteIdentityByContext: db.prepare("DELETE FROM mirror_identity WHERE domain = ? AND context_row_id = ?"),
     deleteLiveMemory: db.prepare("DELETE FROM mirror_live_memory_rows WHERE module_project = ? AND module_row_id = ?"),
     deletePendingReferencesForMemory: db.prepare("DELETE FROM mirror_pending_references WHERE domain = ? AND module_project = ? AND (module_row_id = ? OR target_module_row_id = ?)"),
     deleteIdentity: db.prepare("DELETE FROM mirror_identity WHERE domain = ? AND module_project = ? AND module_row_id = ?"),
@@ -1466,7 +1624,7 @@ function prepareMirrorPageStatements(db) {
              check_quarantined_until = ?, check_next_due_at = ?, check_compiled_at = ?, check_false_since_at = ?,
              check_last_liveness_at = ?, last_checked_at = ?, check_status = ?, check_version = ?,
              policy_version = ?, anchor_block_id = ?, anchor_ordinal = ?, created_at = ?, updated_at = ? WHERE id = ?`),
-    upsertNoteRevision: db.prepare("INSERT INTO mirror_note_revisions(module_project, module_row_id, context_row_id, status_version) VALUES (?, ?, ?, ?) ON CONFLICT(module_project, module_row_id) DO UPDATE SET context_row_id = excluded.context_row_id, status_version = excluded.status_version"),
+    upsertNoteRevision: db.prepare("INSERT OR REPLACE INTO mirror_note_revisions(module_project, module_row_id, context_row_id, status_version) VALUES (?, ?, ?, ?)"),
     translateMemoryReferences: db.prepare(`UPDATE memories
                 SET superseded_by_memory_id = (
                     SELECT target.context_row_id
@@ -1551,6 +1709,9 @@ function rememberIdentity(db, domain, moduleProject, moduleRowId, contextRowId,
   const existing = mirrorIdentity(db, domain, moduleProject, moduleRowId, statements);
   if (existing)
     return;
+  if (domain === "notes") {
+    (statements?.deleteIdentityByContext ?? db.prepare("DELETE FROM mirror_identity WHERE domain = ? AND context_row_id = ?")).run(domain, contextRowId);
+  }
   (statements?.insertIdentity ?? db.prepare("INSERT OR IGNORE INTO mirror_identity(domain, module_project, module_row_id, context_row_id) VALUES (?, ?, ?, ?)")).run(domain, moduleProject, moduleRowId, contextRowId);
 }
 function contextMemoryId(db, domain, moduleProject, row, moduleRowId, statements) {
@@ -2133,6 +2294,8 @@ function healAllNullColumns(db) {
     ["stripped_placeholder_ids", ""],
     ["stale_reduce_stripped_ids", ""],
     ["processed_image_stripped_ids", ""],
+    ["merged_reasoning_stripped_ids", ""],
+    ["trailing_blank_decisions", ""],
     ["memory_block_cache", ""],
     ["memory_block_ids", ""],
     ["compaction_marker_state", ""],
@@ -2244,6 +2407,7 @@ import path from "node:path";
 var GIT_TIMEOUT_MS = 5000;
 var TRANSIENT_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
 var identityCache = new Map;
+var linkedGitWorktreeCache = new Map;
 var lastKnownGitIdentityCache = new Map;
 var directoryFallbackCache = new Map;
 var transientFailureCooldown = new Map;
@@ -2458,7 +2622,12 @@ function takeDubiousOwnershipProjectIdentityWarning(directory) {
   return formatDubiousOwnershipWarning(canonical);
 }
 function canonicalUserHomeDirectory() {
-  return realpathSync.native(userHomeDirectoryForIdentity());
+  const homeDirectory = userHomeDirectoryForIdentity();
+  try {
+    return realpathSync.native(homeDirectory);
+  } catch {
+    return homeDirectory;
+  }
 }
 function isUserHomeDirectory(directory) {
   try {
@@ -2592,6 +2761,27 @@ function normalizeStoredProjectPath(rawOrStored) {
 function storedPathBelongsToIdentity(storedProjectPath, projectIdentity) {
   return storedProjectPath === projectIdentity || normalizeStoredProjectPath(storedProjectPath) === projectIdentity;
 }
+function isLinkedGitWorktree(directory) {
+  const resolvedDirectory = path.resolve(directory);
+  const cached = linkedGitWorktreeCache.get(resolvedDirectory);
+  if (cached !== undefined)
+    return cached;
+  let linked = false;
+  try {
+    const output = execFileSyncForIdentity("git", ["rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir"], {
+      cwd: resolvedDirectory,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      windowsHide: true
+    });
+    const [gitDir, commonDir] = String(output).split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+    linked = Boolean(gitDir && commonDir && path.resolve(gitDir) !== path.resolve(commonDir));
+  } catch {
+    linked = hasGitDir(resolvedDirectory);
+  }
+  linkedGitWorktreeCache.set(resolvedDirectory, linked);
+  return linked;
+}
 // src/features/magic-context/workspaces.ts
 var VALID_SHARE_CATEGORIES = new Set(V2_MEMORY_CATEGORIES);
 var DEFAULT_WORKSPACE_SHARE_CATEGORIES = ["CONSTRAINTS"];
@@ -3083,6 +3273,7 @@ var MIGRATIONS = [
                     status TEXT NOT NULL DEFAULT 'active',
                     promoted_at INTEGER NOT NULL,
                     source_candidate_ids TEXT DEFAULT '[]',
+                    source_candidate_provenance TEXT,
                     created_at INTEGER NOT NULL,
                     updated_at INTEGER NOT NULL
                 );
@@ -4109,6 +4300,7 @@ var MIGRATIONS = [
                     last_observed_at INTEGER,
                     answer_refreshed_at INTEGER,
                     source_candidate_ids TEXT NOT NULL DEFAULT '[]',
+                    source_candidate_provenance TEXT,
                     created_at INTEGER NOT NULL,
                     updated_at INTEGER NOT NULL
                 );
@@ -4918,6 +5110,37 @@ var MIGRATIONS = [
       ensureColumn(db, "notes", "compiled_at", "INTEGER");
       ensureColumn(db, "notes", "compile_status", "TEXT CHECK(compile_status IN ('compiled', 'plain', 'refused'))");
     }
+  },
+  {
+    version: 77,
+    description: "persist scoped provenance for promoted user memories and primers",
+    up(db) {
+      if (tableExists2(db, "user_memories")) {
+        ensureColumn(db, "user_memories", "source_candidate_provenance", "TEXT");
+      }
+      if (tableExists2(db, "primers")) {
+        ensureColumn(db, "primers", "source_candidate_provenance", "TEXT");
+      }
+    }
+  },
+  {
+    version: 78,
+    description: "add migration_pending journal for crash-safe cross-harness session migration",
+    up(db) {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS migration_pending (
+                    migration_key TEXT PRIMARY KEY,
+                    source_session_id TEXT NOT NULL,
+                    target_harness TEXT NOT NULL,
+                    pi_session_id TEXT NOT NULL,
+                    final_path TEXT NOT NULL,
+                    stage_path TEXT NOT NULL,
+                    content_sha256 TEXT NOT NULL,
+                    phase TEXT NOT NULL CHECK (phase IN ('staged', 'db_committed')),
+                    created_at INTEGER NOT NULL
+                );
+            `);
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -5385,7 +5608,7 @@ function getSchemaFenceRejection() {
 function getMigrationOnOpenRefusal() {
   return lastMigrationOnOpenRefusal;
 }
-var LATEST_SUPPORTED_VERSION = 76;
+var LATEST_SUPPORTED_VERSION = 78;
 var PERMISSIONS_ENFORCEABLE = process.platform !== "win32";
 var defaultStoragePermissionFs = { chmodSync, mkdirSync };
 var storagePermissionFs = defaultStoragePermissionFs;
@@ -5532,6 +5755,28 @@ function invalidDiscoveryReason(raw) {
   }
   return "parse-invalid";
 }
+function classifyDiscoveryRecordKind(record) {
+  for (const value of [record.kind, record.harness]) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized)
+      continue;
+    if (normalized === "process")
+      return "process";
+    if (normalized === "opencode server" || normalized === "server") {
+      return "OpenCode server";
+    }
+    if (normalized === "opencode instance" || normalized === "opencode instance (tui/cli)" || normalized === "opencode" || normalized === "tui" || normalized === "cli") {
+      return "OpenCode instance (TUI/CLI)";
+    }
+    if (normalized === "pi" || normalized === "pi harness" || normalized === "omp" || normalized === "oh-my-pi") {
+      return "Pi";
+    }
+  }
+  return null;
+}
+function classifyRpcProcess(record) {
+  return classifyDiscoveryRecordKind(record) ?? classifyProcessKind(readProcessCommand(record.pid));
+}
 function classifyJunkDiscovery(portFile, raw, staleFiles) {
   let mtimeMs;
   try {
@@ -5584,7 +5829,9 @@ function inspectRpcServerDiscovery(storageDir) {
     return { state: "absent", serverPids: [], staleFiles: [] };
   }
   const pids = new Set;
+  const processByPid = new Map;
   const staleFiles = [];
+  const inconclusivePids = new Set;
   for (const portFile of portFiles) {
     let raw;
     try {
@@ -5604,10 +5851,23 @@ function inspectRpcServerDiscovery(storageDir) {
         return junk;
       continue;
     }
-    if (isPidAlive(record.pid) && isPidIdentityPlausible(record))
+    const liveness = isPidAlive(record.pid);
+    const identity = liveness === "dead" ? "implausible" : isPidIdentityPlausible(record);
+    if (liveness === "alive" && identity === "plausible") {
       pids.add(record.pid);
-    else
+      const detected = {
+        kind: classifyRpcProcess(record),
+        pid: record.pid
+      };
+      const previous = processByPid.get(record.pid);
+      if (!previous || previous.kind === "process" && detected.kind !== "process") {
+        processByPid.set(record.pid, detected);
+      }
+    } else if (liveness === "dead" || identity === "implausible") {
       staleFiles.push(portFile);
+    } else {
+      inconclusivePids.add(record.pid);
+    }
   }
   for (const staleFile of staleFiles) {
     try {
@@ -5618,10 +5878,55 @@ function inspectRpcServerDiscovery(storageDir) {
   }
   const serverPids = [...pids].sort((a, b) => a - b);
   if (serverPids.length > 0) {
-    return { state: "live", serverPids, staleFiles };
+    return {
+      state: "live",
+      serverPids,
+      serverProcesses: serverPids.map((pid) => processByPid.get(pid) ?? { kind: "process", pid }),
+      staleFiles
+    };
+  }
+  const uncertainPids = [...inconclusivePids].sort((a, b) => a - b);
+  if (uncertainPids.length > 0) {
+    return {
+      state: "inconclusive",
+      serverPids: [],
+      staleFiles,
+      inconclusivePids: uncertainPids
+    };
   }
   return { state: "stale", serverPids: [], staleFiles };
 }
+function formatInconclusiveOpenCodeMigrationWarning(dbPath, pids) {
+  return `[magic-context] storage warning: continuing migration for ${dbPath}; OpenCode server PID ${pids.join(", ")} was not confirmed because its liveness or identity check could not run. This commonly means an OS sandbox denied kill(0) or ps. No live OpenCode server was confirmed.`;
+}
+function logInconclusiveMigrationProbes(dbPath, discovery, piProbeState) {
+  const uncertainPids = discovery.inconclusivePids ?? [];
+  if (uncertainPids.length > 0) {
+    log(formatInconclusiveOpenCodeMigrationWarning(dbPath, uncertainPids));
+  }
+  if (piProbeState === "unreadable") {
+    log(`[magic-context] storage warning: continuing migration for ${dbPath}; the Pi/OMP process-list probe could not run, which commonly means an OS sandbox denied ps. No live Pi harness was confirmed.`);
+  }
+}
+function isDefaultSharedDatabasePath(dbPath) {
+  if (!process.env.XDG_DATA_HOME && (process.env.MAGIC_CONTEXT_TEST_DATA_DIR || false)) {
+    return false;
+  }
+  return resolve(dbPath) === resolve(join3(getMagicContextStorageDir(), "context.db"));
+}
+function migrationBlockingPiPids(dbPath, discovery, discoveredPiPids) {
+  if (isDefaultSharedDatabasePath(dbPath))
+    return [...discoveredPiPids];
+  const sameDataDirPids = new Set(discovery.serverPids);
+  return discoveredPiPids.filter((pid) => sameDataDirPids.has(pid));
+}
+function formatLiveProcessMigrationRefusal(dbPath, persistedVersion, latestSupportedVersion, serverPids, piPids) {
+  const blockers = [
+    ...serverPids.map((pid) => `confirmed OpenCode server PID ${pid}`),
+    ...piPids.map((pid) => `confirmed Pi harness PID ${pid}`)
+  ];
+  return `[magic-context] storage fatal: refusing to migrate ${dbPath} from upstream migration v${persistedVersion} to v${latestSupportedVersion} while ${blockers.join(", ")} still use the old plugin build. Restart the blocking harness, then retry this process.`;
+}
 function enforceMigrationOnOpenGuard(db, dbPath, dbDir, latestSupportedVersion) {
   const persistedVersion = getPersistedSchemaVersion(db);
   if (persistedVersion >= latestSupportedVersion) {
@@ -5629,9 +5934,16 @@ function enforceMigrationOnOpenGuard(db, dbPath, dbDir, latestSupportedVersion)
     return true;
   }
   const discovery = inspectRpcServerDiscovery(dbDir);
-  const piPids = discoverLivePiProcessIds();
-  if ((discovery.state === "absent" || discovery.state === "stale") && piPids.length === 0) {
+  const piDiscovery = inspectLivePiProcesses();
+  const piPids = migrationBlockingPiPids(dbPath, discovery, piDiscovery.processIds);
+  const serverProcesses = discovery.serverProcesses ?? (discovery.state === "live" ? discovery.serverPids.map((pid) => ({ kind: "process", pid })) : []);
+  const blockingProcesses = [
+    ...serverProcesses,
+    ...piPids.map((pid) => ({ kind: "Pi", pid }))
+  ];
+  if ((discovery.state === "absent" || discovery.state === "stale" || discovery.state === "inconclusive") && piPids.length === 0) {
     lastMigrationOnOpenRefusal = null;
+    logInconclusiveMigrationProbes(dbPath, discovery, piDiscovery.state);
     return true;
   }
   const blockingPids = [...new Set([...discovery.serverPids, ...piPids])].sort((left, right) => left - right);
@@ -5639,6 +5951,7 @@ function enforceMigrationOnOpenGuard(db, dbPath, dbDir, latestSupportedVersion)
     persistedVersion,
     supportedVersion: latestSupportedVersion,
     serverPids: blockingPids,
+    blockingProcesses,
     ...discovery.unreadableFile ? { unreadableFile: discovery.unreadableFile } : {},
     ...discovery.unreadableArm ? { unreadableArm: discovery.unreadableArm } : {}
   };
@@ -5648,11 +5961,7 @@ function enforceMigrationOnOpenGuard(db, dbPath, dbDir, latestSupportedVersion)
     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 {
-    const blockers = [
-      ...discovery.serverPids.map((pid) => `OpenCode server PID ${pid}`),
-      ...piPids.map((pid) => `Pi harness PID ${pid}`)
-    ];
-    log(`[magic-context] storage fatal: refusing to migrate ${dbPath} from upstream migration v${persistedVersion} to v${latestSupportedVersion} while ${blockers.join(", ")} may still use the old plugin build. Restart the blocking harness, then retry this process.`);
+    log(formatLiveProcessMigrationRefusal(dbPath, persistedVersion, latestSupportedVersion, discovery.serverPids, piPids));
   }
   return false;
 }
@@ -5876,6 +6185,7 @@ function initializeDatabase(db) {
       last_observed_at INTEGER,
       answer_refreshed_at INTEGER,
       source_candidate_ids TEXT NOT NULL DEFAULT '[]',
+      source_candidate_provenance TEXT,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL
     );
@@ -6511,6 +6821,11 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "primer_candidates", "question_embedding", "BLOB");
   ensureColumn(db, "primer_candidates", "question_embedding_model_id", "TEXT");
   ensureColumn(db, "primers", "question_embedding_model_id", "TEXT");
+  ensureColumn(db, "primers", "source_candidate_provenance", "TEXT");
+  const hasUserMemoriesTable = db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'user_memories'").get();
+  if (hasUserMemoriesTable) {
+    ensureColumn(db, "user_memories", "source_candidate_provenance", "TEXT");
+  }
   db.exec(`
       CREATE UNIQUE INDEX IF NOT EXISTS idx_primer_candidates_occurrence
         ON primer_candidates(project_path, harness, session_id, source_start_message_id, source_end_message_id);
@@ -6584,6 +6899,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "stripped_placeholder_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "stale_reduce_stripped_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "processed_image_stripped_ids", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "merged_reasoning_stripped_ids", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "trailing_blank_decisions", "TEXT DEFAULT ''");
   ensureColumn(db, "compartments", "start_message_id", "TEXT DEFAULT ''");
   ensureColumn(db, "compartments", "end_message_id", "TEXT DEFAULT ''");
   ensureColumn(db, "memory_embeddings", "model_id", "TEXT");
@@ -6802,11 +7119,11 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "message_history_index", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "workspaces", "share_categories", `TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'`);
 }
-var CHANNEL2_CLAIM_TTL_MS = 120000;
+var CHANNEL2_CLAIM_TTL_MS = 10 * 60000;
 function healWedgedChannel2Claims(db) {
   try {
     const staleBefore = Date.now() - CHANNEL2_CLAIM_TTL_MS;
-    db.prepare("UPDATE session_meta SET channel2_nudge_state = 'pending', channel2_nudge_claimed_at = 0, channel2_nudge_claim_token = '' WHERE channel2_nudge_state = 'claimed' AND (channel2_nudge_claimed_at IS NULL OR channel2_nudge_claimed_at = 0 OR channel2_nudge_claimed_at <= ?)").run(staleBefore);
+    db.prepare("UPDATE session_meta SET channel2_nudge_state = '', channel2_nudge_claimed_at = 0, channel2_nudge_claim_token = '' WHERE channel2_nudge_state = 'claimed' AND (channel2_nudge_claimed_at IS NULL OR channel2_nudge_claimed_at = 0 OR channel2_nudge_claimed_at <= ?)").run(staleBefore);
   } catch {}
 }
 function openDatabase(dbPathOrOptions) {
@@ -8205,7 +8522,7 @@ function clearHistorianFailureState(db, sessionId) {
   })();
 }
 function normalizeDetectedLimitModelKey(modelKey) {
-  return typeof modelKey === "string" && modelKey.length > 0 ? modelKey : null;
+  return typeof modelKey === "string" && modelKey.length > 0 ? piModelRefToCanonical(modelKey) : null;
 }
 function normalizeEmergencyRecoveryOrigin(value) {
   return value === "provider_overflow" || value === "proactive_model_shrink" ? value : null;
@@ -8356,6 +8673,96 @@ function removeStrippedPlaceholderId(db, sessionId, messageId) {
   applyStrippedPlaceholderDelta(db, sessionId, { remove: [messageId] });
   return true;
 }
+function getMergedReasoningStrippedIds(db, sessionId) {
+  const row = db.prepare("SELECT merged_reasoning_stripped_ids FROM session_meta WHERE session_id = ?").get(sessionId);
+  return new Set(parseStrippedBlob(row?.merged_reasoning_stripped_ids));
+}
+function addMergedReasoningStrippedIds(db, sessionId, ids) {
+  const add = [...ids];
+  if (add.length === 0)
+    return true;
+  ensureSessionMetaRow(db, sessionId);
+  for (let attempt = 0;attempt < CAS_RETRY_LIMIT; attempt += 1) {
+    const row = db.prepare("SELECT merged_reasoning_stripped_ids FROM session_meta WHERE session_id = ?").get(sessionId);
+    const rawStored = row ? row.merged_reasoning_stripped_ids ?? null : null;
+    const current = new Set(parseStrippedBlob(rawStored));
+    let changed = false;
+    for (const id of add) {
+      if (!current.has(id)) {
+        current.add(id);
+        changed = true;
+      }
+    }
+    if (!changed)
+      return true;
+    const nextBlob = JSON.stringify([...current]);
+    const result = db.prepare("UPDATE session_meta SET merged_reasoning_stripped_ids = ? WHERE session_id = ? AND merged_reasoning_stripped_ids IS ?").run(nextBlob, sessionId, rawStored);
+    if (result.changes > 0)
+      return true;
+  }
+  sessionLog(sessionId, `merged_reasoning_stripped_ids CAS: ${CAS_RETRY_LIMIT} retries exhausted`);
+  return false;
+}
+function isPersistedTrailingBlankDecision(value) {
+  if (value === "keep" || value === "strip")
+    return true;
+  if (typeof value !== "string" || !value.startsWith("keep:"))
+    return false;
+  const countText = value.slice("keep:".length);
+  if (!/^[1-9]\d*$/.test(countText))
+    return false;
+  const count = Number(countText);
+  return Number.isSafeInteger(count) && count > 1 && count <= 1e4;
+}
+function parseTrailingBlankDecisions(raw) {
+  if (!raw)
+    return new Map;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return new Map;
+    const decisions = new Map;
+    for (const [id, decision] of Object.entries(parsed)) {
+      if (id.length > 0 && isPersistedTrailingBlankDecision(decision)) {
+        decisions.set(id, decision);
+      }
+    }
+    return decisions;
+  } catch {
+    return new Map;
+  }
+}
+function getTrailingBlankDecisions(db, sessionId) {
+  const row = db.prepare("SELECT trailing_blank_decisions FROM session_meta WHERE session_id = ?").get(sessionId);
+  return parseTrailingBlankDecisions(row?.trailing_blank_decisions);
+}
+function addTrailingBlankDecisions(db, sessionId, additions, options) {
+  const add = [...additions];
+  if (add.length === 0)
+    return true;
+  ensureSessionMetaRow(db, sessionId);
+  for (let attempt = 0;attempt < CAS_RETRY_LIMIT; attempt += 1) {
+    const row = db.prepare("SELECT trailing_blank_decisions FROM session_meta WHERE session_id = ?").get(sessionId);
+    const rawStored = row ? row.trailing_blank_decisions ?? null : null;
+    const current = parseTrailingBlankDecisions(rawStored);
+    let changed = false;
+    for (const [id, decision] of add) {
+      const currentDecision = current.get(id);
+      if (currentDecision === undefined || id === options?.overwriteMessageId && currentDecision !== decision) {
+        current.set(id, decision);
+        changed = true;
+      }
+    }
+    if (!changed)
+      return true;
+    const nextBlob = JSON.stringify(Object.fromEntries(current));
+    const result = db.prepare("UPDATE session_meta SET trailing_blank_decisions = ? WHERE session_id = ? AND trailing_blank_decisions IS ?").run(nextBlob, sessionId, rawStored);
+    if (result.changes > 0)
+      return true;
+  }
+  sessionLog(sessionId, `trailing_blank_decisions CAS: ${CAS_RETRY_LIMIT} retries exhausted`);
+  return false;
+}
 function getStaleReduceStrippedIds(db, sessionId) {
   const row = db.prepare("SELECT stale_reduce_stripped_ids FROM session_meta WHERE session_id = ?").get(sessionId);
   return new Set(parseStrippedBlob(row?.stale_reduce_stripped_ids));
@@ -8803,6 +9210,76 @@ function parseCandidateIds(raw) {
     return [];
   }
 }
+function parsePrimerSourceProvenance(raw) {
+  if (raw === null)
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+      return null;
+    const provenance = [];
+    for (const value of parsed) {
+      if (!value || typeof value !== "object")
+        return null;
+      const source = value;
+      if (typeof source.candidate_id !== "number" || !Number.isFinite(source.candidate_id) || typeof source.project_path !== "string" || typeof source.harness !== "string" || typeof source.session_id !== "string" || source.source_compartment_start !== null && typeof source.source_compartment_start !== "number" || source.source_compartment_end !== null && typeof source.source_compartment_end !== "number" || typeof source.source_start_message_id !== "string" || typeof source.source_end_message_id !== "string") {
+        return null;
+      }
+      provenance.push({
+        candidateId: source.candidate_id,
+        projectPath: source.project_path,
+        harness: source.harness,
+        sessionId: source.session_id,
+        sourceCompartmentStart: source.source_compartment_start,
+        sourceCompartmentEnd: source.source_compartment_end,
+        sourceStartMessageId: source.source_start_message_id,
+        sourceEndMessageId: source.source_end_message_id
+      });
+    }
+    return provenance;
+  } catch {
+    return null;
+  }
+}
+function loadPrimerSourceProvenance(db, candidateIds) {
+  const ids = [...new Set(candidateIds)].sort((a, b) => a - b);
+  if (ids.length === 0)
+    return [];
+  const placeholders3 = ids.map(() => "?").join(",");
+  const rows = db.prepare(`SELECT id, project_path, harness, session_id,
+                    source_compartment_start, source_compartment_end,
+                    source_start_message_id, source_end_message_id
+               FROM primer_candidates
+              WHERE id IN (${placeholders3})
+              ORDER BY id ASC`).all(...ids);
+  return rows.map((row) => ({
+    candidateId: row.id,
+    projectPath: row.project_path,
+    harness: row.harness,
+    sessionId: row.session_id,
+    sourceCompartmentStart: row.source_compartment_start,
+    sourceCompartmentEnd: row.source_compartment_end,
+    sourceStartMessageId: row.source_start_message_id,
+    sourceEndMessageId: row.source_end_message_id
+  }));
+}
+function serializePrimerSourceProvenance(provenance, sourceCandidateIds) {
+  if (provenance.length === 0 && sourceCandidateIds.length > 0)
+    return null;
+  return JSON.stringify(provenance.map((source) => ({
+    candidate_id: source.candidateId,
+    project_path: source.projectPath,
+    harness: source.harness,
+    session_id: source.sessionId,
+    source_compartment_start: source.sourceCompartmentStart,
+    source_compartment_end: source.sourceCompartmentEnd,
+    source_start_message_id: source.sourceStartMessageId,
+    source_end_message_id: source.sourceEndMessageId
+  })));
+}
+function normalizedCandidateIds(candidateIds) {
+  return [...new Set(candidateIds)].sort((a, b) => a - b);
+}
 function toCandidate(row) {
   return {
     id: row.id,
@@ -8835,6 +9312,7 @@ function toPrimer(row) {
     lastObservedAt: row.last_observed_at,
     answerRefreshedAt: row.answer_refreshed_at,
     sourceCandidateIds: parseCandidateIds(row.source_candidate_ids),
+    sourceProvenance: parsePrimerSourceProvenance(row.source_candidate_provenance),
     createdAt: row.created_at,
     updatedAt: row.updated_at
   };
@@ -8906,23 +9384,43 @@ function getActivePrimers(db, projectPath) {
   return rows.map(toPrimer);
 }
 function createPrimer(db, input) {
-  const now = input.now ?? Date.now();
-  const info = db.prepare(`INSERT INTO primers (
-                project_path, question, question_embedding, question_embedding_model_id, answer,
-                status, total_support, last_observed_at, answer_refreshed_at,
-                source_candidate_ids, created_at, updated_at
-             ) VALUES (?, ?, ?, ?, ?, 'active', ?, ?, NULL, ?, ?, ?)`).run(input.projectPath, input.question, vectorBlob(input.questionEmbedding), input.questionEmbeddingModelId ?? null, input.answer ?? "", input.totalSupport, input.lastObservedAt, JSON.stringify([...new Set(input.sourceCandidateIds)].sort((a, b) => a - b)), now, now);
-  return Number(info.lastInsertRowid);
+  return db.transaction(() => {
+    const now = input.now ?? Date.now();
+    const sourceCandidateIds = normalizedCandidateIds(input.sourceCandidateIds);
+    const sourceProvenance = loadPrimerSourceProvenance(db, sourceCandidateIds);
+    const info = db.prepare(`INSERT INTO primers (
+                    project_path, question, question_embedding, question_embedding_model_id, answer,
+                    status, total_support, last_observed_at, answer_refreshed_at,
+                    source_candidate_ids, source_candidate_provenance, created_at, updated_at
+                 ) VALUES (?, ?, ?, ?, ?, 'active', ?, ?, NULL, ?, ?, ?, ?)`).run(input.projectPath, input.question, vectorBlob(input.questionEmbedding), input.questionEmbeddingModelId ?? null, input.answer ?? "", input.totalSupport, input.lastObservedAt, JSON.stringify(sourceCandidateIds), serializePrimerSourceProvenance(sourceProvenance, sourceCandidateIds), now, now);
+    return Number(info.lastInsertRowid);
+  })();
 }
 function updatePrimerSupport(db, input) {
-  db.prepare(`UPDATE primers
-         SET question_embedding = COALESCE(?, question_embedding),
-             question_embedding_model_id = COALESCE(?, question_embedding_model_id),
-             total_support = ?,
-             last_observed_at = ?,
-             source_candidate_ids = ?,
-             updated_at = ?
-         WHERE id = ?`).run(vectorBlob(input.questionEmbedding), input.questionEmbeddingModelId ?? null, input.totalSupport, input.lastObservedAt, JSON.stringify([...new Set(input.sourceCandidateIds)].sort((a, b) => a - b)), input.now ?? Date.now(), input.primerId);
+  db.transaction(() => {
+    const sourceCandidateIds = normalizedCandidateIds(input.sourceCandidateIds);
+    const allowedIds = new Set(sourceCandidateIds);
+    const existingRow = db.prepare("SELECT source_candidate_provenance FROM primers WHERE id = ?").get(input.primerId);
+    const provenanceByCandidateId = new Map;
+    for (const source of parsePrimerSourceProvenance(existingRow?.source_candidate_provenance ?? null) ?? []) {
+      if (allowedIds.has(source.candidateId)) {
+        provenanceByCandidateId.set(source.candidateId, source);
+      }
+    }
+    for (const source of loadPrimerSourceProvenance(db, sourceCandidateIds)) {
+      provenanceByCandidateId.set(source.candidateId, source);
+    }
+    const sourceProvenance = [...provenanceByCandidateId.values()].sort((a, b) => a.candidateId - b.candidateId);
+    db.prepare(`UPDATE primers
+             SET question_embedding = COALESCE(?, question_embedding),
+                 question_embedding_model_id = COALESCE(?, question_embedding_model_id),
+                 total_support = ?,
+                 last_observed_at = ?,
+                 source_candidate_ids = ?,
+                 source_candidate_provenance = ?,
+                 updated_at = ?
+             WHERE id = ?`).run(vectorBlob(input.questionEmbedding), input.questionEmbeddingModelId ?? null, input.totalSupport, input.lastObservedAt, JSON.stringify(sourceCandidateIds), serializePrimerSourceProvenance(sourceProvenance, sourceCandidateIds), input.now ?? Date.now(), input.primerId);
+  })();
 }
 function updatePrimerAnswer(db, primerId, answer, refreshedAt = Date.now()) {
   db.prepare("UPDATE primers SET answer = ?, answer_refreshed_at = ?, updated_at = ? WHERE id = ?").run(answer, refreshedAt, refreshedAt, primerId);
@@ -9026,6 +9524,1097 @@ function getLatestHistorianInvocationId(db, sessionId) {
     return null;
   }
 }
+// src/features/magic-context/reclaim-protection.ts
+var CTX_REDUCE_KEEP = 3;
+function newestCtxReduceTagNumbers(tags) {
+  return new Set(tags.filter((tag) => tag.toolName === "ctx_reduce").sort((left, right) => right.tagNumber - left.tagNumber).slice(0, CTX_REDUCE_KEEP).map((tag) => tag.tagNumber));
+}
+
+// src/hooks/magic-context/image-token-estimate.ts
+var IMAGE_TOKEN_DIVISOR = 750;
+var IMAGE_FALLBACK_TOKENS = 1200;
+var IMAGE_TOKEN_CAP = 4500;
+function estimateImageTokensFromDataUrl(url) {
+  const comma = url.indexOf(",");
+  if (comma < 0)
+    return IMAGE_FALLBACK_TOKENS;
+  const header = url.slice(0, comma);
+  const payload = url.slice(comma + 1);
+  const sliceLen = Math.min(512, payload.length);
+  const preview = payload.slice(0, sliceLen);
+  let bytes;
+  try {
+    bytes = base64Decode(preview);
+  } catch {
+    return IMAGE_FALLBACK_TOKENS;
+  }
+  if (header.includes("image/png")) {
+    const dims = parsePngDimensions(bytes);
+    if (dims)
+      return clampImageTokens(Math.ceil(dims.w * dims.h / IMAGE_TOKEN_DIVISOR));
+  } else if (header.includes("image/jpeg") || header.includes("image/jpg")) {
+    const dims = parseJpegDimensions(bytes);
+    if (dims)
+      return clampImageTokens(Math.ceil(dims.w * dims.h / IMAGE_TOKEN_DIVISOR));
+  } else if (header.includes("image/webp")) {
+    const dims = parseWebpDimensions(bytes);
+    if (dims)
+      return clampImageTokens(Math.ceil(dims.w * dims.h / IMAGE_TOKEN_DIVISOR));
+  } else if (header.includes("image/gif")) {
+    const dims = parseGifDimensions(bytes);
+    if (dims)
+      return clampImageTokens(Math.ceil(dims.w * dims.h / IMAGE_TOKEN_DIVISOR));
+  }
+  return IMAGE_FALLBACK_TOKENS;
+}
+function clampImageTokens(n) {
+  if (n < 1)
+    return 1;
+  if (n > IMAGE_TOKEN_CAP)
+    return IMAGE_TOKEN_CAP;
+  return n;
+}
+function base64Decode(b64) {
+  const pad = b64.length % 4;
+  const padded = pad === 0 ? b64 : b64 + "=".repeat(4 - pad);
+  const binary = atob(padded);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++)
+    out[i] = binary.charCodeAt(i);
+  return out;
+}
+function parsePngDimensions(b) {
+  if (b.length < 24)
+    return null;
+  if (b[0] !== 137 || b[1] !== 80 || b[2] !== 78 || b[3] !== 71 || b[4] !== 13 || b[5] !== 10 || b[6] !== 26 || b[7] !== 10)
+    return null;
+  const w = readUint32BE(b, 16);
+  const h = readUint32BE(b, 20);
+  if (!w || !h)
+    return null;
+  return { w, h };
+}
+function parseJpegDimensions(b) {
+  if (b.length < 4 || b[0] !== 255 || b[1] !== 216)
+    return null;
+  let i = 2;
+  while (i < b.length - 8) {
+    if (b[i] !== 255) {
+      i++;
+      continue;
+    }
+    const marker = b[i + 1];
+    if (marker === undefined)
+      break;
+    if (isSofMarker(marker)) {
+      const h = b[i + 5] << 8 | b[i + 6];
+      const w = b[i + 7] << 8 | b[i + 8];
+      if (w && h)
+        return { w, h };
+      return null;
+    }
+    if (marker === 216 || marker === 217 || marker === 1) {
+      i += 2;
+      continue;
+    }
+    const segLen = b[i + 2] << 8 | b[i + 3];
+    if (segLen < 2)
+      return null;
+    i += 2 + segLen;
+  }
+  return null;
+}
+function isSofMarker(m) {
+  if (m >= 192 && m <= 195)
+    return true;
+  if (m >= 197 && m <= 199)
+    return true;
+  if (m >= 201 && m <= 203)
+    return true;
+  if (m >= 205 && m <= 207)
+    return true;
+  return false;
+}
+function parseWebpDimensions(b) {
+  if (b.length < 30)
+    return null;
+  if (b[0] !== 82 || b[1] !== 73 || b[2] !== 70 || b[3] !== 70)
+    return null;
+  if (b[8] !== 87 || b[9] !== 69 || b[10] !== 66 || b[11] !== 80)
+    return null;
+  const variant = String.fromCharCode(b[12], b[13], b[14], b[15]);
+  if (variant === "VP8 ") {
+    const w = (b[26] | b[27] << 8) & 16383;
+    const h = (b[28] | b[29] << 8) & 16383;
+    if (w && h)
+      return { w, h };
+  } else if (variant === "VP8L") {
+    const b0 = b[21];
+    const b1 = b[22];
+    const b2 = b[23];
+    const b3 = b[24];
+    const w = 1 + ((b0 | b1 << 8) & 16383);
+    const h = 1 + ((b1 >> 6 | b2 << 2 | b3 << 10) & 16383);
+    if (w && h)
+      return { w, h };
+  } else if (variant === "VP8X") {
+    const w = 1 + (b[24] | b[25] << 8 | b[26] << 16);
+    const h = 1 + (b[27] | b[28] << 8 | b[29] << 16);
+    if (w && h)
+      return { w, h };
+  }
+  return null;
+}
+function parseGifDimensions(b) {
+  if (b.length < 10)
+    return null;
+  if (b[0] !== 71 || b[1] !== 73 || b[2] !== 70)
+    return null;
+  const w = b[6] | b[7] << 8;
+  const h = b[8] | b[9] << 8;
+  if (!w || !h)
+    return null;
+  return { w, h };
+}
+function readUint32BE(b, offset) {
+  return (b[offset] << 24 | b[offset + 1] << 16 | b[offset + 2] << 8 | b[offset + 3]) >>> 0;
+}
+
+// src/hooks/magic-context/todo-view.ts
+import { createHash as createHash8 } from "node:crypto";
+var TODO_STATUS_PENDING = "pending";
+var TODO_STATUS_IN_PROGRESS = "in_progress";
+var TODO_STATUS_COMPLETED = "completed";
+var TODO_STATUS_CANCELLED = "cancelled";
+var TODO_PRIORITY_HIGH = "high";
+var TODO_PRIORITY_MEDIUM = "medium";
+var TODO_PRIORITY_LOW = "low";
+var TODO_STATUSES = [
+  TODO_STATUS_PENDING,
+  TODO_STATUS_IN_PROGRESS,
+  TODO_STATUS_COMPLETED,
+  TODO_STATUS_CANCELLED
+];
+var TODO_PRIORITIES = [
+  TODO_PRIORITY_HIGH,
+  TODO_PRIORITY_MEDIUM,
+  TODO_PRIORITY_LOW
+];
+var TODO_STATUS_SET = new Set(TODO_STATUSES);
+var TODO_PRIORITY_SET = new Set(TODO_PRIORITIES);
+var TERMINAL_STATUSES = new Set([
+  TODO_STATUS_COMPLETED,
+  TODO_STATUS_CANCELLED
+]);
+var TITLE_DONE_STATUSES = new Set([TODO_STATUS_COMPLETED]);
+var SYNTHETIC_CALL_ID_PREFIX = "mc_synthetic_todo_";
+function normalizeTodoStateJson(todos) {
+  if (!Array.isArray(todos))
+    return null;
+  const normalized = [];
+  for (const todo of todos) {
+    if (!isTodoItem(todo))
+      return null;
+    normalized.push({
+      content: todo.content,
+      status: todo.status,
+      priority: todo.priority ?? TODO_PRIORITY_MEDIUM
+    });
+  }
+  return JSON.stringify(normalized);
+}
+function buildSyntheticTodoPart(stateJson) {
+  const todos = parseTodoState(stateJson);
+  if (todos === null || todos.length === 0)
+    return null;
+  if (todos.every((t) => TERMINAL_STATUSES.has(t.status)))
+    return null;
+  const callID = computeSyntheticCallId(stateJson);
+  const activeCount = todos.filter((t) => !TITLE_DONE_STATUSES.has(t.status)).length;
+  const output = JSON.stringify(todos, null, 2);
+  const ts = 0;
+  return {
+    type: "tool",
+    callID,
+    tool: "todowrite",
+    state: {
+      status: "completed",
+      input: { todos },
+      output,
+      title: `${activeCount} todos`,
+      metadata: { todos, truncated: false },
+      time: { start: ts, end: ts }
+    },
+    syntheticTodoMarker: true
+  };
+}
+function computeSyntheticCallId(stateJson) {
+  const hash = createHash8("sha256").update(stateJson).digest("hex").slice(0, 16);
+  return `${SYNTHETIC_CALL_ID_PREFIX}${hash}`;
+}
+function isSyntheticTodoPart(part) {
+  if (part === null || typeof part !== "object")
+    return false;
+  const p = part;
+  if (p.syntheticTodoMarker === true)
+    return true;
+  return p.type === "tool" && p.tool === "todowrite" && typeof p.callID === "string" && p.callID.startsWith(SYNTHETIC_CALL_ID_PREFIX);
+}
+function parseTodoState(stateJson) {
+  if (stateJson.length === 0)
+    return null;
+  try {
+    const parsed = JSON.parse(stateJson);
+    if (!Array.isArray(parsed))
+      return null;
+    const result = [];
+    for (const item of parsed) {
+      if (!isTodoItem(item))
+        return null;
+      result.push({
+        content: item.content,
+        status: item.status,
+        priority: item.priority ?? TODO_PRIORITY_MEDIUM
+      });
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function isTodoStatus(value) {
+  return typeof value === "string" && TODO_STATUS_SET.has(value);
+}
+function isTodoPriority(value) {
+  return typeof value === "string" && TODO_PRIORITY_SET.has(value);
+}
+function isTodoItem(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const todo = value;
+  return typeof todo.content === "string" && isTodoStatus(todo.status) && (todo.priority === undefined || isTodoPriority(todo.priority));
+}
+
+// src/hooks/magic-context/tail-hygiene-walk.ts
+var MAX_CONTENT_MEMO_ENTRIES = 1e5;
+var MAX_CONTENT_MEMO_BYTES = 64 * 1024 * 1024;
+var contentMemo = new Map;
+var contentMemoBytes = 0;
+var FNV1A_32_OFFSET = 2166136261;
+var FNV1A_32_PRIME = 16777619;
+var TAG_PREFIX = /^§\d+§\s*/;
+var DROP_PREFIXES = ["[dropped", "[truncated"];
+var CHANNEL1_REMINDER_OPEN = `
+
+<system-reminder>
+`;
+var CHANNEL1_REMINDER_CLOSE = `
+</system-reminder>`;
+var TODO_HEAD_ANCHOR_ID = "__magic_context_todo_head__";
+function fnv1a32(value) {
+  let hash = FNV1A_32_OFFSET;
+  for (let index = 0;index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, FNV1A_32_PRIME) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function memoizedContent(kind, content) {
+  const key = `${kind}\x00${content}`;
+  const cached = contentMemo.get(key);
+  if (cached)
+    return cached;
+  const measured = {
+    hash: fnv1a32(key),
+    tokens: kind === "excluded" ? 0 : estimateTokens(content),
+    keyBytes: key.length * 2 + 32
+  };
+  contentMemo.set(key, measured);
+  contentMemoBytes += measured.keyBytes;
+  while (contentMemo.size > MAX_CONTENT_MEMO_ENTRIES || contentMemoBytes > MAX_CONTENT_MEMO_BYTES) {
+    const oldest = contentMemo.keys().next().value;
+    if (typeof oldest !== "string")
+      break;
+    const removed = contentMemo.get(oldest);
+    if (removed)
+      contentMemoBytes -= removed.keyBytes;
+    contentMemo.delete(oldest);
+  }
+  return measured;
+}
+function safeStableStringify(value) {
+  if (value === undefined || value === null)
+    return "";
+  if (typeof value === "string")
+    return value;
+  try {
+    return stableStringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function firstString(record, fields) {
+  for (const field of fields) {
+    const value = record[field];
+    if (typeof value === "string")
+      return value;
+  }
+  return "";
+}
+function callIdFromPart(part) {
+  const direct = firstString(part, ["callID", "callId", "toolCallId", "tool_call_id", "id"]);
+  if (direct)
+    return direct;
+  const state2 = isRecord(part.state) ? part.state : null;
+  return state2 ? firstString(state2, ["callID", "callId", "toolCallId", "tool_call_id", "id"]) : "";
+}
+function toolResultCallId(part) {
+  return firstString(part, ["tool_use_id", "toolUseId", "callID", "callId"]);
+}
+function messageIdentity(message, messageIndex) {
+  return typeof message.info.id === "string" ? message.info.id : `ordinal:${messageIndex}:${message.info.role ?? "unknown"}`;
+}
+function collectToolPartIdentities(messages) {
+  const identities = new Map;
+  const pendingOwners = new Map;
+  for (let messageIndex = 0;messageIndex < messages.length; messageIndex += 1) {
+    const message = messages[messageIndex];
+    const currentOwner = messageIdentity(message, messageIndex);
+    for (const part of message.parts) {
+      if (!isRecord(part))
+        continue;
+      if (part.type === "tool-invocation" || part.type === "tool_use") {
+        const callId = callIdFromPart(part);
+        if (!callId)
+          continue;
+        const owners = pendingOwners.get(callId) ?? [];
+        owners.push(currentOwner);
+        pendingOwners.set(callId, owners);
+        identities.set(part, {
+          callId,
+          ownerMessageId: currentOwner,
+          messageIndex,
+          kind: "invocation"
+        });
+        continue;
+      }
+      if (part.type === "tool_result") {
+        const callId = toolResultCallId(part);
+        if (!callId)
+          continue;
+        const owners = pendingOwners.get(callId);
+        const ownerMessageId = owners?.shift() ?? currentOwner;
+        identities.set(part, {
+          callId,
+          ownerMessageId,
+          messageIndex,
+          kind: "result"
+        });
+        continue;
+      }
+      if (part.type === "tool") {
+        const callId = callIdFromPart(part);
+        if (!callId)
+          continue;
+        identities.set(part, {
+          callId,
+          ownerMessageId: currentOwner,
+          messageIndex,
+          kind: "native"
+        });
+      }
+    }
+  }
+  return identities;
+}
+function isSyntheticMessage(message) {
+  const structuralHead = message.info.id === undefined && message.info.role === "user" && message.parts.length > 0 && message.parts.every((part) => isRecord(part) && part.synthetic === true);
+  return structuralHead || message.info.summary === true || message.info.id === TODO_HEAD_ANCHOR_ID;
+}
+function isSyntheticPart(part) {
+  return isRecord(part) && part.synthetic === true || isSyntheticTodoPart(part);
+}
+function stripChannel1ReminderSpans(output) {
+  let stripped = output;
+  while (stripped.endsWith(CHANNEL1_REMINDER_CLOSE)) {
+    const opener = stripped.lastIndexOf(CHANNEL1_REMINDER_OPEN);
+    if (opener < 0)
+      break;
+    stripped = stripped.slice(0, opener);
+  }
+  return stripped;
+}
+function isDropSentinel(content) {
+  const stripped = content.trimStart().replace(TAG_PREFIX, "").trimStart().toLowerCase();
+  return DROP_PREFIXES.some((prefix) => stripped.startsWith(prefix));
+}
+function toolOutputText(part) {
+  if (part.type === "tool") {
+    const state2 = isRecord(part.state) ? part.state : null;
+    if (!state2)
+      return null;
+    if (state2.output !== undefined)
+      return safeStableStringify(state2.output);
+    if (state2.error !== undefined)
+      return safeStableStringify(state2.error);
+    if (state2.result !== undefined)
+      return safeStableStringify(state2.result);
+    return null;
+  }
+  if (part.type === "tool_result") {
+    const value = part.content ?? part.output ?? part.result;
+    return value === undefined ? null : safeStableStringify(value);
+  }
+  return null;
+}
+function toolInputText(part) {
+  if (part.type === "tool") {
+    const state2 = isRecord(part.state) ? part.state : null;
+    if (!state2 || state2.input === undefined)
+      return null;
+    return safeStableStringify(state2.input);
+  }
+  if (part.type === "tool-invocation") {
+    const value = part.args ?? part.input;
+    return value === undefined ? null : safeStableStringify(value);
+  }
+  if (part.type === "tool_use") {
+    return part.input === undefined ? null : safeStableStringify(part.input);
+  }
+  return null;
+}
+function messageIdForTag(tag) {
+  if (tag.type === "tool")
+    return tag.toolOwnerMessageId;
+  return tag.messageId.replace(/:(?:p|file)\d+$/, "");
+}
+function protectedTagNumbers(tags, protectedTags) {
+  const active = Array.from(new Set(tags.filter((tag) => tag.status === "active").map((tag) => tag.tagNumber))).sort((left, right) => right - left).slice(0, Math.max(0, protectedTags));
+  const protectedNumbers = new Set(active);
+  const protectedCtxReduceTags = newestCtxReduceTagNumbers(tags.filter((tag) => tag.status === "active" && tag.type === "tool"));
+  for (const tagNumber of protectedCtxReduceTags)
+    protectedNumbers.add(tagNumber);
+  return protectedNumbers;
+}
+function neighborhoodConsistent(args) {
+  let previousMax = null;
+  for (let index = 0;index <= args.messageIndex; index += 1) {
+    const bound = args.boundsByMessageIndex.get(index);
+    if (bound)
+      previousMax = previousMax === null ? bound.max : Math.max(previousMax, bound.max);
+  }
+  let nextMin = null;
+  for (let index = args.messageIndex + 1;index < args.messageCount; index += 1) {
+    const bound = args.boundsByMessageIndex.get(index);
+    if (bound)
+      nextMin = nextMin === null ? bound.min : Math.min(nextMin, bound.min);
+  }
+  if (previousMax === null || nextMin === null)
+    return false;
+  return args.orphanTagNumber >= previousMax && args.orphanTagNumber <= nextMin;
+}
+function buildTagAttribution(args) {
+  const protectedNumbers = protectedTagNumbers(args.tags, args.protectedTags);
+  const messageTags = new Map;
+  const exactToolTags = new Map;
+  const orphanTagsByCall = new Map;
+  const messageIndexById = new Map;
+  for (let index = 0;index < args.messages.length; index += 1) {
+    const id = args.messages[index].info.id;
+    if (typeof id === "string")
+      messageIndexById.set(id, index);
+  }
+  const boundsByMessageIndex = new Map;
+  for (const tag of args.tags) {
+    if (tag.type === "tool") {
+      if (tag.toolOwnerMessageId === null) {
+        const rows = orphanTagsByCall.get(tag.messageId) ?? [];
+        rows.push(tag);
+        orphanTagsByCall.set(tag.messageId, rows);
+      } else {
+        exactToolTags.set(`${tag.toolOwnerMessageId}\x00${tag.messageId}`, tag);
+      }
+    } else {
+      messageTags.set(tag.messageId, tag);
+    }
+    const ownerId = messageIdForTag(tag);
+    const index = ownerId === null ? undefined : messageIndexById.get(ownerId);
+    if (index === undefined)
+      continue;
+    const existing = boundsByMessageIndex.get(index);
+    boundsByMessageIndex.set(index, {
+      min: existing ? Math.min(existing.min, tag.tagNumber) : tag.tagNumber,
+      max: existing ? Math.max(existing.max, tag.tagNumber) : tag.tagNumber
+    });
+  }
+  const toolTagsByPart = new Map;
+  const orphanCandidateOwners = new Map;
+  for (const [part, identity] of args.toolIdentities) {
+    const exact = exactToolTags.get(`${identity.ownerMessageId}\x00${identity.callId}`);
+    if (exact) {
+      toolTagsByPart.set(part, exact);
+      continue;
+    }
+    const orphans = orphanTagsByCall.get(identity.callId);
+    if (orphans?.length !== 1)
+      continue;
+    if (!neighborhoodConsistent({
+      orphanTagNumber: orphans[0].tagNumber,
+      messageIndex: identity.messageIndex,
+      boundsByMessageIndex,
+      messageCount: args.messages.length
+    })) {
+      continue;
+    }
+    const byOwner = orphanCandidateOwners.get(identity.callId) ?? new Map;
+    const ownerParts = byOwner.get(identity.ownerMessageId) ?? [];
+    ownerParts.push(identity);
+    byOwner.set(identity.ownerMessageId, ownerParts);
+    orphanCandidateOwners.set(identity.callId, byOwner);
+  }
+  for (const [callId, byOwner] of orphanCandidateOwners) {
+    if (byOwner.size !== 1)
+      continue;
+    const orphan = orphanTagsByCall.get(callId)?.[0];
+    if (!orphan)
+      continue;
+    const ownerId = byOwner.keys().next().value;
+    if (typeof ownerId !== "string")
+      continue;
+    for (const [part, identity] of args.toolIdentities) {
+      if (identity.callId === callId && identity.ownerMessageId === ownerId) {
+        toolTagsByPart.set(part, orphan);
+      }
+    }
+  }
+  return { protectedNumbers, messageTags, toolTagsByPart };
+}
+function snapshot(args) {
+  const memo = memoizedContent(args.kind, args.content);
+  const tag = args.tag;
+  const isProtected = tag ? args.protectedNumbers.has(tag.tagNumber) : false;
+  const uTokens = tag?.status === "active" && !isProtected && args.kind !== "excluded" ? args.tokens : 0;
+  return {
+    key: args.key,
+    contentHash: memo.hash,
+    kind: args.kind,
+    tokens: args.tokens,
+    uTokens,
+    tagNumber: tag?.tagNumber ?? null,
+    tagStatus: tag?.status ?? null,
+    protected: isProtected
+  };
+}
+function excludedSnapshot(key, part) {
+  const content = safeStableStringify(part);
+  return snapshot({
+    key,
+    kind: "excluded",
+    content,
+    tokens: 0,
+    tag: undefined,
+    protectedNumbers: new Set
+  });
+}
+function fileContentAndTokens(part) {
+  const mime = typeof part.mime === "string" ? part.mime : "";
+  const type = typeof part.type === "string" ? part.type.toLowerCase() : "";
+  const url = typeof part.url === "string" ? part.url : "";
+  if (mime.startsWith("image/") || type.includes("image")) {
+    return {
+      content: url,
+      tokens: url.startsWith("data:") ? estimateImageTokensFromDataUrl(url) : 1200
+    };
+  }
+  const content = firstString(part, ["content", "text", "source", "url"]);
+  const memo = memoizedContent("file", content);
+  return { content, tokens: memo.tokens };
+}
+function contentSignature(parts) {
+  return fnv1a32(parts.map((part) => `${part.key}:${part.contentHash}`).join("\x00"));
+}
+function tailHygieneStructuralSignature(messages) {
+  const partCounts = [];
+  let totalBytes = 0;
+  for (const message of messages) {
+    partCounts.push(message.parts.length);
+    totalBytes += byteSize(JSON.stringify(message) ?? "");
+  }
+  return { messageCount: messages.length, partCounts, totalBytes };
+}
+function sameTailHygieneStructuralSignature(expected, actual) {
+  if (expected.messageCount !== actual.messageCount || expected.totalBytes !== actual.totalBytes || expected.partCounts.length !== actual.partCounts.length) {
+    return false;
+  }
+  return expected.partCounts.every((count, index) => count === actual.partCounts[index]);
+}
+function measureTailHygiene(input) {
+  const toolIdentities = collectToolPartIdentities(input.messages);
+  const attribution = buildTagAttribution({
+    messages: input.messages,
+    tags: input.tags,
+    toolIdentities,
+    protectedTags: input.protectedTags
+  });
+  const droppedToolOwners = new Set;
+  for (const [part, identity] of toolIdentities) {
+    if (!isRecord(part))
+      continue;
+    const output = toolOutputText(part);
+    if (output !== null && isDropSentinel(output)) {
+      droppedToolOwners.add(`${identity.ownerMessageId}\x00${identity.callId}`);
+    }
+  }
+  const parts = [];
+  let t = 0;
+  let u = 0;
+  for (let messageIndex = 0;messageIndex < input.messages.length; messageIndex += 1) {
+    const message = input.messages[messageIndex];
+    const messageKey = messageIdentity(message, messageIndex);
+    const messageSynthetic = isSyntheticMessage(message);
+    for (let partIndex = 0;partIndex < message.parts.length; partIndex += 1) {
+      const part = message.parts[partIndex];
+      const key = `${messageKey}\x00${partIndex}`;
+      if (messageSynthetic || isSyntheticPart(part) || !isRecord(part)) {
+        parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+        continue;
+      }
+      const type = typeof part.type === "string" ? part.type : "";
+      if (type === "reasoning" || type === "thinking" || type === "redacted_thinking" || type === "signature") {
+        parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+        continue;
+      }
+      if (type === "text") {
+        const content = firstString(part, ["text", "content"]);
+        if (!content || isDropSentinel(content)) {
+          parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+          continue;
+        }
+        const memo = memoizedContent("text", content);
+        const tag = attribution.messageTags.get(`${message.info.id}:p${partIndex}`);
+        const measured = snapshot({
+          key: `${key}\x00text`,
+          kind: "text",
+          content,
+          tokens: memo.tokens,
+          tag,
+          protectedNumbers: attribution.protectedNumbers
+        });
+        parts.push(measured);
+        t += measured.tokens;
+        u += measured.uTokens;
+        continue;
+      }
+      if (type === "file" || type.includes("image") || type === "source") {
+        const file = fileContentAndTokens(part);
+        if (!file.content || isDropSentinel(file.content)) {
+          parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+          continue;
+        }
+        const tag = attribution.messageTags.get(`${message.info.id}:file${partIndex}`);
+        const measured = snapshot({
+          key: `${key}\x00file`,
+          kind: "file",
+          content: file.content,
+          tokens: file.tokens,
+          tag,
+          protectedNumbers: attribution.protectedNumbers
+        });
+        parts.push(measured);
+        t += measured.tokens;
+        u += measured.uTokens;
+        continue;
+      }
+      const toolIdentity = toolIdentities.get(part);
+      if (toolIdentity) {
+        const ownerKey = `${toolIdentity.ownerMessageId}\x00${toolIdentity.callId}`;
+        if (droppedToolOwners.has(ownerKey)) {
+          parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+          continue;
+        }
+        const tag = attribution.toolTagsByPart.get(part);
+        const inputText = toolInputText(part);
+        if (inputText !== null) {
+          const memo = memoizedContent("toolInput", inputText);
+          const measured = snapshot({
+            key: `${key}\x00toolInput`,
+            kind: "toolInput",
+            content: inputText,
+            tokens: memo.tokens,
+            tag,
+            protectedNumbers: attribution.protectedNumbers
+          });
+          parts.push(measured);
+          t += measured.tokens;
+          u += measured.uTokens;
+        }
+        const rawOutput = toolOutputText(part);
+        if (rawOutput !== null) {
+          const output = stripChannel1ReminderSpans(rawOutput);
+          if (isDropSentinel(output)) {
+            parts.push(excludedSnapshot(`${key}\x00excludedOutput`, output));
+          } else {
+            const memo = memoizedContent("toolOutput", output);
+            const measured = snapshot({
+              key: `${key}\x00toolOutput`,
+              kind: "toolOutput",
+              content: output,
+              tokens: memo.tokens,
+              tag,
+              protectedNumbers: attribution.protectedNumbers
+            });
+            parts.push(measured);
+            t += measured.tokens;
+            u += measured.uTokens;
+          }
+        }
+        if (inputText === null && rawOutput === null) {
+          parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+        }
+        continue;
+      }
+      parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+    }
+  }
+  return {
+    u: Math.min(Math.max(0, u), Math.max(0, t)),
+    t: Math.max(0, t),
+    contentSignature: contentSignature(parts),
+    parts
+  };
+}
+function sameMeasuredPrefix(baseline, current) {
+  if (current.length < baseline.length)
+    return { valid: false, boundaryAdvanceU: 0 };
+  let boundaryAdvanceU = 0;
+  for (let index = 0;index < baseline.length; index += 1) {
+    const before = baseline[index];
+    const after = current[index];
+    if (before.key !== after.key || before.contentHash !== after.contentHash || before.kind !== after.kind || before.tokens !== after.tokens || before.tagNumber !== after.tagNumber || before.tagStatus !== after.tagStatus) {
+      return { valid: false, boundaryAdvanceU: 0 };
+    }
+    if (!before.protected && after.protected)
+      return { valid: false, boundaryAdvanceU: 0 };
+    if (before.protected && !after.protected) {
+      if (after.tagStatus !== "active")
+        return { valid: false, boundaryAdvanceU: 0 };
+      boundaryAdvanceU += after.tokens;
+    } else if (before.uTokens !== after.uTokens) {
+      return { valid: false, boundaryAdvanceU: 0 };
+    }
+  }
+  return { valid: true, boundaryAdvanceU };
+}
+function refreshTailHygieneBaseline(input) {
+  const measured = measureTailHygiene(input);
+  const now = input.now ?? Date.now();
+  if (!input.cacheBusting && input.previous?.generationInvalidated) {
+    return { ...input.previous, contentSignature: measured.contentSignature };
+  }
+  if (input.cacheBusting || !input.previous) {
+    return {
+      baselineU: measured.u,
+      baselineT: measured.t,
+      turnDeltaU: 0,
+      turnDeltaT: 0,
+      baselineGeneration: (input.previous?.baselineGeneration ?? 0) + 1,
+      computedAt: now,
+      evaluable: true,
+      generationInvalidated: false,
+      baselineParts: measured.parts,
+      contentSignature: measured.contentSignature
+    };
+  }
+  const prefix = sameMeasuredPrefix(input.previous.baselineParts, measured.parts);
+  if (!prefix.valid) {
+    return {
+      ...input.previous,
+      evaluable: false,
+      generationInvalidated: true,
+      contentSignature: measured.contentSignature
+    };
+  }
+  let turnDeltaT = 0;
+  let turnDeltaU = prefix.boundaryAdvanceU;
+  for (let index = input.previous.baselineParts.length;index < measured.parts.length; index += 1) {
+    const part = measured.parts[index];
+    turnDeltaT += part.tokens;
+    if (part.kind !== "toolOutput")
+      turnDeltaU += part.uTokens;
+  }
+  return {
+    ...input.previous,
+    turnDeltaU,
+    turnDeltaT,
+    evaluable: true,
+    generationInvalidated: false,
+    contentSignature: measured.contentSignature
+  };
+}
+function effectiveTailHygiene(baseline) {
+  const t = Math.max(0, baseline.baselineT + baseline.turnDeltaT);
+  const u = Math.min(t, Math.max(0, baseline.baselineU + baseline.turnDeltaU));
+  return { u, t };
+}
+function assertTailHygieneContentUnchanged(input) {
+  const actual = measureTailHygiene(input).contentSignature;
+  if (actual !== input.expectedSignature) {
+    throw new Error(`tail hygiene walk was not the last byte-affecting operation: expected ${input.expectedSignature}, got ${actual}`);
+  }
+}
+
+// src/hooks/magic-context/ctx-reduce-nudge.ts
+var CHANNEL1_SENTINEL = "<system-reminder>";
+var TOKENS_PER_BYTE = 0.25;
+var CHANNEL1_MIN_TOKENS = 60000;
+var CHANNEL1_FLOOR_TOKENS = 25000;
+var CHANNEL1_REFIRE_FLOOR_TOKENS = 25000;
+var S_GENTLE = 0.2;
+var S_FIRM = 0.4;
+var S_URGENT = 0.6;
+var LEVEL_RANK = { gentle: 1, firm: 2, urgent: 3 };
+function channel1RefireTokens(tailTokens) {
+  const scaled = Math.round(0.08 * Math.max(0, tailTokens));
+  return Math.max(CHANNEL1_REFIRE_FLOOR_TOKENS, scaled);
+}
+function toolOutputTokens(output) {
+  return estimateTokens(stripChannel1ReminderSpans(output));
+}
+function decideChannel1(input) {
+  const tailTokens = Math.max(0, input.baselineT + input.turnDeltaT);
+  const undroppedTokens = Math.min(tailTokens, Math.max(0, input.baselineU + input.turnDeltaU));
+  const severity = Math.min(1, Math.max(0, undroppedTokens / Math.max(tailTokens, 1)));
+  const resetCycle = input.hasRecentReduce || undroppedTokens < input.lastNudgeUndropped;
+  const lastNudge = resetCycle ? 0 : input.lastNudgeUndropped;
+  const lastLevel = resetCycle ? "" : input.lastNudgeLevel;
+  const quiet = () => ({
+    fire: false,
+    level: "gentle",
+    undroppedTokens,
+    tailTokens,
+    severity,
+    nextLastNudge: lastNudge,
+    nextLastNudgeLevel: lastLevel
+  });
+  if (input.evaluable === false || input.generationInvalidated === true)
+    return quiet();
+  if (input.hasRecentReduce)
+    return quiet();
+  if (tailTokens < CHANNEL1_MIN_TOKENS)
+    return quiet();
+  if (undroppedTokens < CHANNEL1_FLOOR_TOKENS || undroppedTokens === 0)
+    return quiet();
+  if (severity < S_GENTLE)
+    return quiet();
+  let level;
+  if (severity >= S_URGENT)
+    level = "urgent";
+  else if (severity >= S_FIRM)
+    level = "firm";
+  else
+    level = "gentle";
+  const escalated = lastLevel === "" || LEVEL_RANK[level] > LEVEL_RANK[lastLevel];
+  const cadenceReached = lastLevel !== "" && undroppedTokens - lastNudge >= channel1RefireTokens(tailTokens);
+  if (!escalated && !cadenceReached)
+    return quiet();
+  return {
+    fire: true,
+    level,
+    undroppedTokens,
+    tailTokens,
+    severity,
+    nextLastNudge: undroppedTokens,
+    nextLastNudgeLevel: level
+  };
+}
+var CHANNEL2_SEVERITY_THRESHOLD = 0.75;
+var CHANNEL2_FLOOR_TOKENS = 50000;
+function evaluateChannel2(input) {
+  const values = input ? [input.baselineU, input.baselineT, input.turnDeltaU, input.turnDeltaT] : [];
+  if (input?.evaluable !== true || input.generationInvalidated === true || values.some((value) => !Number.isFinite(value))) {
+    return {
+      evaluable: false,
+      shouldTrigger: false,
+      reclaimableTokens: 0,
+      tailTokens: 0,
+      severity: 0
+    };
+  }
+  const tailTokens = Math.max(0, input.baselineT + input.turnDeltaT);
+  const reclaimableTokens = Math.min(tailTokens, Math.max(0, input.baselineU + input.turnDeltaU));
+  const severity = Math.min(1, Math.max(0, reclaimableTokens / Math.max(tailTokens, 1)));
+  return {
+    evaluable: true,
+    shouldTrigger: tailTokens >= CHANNEL1_MIN_TOKENS && reclaimableTokens >= CHANNEL2_FLOOR_TOKENS && severity >= CHANNEL2_SEVERITY_THRESHOLD,
+    reclaimableTokens,
+    tailTokens,
+    severity
+  };
+}
+function approxThousands(tokens) {
+  return `${Math.round(tokens / 1000)}k`;
+}
+function formatOldestReclaimableHint(hint) {
+  if (!hint || hint.length === 0)
+    return "";
+  const rendered = hint.slice(0, 4).map((tag) => `§${tag.tagNumber}§ ${tag.toolName ?? "tool"}`).join(" · ");
+  return rendered.length > 0 ? `
+oldest reclaimable: ${rendered}.` : "";
+}
+function buildChannel2Reminder(undroppedTokens, hint) {
+  const amount = approxThousands(undroppedTokens);
+  const hintText = formatOldestReclaimableHint(hint);
+  return `<system-reminder>
+` + `Routine context housekeeping is near: a large span of this session will be comparted soon, ` + `and ~${amount} tokens of tool output remain unreduced. Drop spent outputs with ctx_reduce ` + `first so the archived span is the part that matters.${hintText}
+` + `</system-reminder>`;
+}
+function buildChannel1Reminder(level, undroppedTokens, hint) {
+  const amount = approxThousands(undroppedTokens);
+  const hintText = formatOldestReclaimableHint(hint);
+  let body;
+  switch (level) {
+    case "gentle":
+      body = `You have ~${amount} tokens of content you have not reduced. ` + `When you are done with earlier outputs, dropping them with ctx_reduce keeps context lean.`;
+      break;
+    case "firm":
+      body = `~${amount} tokens of unreduced content has built up. ` + `At your next natural stopping point, consider dropping what you have already processed with ctx_reduce.`;
+      break;
+    case "urgent":
+      body = `~${amount} tokens of unreduced content remain across most of the live tail. ` + `Consider dropping spent outputs with ctx_reduce so the archived span is the part that matters.`;
+      break;
+  }
+  return `
+
+<system-reminder>
+${body}${hintText}
+</system-reminder>`;
+}
+
+// src/hooks/magic-context/emergency-drop.ts
+var TARGET_FRACTION = 0.3;
+var TIER_RECENCY_RESERVE = 0.2;
+var EMERGENCY_REARM_MIN_TOKENS = 2000;
+var T1_TOOLS = new Set(["read", "todowrite", "task", "aft_outline", "aft_zoom"]);
+var T2_TOOLS = new Set(["edit", "write", "apply_patch", "grep", "glob", "aft_search"]);
+function normalizeToolName(toolName) {
+  if (!toolName)
+    return "";
+  let name = toolName.toLowerCase();
+  if (name.startsWith("mcp_"))
+    name = name.slice(4);
+  return name;
+}
+function resolveToolTier(toolName) {
+  const name = normalizeToolName(toolName);
+  if (T1_TOOLS.has(name))
+    return 1;
+  if (T2_TOOLS.has(name))
+    return 2;
+  return 3;
+}
+function tagReclaimBytes(tag) {
+  return tag.byteSize + tag.inputByteSize + tag.reasoningByteSize;
+}
+function estimateEmergencyDropReclaimTokens(tag) {
+  return Math.round(tagReclaimBytes(tag) * TOKENS_PER_BYTE);
+}
+function planEmergencyDrop(input) {
+  const {
+    tags,
+    floorTags,
+    maxTag,
+    protectedTags,
+    currentTotalInputTokens,
+    ceilingTokens,
+    priorInputSample,
+    hasPriorDrop
+  } = input;
+  const noop = (reason) => ({
+    shouldDrop: false,
+    tagNumbers: [],
+    reclaimTokens: 0,
+    reason
+  });
+  if (!Number.isFinite(ceilingTokens) || ceilingTokens <= 0) {
+    return noop("unknown-ceiling");
+  }
+  if (!Number.isFinite(currentTotalInputTokens) || currentTotalInputTokens <= 0) {
+    return noop("unknown-usage");
+  }
+  if (hasPriorDrop && currentTotalInputTokens === priorInputSample) {
+    return noop("same-input-sample (awaiting fresh usage after prior drop)");
+  }
+  let tailTokens = 0;
+  for (const tag of floorTags) {
+    if (tag.status !== "active")
+      continue;
+    tailTokens += estimateEmergencyDropReclaimTokens(tag);
+  }
+  const fixedFloor = Math.max(currentTotalInputTokens - tailTokens, 0);
+  const workingSpan = Math.max(ceilingTokens - fixedFloor, 0);
+  const target = fixedFloor + TARGET_FRACTION * workingSpan;
+  const reclaimTokens = Math.round(currentTotalInputTokens - target);
+  if (reclaimTokens <= EMERGENCY_REARM_MIN_TOKENS) {
+    return noop(`reclaim<=min (${reclaimTokens} <= ${EMERGENCY_REARM_MIN_TOKENS})`);
+  }
+  const protectedCutoff = maxTag - protectedTags;
+  const tierActive = { 1: [], 2: [] };
+  for (const tag of tags) {
+    if (tag.status !== "active" || tag.type !== "tool")
+      continue;
+    const tier = resolveToolTier(tag.toolName);
+    if (tier === 1 || tier === 2)
+      tierActive[tier].push(tag.tagNumber);
+  }
+  const reserved = new Set;
+  for (const tier of [1, 2]) {
+    const nums = tierActive[tier];
+    if (nums.length === 0)
+      continue;
+    nums.sort((a, b) => b - a);
+    const reserveCount = Math.ceil(TIER_RECENCY_RESERVE * nums.length);
+    for (let i = 0;i < reserveCount && i < nums.length; i++) {
+      reserved.add(nums[i]);
+    }
+  }
+  const protectedCtxReduceTags = newestCtxReduceTagNumbers(floorTags.filter((tag) => tag.status === "active" && tag.type === "tool"));
+  const byTier = { 1: [], 2: [], 3: [] };
+  for (const tag of tags) {
+    if (tag.status !== "active" || tag.type !== "tool")
+      continue;
+    if (tag.tagNumber > protectedCutoff)
+      continue;
+    if (protectedCtxReduceTags.has(tag.tagNumber))
+      continue;
+    const tier = resolveToolTier(tag.toolName);
+    if ((tier === 1 || tier === 2) && reserved.has(tag.tagNumber))
+      continue;
+    byTier[tier].push(tag);
+  }
+  const selected = [];
+  let reclaimed = 0;
+  outer:
+    for (const tier of [3, 2, 1]) {
+      const group = byTier[tier];
+      group.sort((a, b) => a.tagNumber - b.tagNumber);
+      for (const tag of group) {
+        selected.push(tag.tagNumber);
+        reclaimed += estimateEmergencyDropReclaimTokens(tag);
+        if (reclaimed >= reclaimTokens)
+          break outer;
+      }
+    }
+  if (selected.length === 0) {
+    return noop("no-candidates");
+  }
+  return {
+    shouldDrop: true,
+    tagNumbers: selected,
+    reclaimTokens,
+    reason: `tiered drop: ${selected.length} tags, reclaim≈${reclaimed}/${reclaimTokens} tokens (floor≈${fixedFloor}, ceiling=${Math.round(ceilingTokens)})`
+  };
+}
+
 // src/features/magic-context/storage-tags.ts
 var insertTagStatements = new WeakMap;
 var updateTagStatusStatements = new WeakMap;
@@ -9069,32 +10658,23 @@ function ownerMessageIdForTagRow(row) {
   }
   return row.message_id.replace(CONTENT_ID_SUFFIX, "");
 }
-function getActiveTagTokenAggregate(db, sessionId, protectedTags = 0) {
-  const toolOutputExpr = protectedTags > 0 ? `COALESCE(SUM(CASE WHEN type = 'tool' AND tag_number < (
-                    SELECT tag_number FROM tags
-                    WHERE session_id = ? AND status = 'active'
-                    ORDER BY tag_number DESC LIMIT 1 OFFSET ?
-                ) THEN COALESCE(token_count, 0) ELSE 0 END), 0)` : `COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0)`;
-  const sql = `SELECT
-                COALESCE(SUM(CASE WHEN type != 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0)
-                    + COALESCE(SUM(COALESCE(reasoning_token_count, 0)), 0) AS conversation,
-                COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) + COALESCE(input_token_count, 0) ELSE 0 END), 0) AS tool_call,
-                ${toolOutputExpr} AS tool_output,
-                COALESCE(SUM(CASE WHEN token_count IS NULL THEN 1 ELSE 0 END), 0) AS null_count
-             FROM tags
-             WHERE session_id = ? AND status = 'active'`;
-  const params = protectedTags > 0 ? [sessionId, protectedTags - 1, sessionId] : [sessionId];
-  const row = db.prepare(sql).get(...params);
-  return {
-    conversation: row?.conversation ?? 0,
-    toolCall: row?.tool_call ?? 0,
-    toolOutput: row?.tool_output ?? 0,
-    nullCount: row?.null_count ?? 0
-  };
-}
-var RECLAIM_HINT_EXCLUDED_TOOLS = ["todowrite"];
+var RECLAIM_HINT_EXCLUDED_TOOLS = new Set([
+  "ask",
+  "bash_kill",
+  "bash_status",
+  "board",
+  "task",
+  "todoread",
+  "todowrite",
+  "work"
+]);
 var AGE_RECLAIM_MIN_TOKENS = 250;
-var RECLAIM_HINT_EXCLUDED_LIST = RECLAIM_HINT_EXCLUDED_TOOLS.map((name) => `'${name.replace(/'/g, "''")}'`).join(", ");
+function isReclaimHintExcludedTool(toolName) {
+  if (!toolName)
+    return false;
+  const normalized = toolName.toLowerCase().replace(/^mcp_/, "");
+  return normalized.startsWith("ctx_") || RECLAIM_HINT_EXCLUDED_TOOLS.has(normalized);
+}
 function getOldestActiveUnprotectedToolTags(db, sessionId, protectedTags = 0, limit = 4) {
   if (limit <= 0)
     return [];
@@ -9104,24 +10684,21 @@ function getOldestActiveUnprotectedToolTags(db, sessionId, protectedTags = 0, li
                     WHERE session_id = ? AND status = 'active'
                     ORDER BY tag_number DESC LIMIT 1 OFFSET ?
                 )` : "";
-  const excludeStateTools = RECLAIM_HINT_EXCLUDED_LIST ? `AND (tool_name IS NULL OR tool_name NOT IN (${RECLAIM_HINT_EXCLUDED_LIST}))` : "";
   const valueFloor = `AND (
             (token_count IS NULL AND input_token_count IS NULL)
             OR (COALESCE(token_count, 0) + COALESCE(input_token_count, 0)) >= ?
         )`;
-  const params = protectedTags > 0 ? [sessionId, AGE_RECLAIM_MIN_TOKENS, sessionId, protectedTags - 1, boundedLimit] : [sessionId, AGE_RECLAIM_MIN_TOKENS, boundedLimit];
+  const params = protectedTags > 0 ? [sessionId, AGE_RECLAIM_MIN_TOKENS, sessionId, protectedTags - 1] : [sessionId, AGE_RECLAIM_MIN_TOKENS];
   const rows = db.prepare(`SELECT tag_number, tool_name
              FROM tags
              WHERE session_id = ? AND status = 'active' AND type = 'tool'
-             ${excludeStateTools}
              ${valueFloor}
              ${whereProtected}
-             ORDER BY tag_number ASC, id ASC
-             LIMIT ?`).all(...params);
+             ORDER BY tag_number ASC, id ASC`).all(...params);
   return rows.filter((row) => typeof row.tag_number === "number").map((row) => ({
     tagNumber: row.tag_number,
     toolName: typeof row.tool_name === "string" ? row.tool_name : null
-  }));
+  })).filter((tag) => !isReclaimHintExcludedTool(tag.toolName)).sort((left, right) => resolveToolTier(right.toolName) - resolveToolTier(left.toolName) || left.tagNumber - right.tagNumber).slice(0, boundedLimit);
 }
 var getActiveToolTagsForAgeReclaimStatements = new WeakMap;
 function getActiveToolTagsForAgeReclaim(db, sessionId) {
@@ -9134,7 +10711,7 @@ function getActiveToolTagsForAgeReclaim(db, sessionId) {
     getActiveToolTagsForAgeReclaimStatements.set(db, stmt);
   }
   const rows = stmt.all(sessionId);
-  return rows.filter((row) => typeof row.tag_number === "number").map((row) => {
+  const tags = rows.filter((row) => typeof row.tag_number === "number").map((row) => {
     const outputTokens = typeof row.token_count === "number" ? row.token_count : null;
     const inputTokens = typeof row.input_token_count === "number" ? row.input_token_count : null;
     return {
@@ -9143,6 +10720,8 @@ function getActiveToolTagsForAgeReclaim(db, sessionId) {
       reclaimableTokens: outputTokens === null && inputTokens === null ? null : (outputTokens ?? 0) + (inputTokens ?? 0)
     };
   });
+  const protectedCtxReduceTags = newestCtxReduceTagNumbers(tags);
+  return tags.filter((tag) => !protectedCtxReduceTags.has(tag.tagNumber));
 }
 function getTriggerTagTokenUpperBound(db, sessionId, floor = 0) {
   const sql = floor > 0 ? `SELECT
@@ -9297,8 +10876,8 @@ function isMaxTagNumberRow(row) {
 function escapeLikePattern(value) {
   return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
 }
-function insertTag(db, sessionId, messageId, type, byteSize, tagNumber, reasoningByteSize = 0, toolName = null, inputByteSize = 0, toolOwnerMessageId = null, entryFingerprint = null, tokenCounts = null) {
-  getInsertTagStatement(db).run(sessionId, messageId, type, byteSize, reasoningByteSize, tagNumber, toolName, inputByteSize, getHarness(), toolOwnerMessageId, entryFingerprint, tokenCounts?.tokenCount ?? null, tokenCounts?.inputTokenCount ?? null, tokenCounts?.reasoningTokenCount ?? null);
+function insertTag(db, sessionId, messageId, type, byteSize2, tagNumber, reasoningByteSize = 0, toolName = null, inputByteSize = 0, toolOwnerMessageId = null, entryFingerprint = null, tokenCounts = null) {
+  getInsertTagStatement(db).run(sessionId, messageId, type, byteSize2, reasoningByteSize, tagNumber, toolName, inputByteSize, getHarness(), toolOwnerMessageId, entryFingerprint, tokenCounts?.tokenCount ?? null, tokenCounts?.inputTokenCount ?? null, tokenCounts?.reasoningTokenCount ?? null);
   return tagNumber;
 }
 function updateTagStatus(db, sessionId, tagId, status) {
@@ -9403,6 +10982,7 @@ function getTagsBySession(db, sessionId) {
   return rows.map(toTagEntry);
 }
 var getActiveTagsBySessionStatements = new WeakMap;
+var getNullOwnerToolTagsBySessionStatements = new WeakMap;
 var getDroppedTagsBySessionStatements = new WeakMap;
 var getMaxDroppedTagNumberStatements = new WeakMap;
 function getActiveTagsBySessionStatement(db) {
@@ -9433,6 +11013,24 @@ function getActiveTagsBySession(db, sessionId) {
   const rows = getActiveTagsBySessionStatement(db).all(sessionId).filter(isTagRow);
   return rows.map(toTagEntry);
 }
+function getTailHygieneTags(db, sessionId) {
+  const active = getActiveTagsBySession(db, sessionId);
+  let orphanStatement = getNullOwnerToolTagsBySessionStatements.get(db);
+  if (!orphanStatement) {
+    orphanStatement = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags
+             WHERE session_id = ? AND type = 'tool' AND tool_owner_message_id IS NULL
+             ORDER BY tag_number ASC, id ASC`);
+    getNullOwnerToolTagsBySessionStatements.set(db, orphanStatement);
+  }
+  const seen = new Set(active.map((tag) => `${tag.tagNumber}\x00${tag.messageId}\x00${tag.type}`));
+  for (const row of orphanStatement.all(sessionId).filter(isTagRow)) {
+    const orphan = toTagEntry(row);
+    const key = `${orphan.tagNumber}\x00${orphan.messageId}\x00${orphan.type}`;
+    if (!seen.has(key))
+      active.push(orphan);
+  }
+  return active;
+}
 function getDroppedTagsBySession(db, sessionId) {
   const rows = getDroppedTagsBySessionStatement(db).all(sessionId).filter(isTagRow);
   return rows.map(toTagEntry);
@@ -9651,7 +11249,7 @@ var LIMIT_EXTRACTION_PATTERNS = [
     pattern: /too large for model with (\d+) maximum context length/i,
     provenance: "combined"
   },
-  { pattern: /context size.*(\d+) tokens?/i, provenance: "combined" },
+  { pattern: /context size[^0-9]{0,40}(\d{4,})\s*tokens?/i, provenance: "combined" },
   { pattern: /exceeds? the context length of (\d+)/i, provenance: "combined" },
   {
     pattern: />\s*(\d+)\s*(?:tokens?\s*)?(?:maximum|max|limit)\b/i,
@@ -9823,7 +11421,7 @@ async function abortChildRun(client, sessionId) {
   try {
     await Promise.race([
       client.session.abort({ path: { id: sessionId } }),
-      new Promise((resolve) => setTimeout(resolve, ABORT_CALL_TIMEOUT_MS))
+      new Promise((resolve2) => setTimeout(resolve2, ABORT_CALL_TIMEOUT_MS))
     ]);
   } catch (error) {
     log(`[model-retry] child session abort failed for ${sessionId}: ${String(error)}`);
@@ -10052,16 +11650,25 @@ function modelKeyLookupOrder(modelKey) {
     return [];
   const provider = modelKey.slice(0, slash);
   let modelID = modelKey.slice(slash + 1);
+  const providerRefs = modelRefLookupOrder(`${provider}/${modelID}`);
   const candidates = [];
   while (modelID.length > 0) {
-    candidates.push({ key: `${provider}/${modelID}`, source: "exact" });
+    for (const providerRef of providerRefs) {
+      const providerSlash = providerRef.indexOf("/");
+      const providerPrefix = providerRef.slice(0, providerSlash);
+      candidates.push({ key: `${providerPrefix}/${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" });
+  for (const providerRef of providerRefs) {
+    const providerSlash = providerRef.indexOf("/");
+    const providerPrefix = providerRef.slice(0, providerSlash);
+    candidates.push({ key: `${providerPrefix}/*`, source: "wildcard" });
+  }
   const seen = new Set;
   return candidates.filter((candidate) => {
     if (seen.has(candidate.key))
@@ -10094,7 +11701,7 @@ function resolveModelConfigOrDefault(values, modelKey, 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";
+import { dirname as dirname3, isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
 
 // src/config/migrate-config-location.ts
 import {
@@ -10505,7 +12112,7 @@ function promptSurfaceHashMaterial(systemContent, preset = "full") {
 var PROMPT_SURFACE_TOOL_ID_SET = new Set(ACTIVE_TOOL_IDS);
 function resolveUserConfigDirectory(options) {
   if (options.userConfigDirectory)
-    return resolve(options.userConfigDirectory);
+    return resolve2(options.userConfigDirectory);
   const sharedBase = cortexKitUserConfigBasePath();
   const shared = detectConfigFile(sharedBase);
   if (shared.format !== "none")
@@ -10532,7 +12139,7 @@ function createPromptSurfaceRuntime(options) {
   const readGuidanceOverride = (configuredPath) => {
     if (!configuredPath)
       return;
-    const path3 = isAbsolute2(configuredPath) ? configuredPath : resolve(userConfigDirectory, configuredPath);
+    const path3 = isAbsolute2(configuredPath) ? configuredPath : resolve2(userConfigDirectory, configuredPath);
     let content;
     try {
       if (!statSync5(path3).isFile()) {
@@ -10592,12 +12199,13 @@ function createPromptSurfaceGuidanceEpochCache(runtime) {
   const epochs = new Map;
   return {
     resolve(sessionId, config, modelKey) {
+      const canonicalModelKey = modelKey ? piModelRefToCanonical(modelKey) : undefined;
       const cached = epochs.get(sessionId);
-      if (cached && cached.config === config && cached.modelKey === modelKey) {
+      if (cached && cached.config === config && cached.modelKey === canonicalModelKey) {
         return cached.selection;
       }
-      const selection = runtime.resolveGuidance(config, modelKey);
-      epochs.set(sessionId, { config, modelKey, selection });
+      const selection = runtime.resolveGuidance(config, canonicalModelKey);
+      epochs.set(sessionId, { config, modelKey: canonicalModelKey, selection });
       return selection;
     },
     clear(sessionId) {
@@ -10703,13 +12311,44 @@ function pruneExpiredUserMemoryCandidates(db, ttlMs, now = Date.now()) {
   const result = db.prepare("DELETE FROM user_memory_candidates WHERE created_at < ?").run(cutoff);
   return Number(result.changes ?? 0);
 }
+function loadUserMemorySourceProvenance(db, candidateIds) {
+  const ids = [...new Set(candidateIds)].sort((a, b) => a - b);
+  if (ids.length === 0)
+    return [];
+  const placeholders3 = ids.map(() => "?").join(",");
+  const rows = db.prepare(`SELECT id, session_id, source_compartment_start, source_compartment_end
+               FROM user_memory_candidates
+              WHERE id IN (${placeholders3})
+              ORDER BY id ASC`).all(...ids);
+  return rows.map((row) => ({
+    candidateId: row.id,
+    sessionId: row.session_id,
+    sourceCompartmentStart: row.source_compartment_start,
+    sourceCompartmentEnd: row.source_compartment_end
+  }));
+}
+function serializeUserMemorySourceProvenance(provenance, sourceCandidateIds) {
+  if (provenance.length === 0 && sourceCandidateIds.length > 0)
+    return null;
+  return JSON.stringify(provenance.map((source) => ({
+    candidate_id: source.candidateId,
+    session_id: source.sessionId,
+    source_compartment_start: source.sourceCompartmentStart,
+    source_compartment_end: source.sourceCompartmentEnd
+  })));
+}
 function insertUserMemory(db, content, sourceCandidateIds) {
-  const now = Date.now();
-  const result = db.prepare("INSERT INTO user_memories (content, status, promoted_at, source_candidate_ids, created_at, updated_at) VALUES (?, 'active', ?, ?, ?, ?)").run(content, now, JSON.stringify(sourceCandidateIds), now, now);
-  return Number(result.lastInsertRowid);
+  return db.transaction(() => {
+    const now = Date.now();
+    const sourceProvenance = loadUserMemorySourceProvenance(db, sourceCandidateIds);
+    const result = db.prepare(`INSERT INTO user_memories
+                    (content, status, promoted_at, source_candidate_ids, source_candidate_provenance, created_at, updated_at)
+                 VALUES (?, 'active', ?, ?, ?, ?, ?)`).run(content, now, JSON.stringify(sourceCandidateIds), serializeUserMemorySourceProvenance(sourceProvenance, sourceCandidateIds), now, now);
+    return Number(result.lastInsertRowid);
+  })();
 }
 function getActiveUserMemories(db) {
-  const rows = db.prepare("SELECT id, content, status, promoted_at, source_candidate_ids, created_at, updated_at FROM user_memories WHERE status = 'active' ORDER BY promoted_at ASC, id ASC").all();
+  const rows = db.prepare("SELECT id, content, status, promoted_at, source_candidate_ids, source_candidate_provenance, created_at, updated_at FROM user_memories WHERE status = 'active' ORDER BY promoted_at ASC, id ASC").all();
   return rows.map(parseUserMemoryRow);
 }
 function updateUserMemoryContent(db, id, content) {
@@ -10718,26 +12357,58 @@ function updateUserMemoryContent(db, id, content) {
 function dismissUserMemory(db, id) {
   db.prepare("UPDATE user_memories SET status = 'dismissed', updated_at = ? WHERE id = ?").run(Date.now(), id);
 }
-function parseUserMemoryRow(row) {
-  let candidateIds = [];
+function parseCandidateIds2(raw) {
   try {
-    candidateIds = JSON.parse(row.source_candidate_ids);
-  } catch {}
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((id) => typeof id === "number" && Number.isFinite(id)) : [];
+  } catch {
+    return [];
+  }
+}
+function parseUserMemorySourceProvenance(raw) {
+  if (raw === null)
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+      return null;
+    const provenance = [];
+    for (const value of parsed) {
+      if (!value || typeof value !== "object")
+        return null;
+      const source = value;
+      if (typeof source.candidate_id !== "number" || !Number.isFinite(source.candidate_id) || typeof source.session_id !== "string" || source.source_compartment_start !== null && typeof source.source_compartment_start !== "number" || source.source_compartment_end !== null && typeof source.source_compartment_end !== "number") {
+        return null;
+      }
+      provenance.push({
+        candidateId: source.candidate_id,
+        sessionId: source.session_id,
+        sourceCompartmentStart: source.source_compartment_start,
+        sourceCompartmentEnd: source.source_compartment_end
+      });
+    }
+    return provenance;
+  } catch {
+    return null;
+  }
+}
+function parseUserMemoryRow(row) {
   return {
     id: row.id,
     content: row.content,
     status: row.status === "dismissed" ? "dismissed" : "active",
     promotedAt: row.promoted_at,
-    sourceCandidateIds: candidateIds,
+    sourceCandidateIds: parseCandidateIds2(row.source_candidate_ids),
+    sourceProvenance: parseUserMemorySourceProvenance(row.source_candidate_provenance),
     createdAt: row.created_at,
     updatedAt: row.updated_at
   };
 }
 
 // src/features/magic-context/mural/storage-mural-cues.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 function computeCueContentHash(content) {
-  return createHash8("sha256").update(content).digest("hex");
+  return createHash9("sha256").update(content).digest("hex");
 }
 var muralCueColumnCache = new WeakMap;
 var muralCueRejectionColumnCache = new WeakMap;
@@ -10935,13 +12606,13 @@ function invalidateMemory(projectPath, memoryId) {
 }
 
 // src/features/magic-context/memory/normalize-hash.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 function normalizeMemoryContent(content) {
   return content.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function computeNormalizedHash(content) {
   const normalized = normalizeMemoryContent(content);
-  return createHash9("md5").update(normalized).digest("hex");
+  return createHash10("md5").update(normalized).digest("hex");
 }
 
 // src/features/magic-context/memory/visibility.ts
@@ -11910,7 +13581,7 @@ async function runMemoryMigration(deps) {
 }
 
 // src/features/magic-context/compartment-chunk-embedding.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 
 // src/features/magic-context/recursive-text-splitter.ts
 var DEFAULT_SEPARATORS = [`
@@ -12195,7 +13866,7 @@ function parseCanonicalLineRange(line) {
   return { start, end };
 }
 function hashChunkText(text) {
-  return createHash10("sha256").update(text).digest("hex");
+  return createHash11("sha256").update(text).digest("hex");
 }
 function vectorBlob2(vector) {
   return new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength);
@@ -12586,7 +14257,7 @@ function countSessionCompartmentEmbedCoverage(db, projectPath, sessionId, modelI
 }
 
 // src/features/magic-context/project-embedding-registry.ts
-import { createHash as createHash12, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash13, randomUUID as randomUUID2 } from "node:crypto";
 
 // src/config/schema/magic-context.ts
 import { homedir as homedir3 } from "node:os";
@@ -27252,7 +28923,10 @@ var MagicContextConfigSchema = exports_external.object({
   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))
-  ]).optional().describe('User-only output-token reservation override. Number or per-model object ({ default: 16384, "provider/model": 8192 }); 0 disables reservation. When unset, Magic Context reserves the catalog output limit (capped at 25% of context) for shared-window providers and keeps proven separate-quota Google/Gemini windows unchanged.'),
+  ]).optional().describe('User-only output-token reservation override. Number or per-model object ({ default: 16384, "provider/model": 8192 }); 0 disables reservation. Takes precedence over every derived source: an explicit value here always wins against catalog output limits, provider window-geometry facts, and the 25%-of-context fallback (usable window = context window minus this reserve). When unset, Magic Context reserves the catalog output limit (capped at 25% of context) for shared-window providers and keeps proven separate-quota Google/Gemini windows unchanged.'),
+  models: exports_external.object({
+    window_overlay_path: exports_external.string().trim().min(1).optional()
+  }).optional().describe("User-only Fusiform window-overlay settings. The path defaults to <dataDir>/fusiform/window-overlay.json."),
   toast_duration_ms: exports_external.number().min(0).max(60000).default(5000).describe("TUI toast lifetime in milliseconds for Magic Context notifications. Set to 0 to disable Magic Context toasts entirely (min: 0, max: 60000, default: 5000)"),
   execute_threshold_percentage: exports_external.union([
     exports_external.number().min(20).max(90, EXECUTE_THRESHOLD_CAP_MESSAGE),
@@ -27304,7 +28978,7 @@ var MagicContextConfigSchema = exports_external.object({
     overlay: exports_external.boolean().default(true).describe("Pi only: show the persistent todo overlay above the editor while tasks are active.")
   }).default({ enabled: true, overlay: true }).describe("Pi-only todowrite tool and overlay controls. Pi registers tools and widgets at extension boot, so changing this after /cd requires /reload or restart."),
   pi: PiConfigSchema.describe("Pi-only child-process extension controls. This setting is user-level only; project configuration cannot choose which extensions a user's subagent children load."),
-  smart_drops: exports_external.boolean().default(false).describe("Content-aware reclaim of provably-superseded tool output, layered on the existing execute-pass auto-drop. When on: superseded todowrite (keep newest 1), spent ctx_reduce (keep newest 5), and zero-value meta (bash_status, bash_kill, ctx_note read/dismiss) outputs are dropped; older edits to a file are compressed to a filePath-preserving marker while the newest edit per file stays full. Only acts on passes already busting the cache, so it never originates a cache bust. Honors the protected-tag reserve. Experimental: opt-in, default off until cache stability is proven; when off the wire is byte-identical to the positional-only reclaim. Requires a restart."),
+  smart_drops: exports_external.boolean().default(false).describe("Content-aware reclaim of provably-superseded tool output, layered on the existing execute-pass auto-drop. When on: superseded todowrite (keep newest 1), spent ctx_reduce (keep newest 3), and zero-value meta (bash_status, bash_kill, ctx_note read/dismiss) outputs are dropped; older edits to a file are compressed to a filePath-preserving marker while the newest edit per file stays full. Only acts on passes already busting the cache, so it never originates a cache bust. Honors the protected-tag reserve. Experimental: opt-in, default off until cache stability is proven; when off the wire is byte-identical to the positional-only reclaim. Requires a restart."),
   caveman_text_compression: exports_external.object({
     enabled: exports_external.boolean().default(false).describe("Apply deterministic caveman-style text compression to old conversation text. Active for primary sessions when enabled; never for subagents. Compresses user/assistant text in oldest-first tiers: ultra (oldest 20%), full, lite, untouched (newest 40%)."),
     min_chars: exports_external.number().min(100).max(1e4).default(500).describe("Text parts shorter than this (characters) stay untouched. Min 100, max 10000. Default: 500.")
@@ -27656,7 +29330,7 @@ function releaseGitSweepLease(db, projectPath, holderId) {
 }
 
 // src/features/magic-context/memory/embedding-synapse.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 
 // ../../node_modules/.bun/@cortexkit+subc-client@0.4.1/node_modules/@cortexkit/subc-client/dist/client.js
 import { promises as fs2 } from "node:fs";
@@ -28030,7 +29704,7 @@ class SubcSocket {
     return this.sock.localPort ?? null;
   }
   static connect(host, port, deadlineMs) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const sock = net.connect({ host, port });
       sock.setNoDelay(true);
       const timer = setTimeout(() => {
@@ -28039,7 +29713,7 @@ class SubcSocket {
       }, Math.max(0, deadlineMs - Date.now()));
       sock.once("connect", () => {
         clearTimeout(timer);
-        resolve2(new SubcSocket(sock));
+        resolve3(new SubcSocket(sock));
       });
       sock.once("error", (err) => {
         clearTimeout(timer);
@@ -28071,7 +29745,7 @@ class SubcSocket {
     }
     if (n === 0)
       return Promise.resolve(new Uint8Array(0));
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       let timer = null;
       if (Number.isFinite(deadlineMs)) {
         const remaining = deadlineMs - Date.now();
@@ -28084,7 +29758,7 @@ class SubcSocket {
           reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
         }, remaining);
       }
-      this.waiter = { need: n, resolve: resolve2, reject, timer };
+      this.waiter = { need: n, resolve: resolve3, reject, timer };
       this.tryServe();
     });
   }
@@ -28108,7 +29782,7 @@ class SubcSocket {
     let queued = false;
     let settled = false;
     let timer = null;
-    const completed = new Promise((resolve2, reject) => {
+    const completed = new Promise((resolve3, reject) => {
       const settle = (run) => {
         if (settled)
           return;
@@ -28132,7 +29806,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 {
-              resolve2();
+              resolve3();
             }
           });
         });
@@ -28348,14 +30022,14 @@ class SubcClient {
     const admission = opts.admissionClass ?? AdmissionClass.Normal;
     const corr = this.allocateCorr();
     const key = pendingKey(handle, corr);
-    const closed = new Promise((resolve2, reject) => {
+    const closed = new Promise((resolve3, reject) => {
       if (this.closedErr) {
         reject(this.closedErr);
         return;
       }
       this.pending.set(key, {
         handle,
-        resolve: () => resolve2(),
+        resolve: () => resolve3(),
         reject,
         onProgress: onEvent,
         timer: null,
@@ -28440,11 +30114,11 @@ class SubcClient {
     const waiters = [];
     for (const pending of this.pending.values()) {
       if (pending.handle === handle && !pending.subscription) {
-        waiters.push(new Promise((resolve2) => {
+        waiters.push(new Promise((resolve3) => {
           const previous = pending.onSettle;
           pending.onSettle = () => {
             previous?.();
-            resolve2();
+            resolve3();
           };
         }));
       }
@@ -28500,11 +30174,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((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
       const pending = {
         handle,
-        resolve: resolve2,
+        resolve: resolve3,
         reject,
         onProgress,
         timer: null,
@@ -28578,11 +30252,11 @@ class SubcClient {
       }
       return this.outcomeUnknownCallError("connection dropped before the managed call returned a response", error51);
     };
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
       const pending = {
         handle,
-        resolve: resolve2,
+        resolve: resolve3,
         reject,
         onProgress,
         timer: null,
@@ -28970,7 +30644,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((resolve2) => setTimeout(resolve2, ms))),
+    sleep: opts.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms))),
     timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS
   };
 }
@@ -29027,8 +30701,8 @@ class AsyncPermitPool {
       this.available -= 1;
       return this.releaseOnce();
     }
-    await new Promise((resolve2) => {
-      this.waiters.push(resolve2);
+    await new Promise((resolve3) => {
+      this.waiters.push(resolve3);
     });
     return this.releaseOnce();
   }
@@ -29084,8 +30758,8 @@ class SubcProvider {
     this.currentConn = currentConn;
     this.opts = opts;
     this.storage = storage;
-    this.closed = new Promise((resolve2) => {
-      this.resolveClosed = resolve2;
+    this.closed = new Promise((resolve3) => {
+      this.resolveClosed = resolve3;
     });
     this.readLoop(sock, this.generation);
     this.enqueueConnectionState({ state: "connected", epoch: this.connectionEpoch });
@@ -29105,13 +30779,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((resolve2, reject) => {
+    return await new Promise((resolve3, 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) => resolve2(response.body),
+        resolve: (response) => resolve3(response.body),
         reject,
         timer
       });
@@ -29583,7 +31257,7 @@ function normalizeProviderConnectOptions(opts) {
     onBound: opts.onBound,
     onRouteGone: opts.onRouteGone,
     reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
-    sleep: opts.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms))),
+    sleep: opts.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms))),
     restoredDebounceMs: opts.restoredDebounceMs ?? DEFAULT_RESTORED_DEBOUNCE_MS,
     onConnectionState: opts.onConnectionState,
     launchNonce: opts.launchNonce
@@ -29628,7 +31302,7 @@ function errorCode2(err) {
   return;
 }
 async function pauseBeforeStateRetry() {
-  await new Promise((resolve2) => setTimeout(resolve2, 0));
+  await new Promise((resolve3) => setTimeout(resolve3, 0));
 }
 function controlFlags() {
   return buildFlags(false, Priority.Passive, false);
@@ -29866,10 +31540,10 @@ function classifyError(value) {
   });
 }
 function wait(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function sha256(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 function stableJson(value) {
   if (Array.isArray(value))
@@ -30375,7 +32049,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((resolve2) => setTimeout(resolve2, LOCK_POLL_MS));
+      await new Promise((resolve3) => setTimeout(resolve3, LOCK_POLL_MS));
     }
   }
 }
@@ -30580,7 +32254,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((resolve2) => setTimeout(resolve2, delayMs));
+              await new Promise((resolve3) => setTimeout(resolve3, delayMs));
             }
           }
           if (this.pipeline) {
@@ -30613,8 +32287,8 @@ class LocalEmbeddingProvider {
     if (this.inFlight === 0) {
       return Promise.resolve();
     }
-    return new Promise((resolve2) => {
-      this.inFlightWaiters.push(resolve2);
+    return new Promise((resolve3) => {
+      this.inFlightWaiters.push(resolve3);
     });
   }
   finishInFlight() {
@@ -30769,9 +32443,14 @@ function blockedEmbeddingEndpointReason(endpoint) {
 function normalizeEndpoint2(endpoint) {
   return endpoint?.trim().replace(/\/+$/, "") ?? "";
 }
-function embeddingModelsMatch(served, requested) {
-  const a = served.trim().toLowerCase();
-  const b = requested.trim().toLowerCase();
+function parseEmbeddingModel(model) {
+  const lastColon = model.lastIndexOf(":");
+  if (lastColon > model.lastIndexOf("/")) {
+    return { base: model.slice(0, lastColon), tag: model.slice(lastColon + 1) };
+  }
+  return { base: model };
+}
+function matchNormalizedEmbeddingModels(a, b) {
   if (a.length === 0 || b.length === 0)
     return true;
   if (a === b)
@@ -30785,6 +32464,16 @@ function embeddingModelsMatch(served, requested) {
     return true;
   return false;
 }
+function embeddingModelsMatch(served, requested) {
+  const a = served.trim().toLowerCase();
+  const b = requested.trim().toLowerCase();
+  const servedModel = parseEmbeddingModel(a);
+  const requestedModel = parseEmbeddingModel(b);
+  if (servedModel.tag !== undefined && requestedModel.tag !== undefined && servedModel.tag !== requestedModel.tag) {
+    return false;
+  }
+  return matchNormalizedEmbeddingModels(servedModel.base, requestedModel.base);
+}
 var FAILURE_THRESHOLD = 3;
 var FAILURE_WINDOW_MS = 60000;
 var OPEN_DURATION_MS = 5 * 60000;
@@ -30915,7 +32604,7 @@ class OpenAICompatibleEmbeddingProvider {
       const servedModel = typeof body.model === "string" ? body.model : "";
       if (this.model && servedModel && !embeddingModelsMatch(servedModel, this.model)) {
         if (!this.modelMismatchLogged) {
-          log(`[magic-context] embedding endpoint served a DIFFERENT model than requested — refusing the substituted vectors (they have the wrong dimensions/space). requested="${this.model}" served="${servedModel}". The endpoint likely substituted a loaded model; load/select "${this.model}" on the endpoint, or set embedding.model to the served model.`);
+          log(`[magic-context] embedding endpoint served a DIFFERENT model than requested — refusing the substituted vectors (they have the wrong dimensions/space). requested="${this.model}" served="${servedModel}". Check that the endpoint serves the requested model; variant suffixes and vendor prefixes are matched automatically.`);
           this.modelMismatchLogged = true;
         }
         this.recordFailure(isProbe);
@@ -31302,10 +32991,10 @@ function stableStringify2(value) {
   return JSON.stringify(value);
 }
 function sha256Prefix(value, length = 16) {
-  return createHash12("sha256").update(value).digest("hex").slice(0, length);
+  return createHash13("sha256").update(value).digest("hex").slice(0, length);
 }
 function contentSha256(value) {
-  return createHash12("sha256").update(value).digest("hex");
+  return createHash13("sha256").update(value).digest("hex");
 }
 function getRuntimeFingerprint(config2) {
   if (config2.provider === "off") {
@@ -31505,14 +33194,14 @@ function hasStaleEmbeddingRows(db, scope, projectIdentity, modelId) {
                  LIMIT 1`).get(projectIdentity, modelId));
 }
 function sweepStaleEmbeddingIdentitiesForProject(db, projectIdentity, now = Date.now()) {
-  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
+  const snapshot2 = getProjectEmbeddingSnapshot(projectIdentity);
   const result = {
     memoryRowsDeleted: 0,
     commitRowsDeleted: 0,
     chunkRowsDeleted: 0,
     trackingRowsDeleted: 0
   };
-  if (!snapshot)
+  if (!snapshot2)
     return result;
   if (untrustedLoadProjects.has(projectIdentity))
     return result;
@@ -31520,25 +33209,25 @@ function sweepStaleEmbeddingIdentitiesForProject(db, projectIdentity, now = Date
   const deleteTracking = getDeleteActiveIdentityStatement(db);
   const shadow = shadowRegistrations.get(projectIdentity);
   const protectedModels = {
-    memory: new Set([snapshot.modelId, ...shadow ? [shadow.modelId] : []]),
-    commit: new Set([snapshot.modelId, ...shadow ? [shadow.modelId] : []]),
-    chunk: new Set([snapshot.chunkModelId, ...shadow ? [shadow.chunkModelId] : []])
+    memory: new Set([snapshot2.modelId, ...shadow ? [shadow.modelId] : []]),
+    commit: new Set([snapshot2.modelId, ...shadow ? [shadow.modelId] : []]),
+    chunk: new Set([snapshot2.chunkModelId, ...shadow ? [shadow.chunkModelId] : []])
   };
   const scopes = [
     {
       scope: "memory",
-      enabled: snapshot.enabled && snapshot.modelId !== "off",
-      currentModelId: snapshot.modelId
+      enabled: snapshot2.enabled && snapshot2.modelId !== "off",
+      currentModelId: snapshot2.modelId
     },
     {
       scope: "commit",
-      enabled: snapshot.gitCommitEnabled && snapshot.modelId !== "off",
-      currentModelId: snapshot.modelId
+      enabled: snapshot2.gitCommitEnabled && snapshot2.modelId !== "off",
+      currentModelId: snapshot2.modelId
     },
     {
       scope: "chunk",
-      enabled: snapshot.enabled && snapshot.chunkModelId !== "off",
-      currentModelId: snapshot.chunkModelId
+      enabled: snapshot2.enabled && snapshot2.chunkModelId !== "off",
+      currentModelId: snapshot2.chunkModelId
     }
   ];
   let remainingBudget = STALE_EMBEDDING_GC_BATCH_SIZE;
@@ -31994,7 +33683,7 @@ async function runShadowWorker() {
     }
     processed += item.ids.length;
     processedBytes += itemBytes;
-    await new Promise((resolve2) => setTimeout(resolve2, 0));
+    await new Promise((resolve3) => setTimeout(resolve3, 0));
   }
 }
 function registerProjectInObservationMode(db, projectIdentity, sourceDirectory, failedConfig, failureSummary) {
@@ -32177,11 +33866,11 @@ function getLoadUnembeddedMemoriesStatement(db) {
   return stmt;
 }
 async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize = 10) {
-  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
-  if (!snapshot?.enabled)
+  const snapshot2 = getProjectEmbeddingSnapshot(projectIdentity);
+  if (!snapshot2?.enabled)
     return 0;
   const normalizedBatchSize = Math.max(1, Math.floor(batchSize));
-  const memories = getLoadUnembeddedMemoriesStatement(db).all(snapshot.modelId, projectIdentity, normalizedBatchSize).filter(isUnembeddedMemoryRow);
+  const memories = getLoadUnembeddedMemoriesStatement(db).all(snapshot2.modelId, projectIdentity, normalizedBatchSize).filter(isUnembeddedMemoryRow);
   if (memories.length === 0)
     return 0;
   try {
@@ -32211,10 +33900,10 @@ async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize
   }
 }
 async function embedCommitBatch(db, projectIdentity, batchSize) {
-  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
-  if (!snapshot?.gitCommitEnabled)
+  const snapshot2 = getProjectEmbeddingSnapshot(projectIdentity);
+  if (!snapshot2?.gitCommitEnabled)
     return 0;
-  const commits = loadUnembeddedCommits(db, projectIdentity, snapshot.modelId, Math.max(1, Math.floor(batchSize)));
+  const commits = loadUnembeddedCommits(db, projectIdentity, snapshot2.modelId, Math.max(1, Math.floor(batchSize)));
   if (commits.length === 0)
     return 0;
   const result = await embedItemsForProject(projectIdentity, commits.map((commit) => ({
@@ -32238,8 +33927,8 @@ async function embedCommitBatch(db, projectIdentity, batchSize) {
   return embeddedCount;
 }
 async function drainCommitBacklogForProject(db, projectIdentity, deadline) {
-  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
-  if (!snapshot?.gitCommitEnabled)
+  const snapshot2 = getProjectEmbeddingSnapshot(projectIdentity);
+  if (!snapshot2?.gitCommitEnabled)
     return 0;
   const holderId = `embed-sweep-${randomUUID2()}`;
   const lease = acquireGitSweepLease(db, projectIdentity, holderId, { ignoreCooldown: true });
@@ -32355,7 +34044,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((resolve2) => setTimeout(resolve2, EMBED_SLICE_RETRY_BASE_MS * 2 ** attempt));
+        await new Promise((resolve3) => setTimeout(resolve3, EMBED_SLICE_RETRY_BASE_MS * 2 ** attempt));
       }
     }
     embedded += persistedIds.size;
@@ -32369,12 +34058,12 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
   return { embedded, noWork, failed };
 }
 async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, options) {
-  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
-  if (!snapshot?.enabled || snapshot.chunkModelId === "off") {
+  const snapshot2 = getProjectEmbeddingSnapshot(projectIdentity);
+  if (!snapshot2?.enabled || snapshot2.chunkModelId === "off") {
     return { status: "disabled", embedded: 0, total: 0 };
   }
   recordSessionProjectIdentity(db, sessionId, projectIdentity);
-  const total = countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot.chunkModelId);
+  const total = countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot2.chunkModelId);
   if (total === 0)
     return { status: "nothing", embedded: 0, total: 0 };
   const holderId = `session-embed-${randomUUID2()}`;
@@ -32411,14 +34100,14 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
         aborted2 = true;
         break;
       }
-      const candidates = loadUnembeddedSessionChunkCandidates(db, projectIdentity, sessionId, snapshot.chunkModelId, batchSize, [...skipIds, ...failedIds]);
+      const candidates = loadUnembeddedSessionChunkCandidates(db, projectIdentity, sessionId, snapshot2.chunkModelId, batchSize, [...skipIds, ...failedIds]);
       if (candidates.length === 0)
         break;
       const {
         embedded: n,
         noWork,
         failed
-      } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, drainAbort.signal);
+      } = await embedCandidateChunkBatch(db, projectIdentity, snapshot2.chunkModelId, candidates, drainAbort.signal);
       if (leaseLost || !renewGitSweepLease(db, projectIdentity, holderId)) {
         leaseLost = true;
         drainAbort.abort();
@@ -32440,7 +34129,7 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
       }
       embedded += n;
       options?.onProgress?.({ embedded: Math.min(embedded, total), total });
-      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      await new Promise((resolve3) => setTimeout(resolve3, 0));
     }
   } finally {
     clearInterval(renewal);
@@ -32454,7 +34143,7 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
   if (aborted2)
     return { status: "aborted", embedded, total, failed: failedIds.length };
   if (providerDown || failedIds.length > 0) {
-    const remaining = Math.max(0, countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot.chunkModelId) - skipIds.length);
+    const remaining = Math.max(0, countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot2.chunkModelId) - skipIds.length);
     if (remaining > 0) {
       return { status: "stalled", embedded, total, remaining, failed: failedIds.length };
     }
@@ -32462,29 +34151,29 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
   return { status: "done", embedded, total, failed: failedIds.length };
 }
 function getEmbeddingCoverageStatus(db, projectIdentity, sessionId) {
-  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
-  if (!snapshot?.enabled || snapshot.chunkModelId === "off") {
+  const snapshot2 = getProjectEmbeddingSnapshot(projectIdentity);
+  if (!snapshot2?.enabled || snapshot2.chunkModelId === "off") {
     return {
       enabled: false,
-      model: snapshot?.model ?? "off",
-      provider: snapshot?.provider ?? "off",
+      model: snapshot2?.model ?? "off",
+      provider: snapshot2?.provider ?? "off",
       session: { embedded: 0, total: 0 },
       memories: { embedded: 0, total: 0 },
       commits: { embedded: 0, total: 0, gitEnabled: false }
     };
   }
-  const session = countSessionCompartmentEmbedCoverage(db, projectIdentity, sessionId, snapshot.chunkModelId);
-  const memories = getMemoryEmbedCoverage(db, projectIdentity, snapshot.modelId);
-  const gitEnabled = snapshot.gitCommitEnabled;
+  const session = countSessionCompartmentEmbedCoverage(db, projectIdentity, sessionId, snapshot2.chunkModelId);
+  const memories = getMemoryEmbedCoverage(db, projectIdentity, snapshot2.modelId);
+  const gitEnabled = snapshot2.gitCommitEnabled;
   const commits = gitEnabled ? {
-    embedded: countEmbeddedCommits(db, projectIdentity, snapshot.modelId),
+    embedded: countEmbeddedCommits(db, projectIdentity, snapshot2.modelId),
     total: getCommitCount(db, projectIdentity),
     gitEnabled: true
   } : { embedded: 0, total: 0, gitEnabled: false };
   return {
     enabled: true,
-    model: snapshot.model,
-    provider: snapshot.provider,
+    model: snapshot2.model,
+    provider: snapshot2.provider,
     session,
     memories,
     commits
@@ -32672,8 +34361,8 @@ async function embedText(text, signal) {
 }
 // src/features/magic-context/memory/embedding-backfill.ts
 async function ensureMemoryEmbeddings(args) {
-  const snapshot = getProjectEmbeddingSnapshot(args.projectIdentity);
-  if (!snapshot?.enabled) {
+  const snapshot2 = getProjectEmbeddingSnapshot(args.projectIdentity);
+  if (!snapshot2?.enabled) {
     return args.existingEmbeddings;
   }
   const missingMemories = args.memories.filter((memory) => !args.existingEmbeddings.has(memory.id));
@@ -33145,7 +34834,7 @@ function tallyFactsByCategory(facts) {
 import { join as join7 } from "node:path";
 
 // src/features/magic-context/compaction-marker.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 import { existsSync as existsSync7 } from "node:fs";
 import { join as join6 } from "node:path";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -33153,7 +34842,7 @@ var ID_PREFIX_HEX_LENGTH = 12;
 var ID_SUFFIX_LENGTH = 14;
 var ID_PREFIX_MASK = (1n << BigInt(ID_PREFIX_HEX_LENGTH * 4)) - 1n;
 function deterministicBase62(seed, length) {
-  let value = BigInt(`0x${createHash13("sha256").update(seed).digest("hex")}`);
+  let value = BigInt(`0x${createHash14("sha256").update(seed).digest("hex")}`);
   const chars = Array(length);
   for (let index = length - 1;index >= 0; index -= 1) {
     chars[index] = BASE62_CHARS[Number(value % 62n)];
@@ -35473,8 +37162,8 @@ function isTransientHistorianPromptError(message) {
   ].some((token) => normalized.includes(token));
 }
 function sleep(ms) {
-  return new Promise((resolve2) => {
-    setTimeout(resolve2, ms);
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
   });
 }
 function cleanupHistorianDump(sessionId, dumpPath) {
@@ -35519,7 +37208,7 @@ function sanitizeDumpName(value) {
 import { Buffer as Buffer3 } from "node:buffer";
 
 // src/features/magic-context/mural/render-trigger.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 
 // src/features/magic-context/mural/mural-selection.ts
 var DEFAULT_MURAL_MEMORY_BUDGET = 8000;
@@ -36145,7 +37834,7 @@ function ensureMuralRendered(db, projectIdentity, budgetTokens = DEFAULT_MURAL_M
     return { hasMural: false, rerendered: false };
   }
   const rendered = renderMural(entries);
-  const textHash = createHash14("sha256").update(rendered.sha256Input).digest("hex");
+  const textHash = createHash15("sha256").update(rendered.sha256Input).digest("hex");
   const existing = getMural(db, projectIdentity);
   if (existing && existing.contentHash === textHash && existing.width === rendered.width && existing.height === rendered.height) {
     return {
@@ -36710,11 +38399,15 @@ function trimMemoriesToBudget(sessionId, memories, budgetTokens) {
 }
 function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectPath, injectionBudgetTokens, temporalAwareness) {
   const cached2 = injectionCache.get(sessionId);
-  if (!isCacheBusting && cached2) {
-    if (cached2.kind === "empty") {
+  if (cached2 && cached2.db !== db) {
+    clearInjectionCache(sessionId);
+  }
+  const usableCached = cached2?.db === db ? cached2 : undefined;
+  if (!isCacheBusting && usableCached) {
+    if (usableCached.kind === "empty") {
       return null;
     }
-    const prepared = cached2.injection;
+    const prepared = usableCached.injection;
     if (prepared.compartmentEndMessageId === null) {
       sessionLog(sessionId, "compartment injection cache in degraded mode (null boundary), forcing rebuild");
     } else {
@@ -36761,6 +38454,7 @@ function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, pr
   }
   if (compartments.length === 0 && facts.length === 0 && !memoryBlock) {
     injectionCache.set(sessionId, {
+      db,
       kind: "empty",
       compartmentEndMessageId: "",
       renderedBytes: 0
@@ -36800,7 +38494,7 @@ function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, pr
       memoryCount,
       rebuiltFromDb: true
     };
-    injectionCache.set(sessionId, { kind: "populated", injection: result2 });
+    injectionCache.set(sessionId, { db, kind: "populated", injection: result2 });
     return result2;
   }
   const lastCompartment = compartments[compartments.length - 1];
@@ -36832,7 +38526,7 @@ function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, pr
       memoryCount,
       rebuiltFromDb: true
     };
-    injectionCache.set(sessionId, { kind: "populated", injection: result2 });
+    injectionCache.set(sessionId, { db, kind: "populated", injection: result2 });
     return result2;
   }
   let skippedVisibleMessages = 0;
@@ -36893,7 +38587,7 @@ function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, pr
   if (needsFreshMaterialization) {
     result.needsFreshMaterialization = true;
   }
-  injectionCache.set(sessionId, { kind: "populated", injection: result });
+  injectionCache.set(sessionId, { db, kind: "populated", injection: result });
   return result;
 }
 function readCachedBaselineState(db, sessionId) {
@@ -37255,7 +38949,7 @@ function readCurrentM0SnapshotMarkersUncached(args) {
       upgradeState: getUpgradeState(args.db, args.sessionId),
       compartmentRenderEpoch: COMPARTMENT_RENDER_EPOCH,
       systemHash: hard.systemHash,
-      modelKey: hard.modelKey,
+      modelKey: piModelRefToCanonical(hard.modelKey),
       projectIdentity: args.projectPath ?? null,
       muralEnabled: args.muralEnabled === true,
       renderBudgetIdentity: renderBudgetIdentity(args.memoryInjectionBudgetTokens, args.historyBudgetTokens)
@@ -37358,7 +39052,9 @@ function mustMaterialize(args) {
   if (cachedUpgradeIdentity.muralEnabled !== null && cachedUpgradeIdentity.muralEnabled !== current.muralEnabled || cachedUpgradeIdentity.renderBudgetIdentity !== null && cachedUpgradeIdentity.renderBudgetIdentity !== current.renderBudgetIdentity) {
     return { value: true, reason: "render_config" };
   }
-  if (hard.modelKey !== "" && hard.modelKey !== (args.state.cachedM0ModelKey ?? "")) {
+  const canonicalHardModelKey = piModelRefToCanonical(hard.modelKey);
+  const canonicalCachedModelKey = piModelRefToCanonical(args.state.cachedM0ModelKey ?? "");
+  if (canonicalHardModelKey !== "" && canonicalHardModelKey !== canonicalCachedModelKey) {
     return { value: true, reason: "model_change" };
   }
   if (hard.systemHash !== "" && hard.systemHash !== (args.state.cachedM0SystemHash ?? "")) {
@@ -38102,7 +39798,7 @@ function markersFromCachedRow(row) {
   };
 }
 function cachedRowMatchesState(row, state2) {
-  return bufferEqualsNullable(row.cached_m0_bytes, state2.cachedM0Bytes) && (row.cached_m0_mural_data_url ?? null) === (state2.cachedM0MuralDataUrl ?? null) && (row.cached_m0_mural_hash ?? null) === (state2.cachedM0MuralHash ?? null) && row.cached_m0_project_memory_epoch === state2.cachedM0ProjectMemoryEpoch && (row.cached_m0_workspace_fingerprint ?? null) === (state2.cachedM0WorkspaceFingerprint ?? null) && row.cached_m0_project_user_profile_version === state2.cachedM0ProjectUserProfileVersion && row.cached_m0_max_compartment_seq === state2.cachedM0MaxCompartmentSeq && row.cached_m0_max_memory_id === state2.cachedM0MaxMemoryId && row.cached_m0_max_mutation_id === state2.cachedM0MaxMutationId && row.cached_m0_max_memory_mutation_id === state2.cachedM0MaxMemoryMutationId && row.cached_m0_materialized_at === state2.cachedM0MaterializedAt && row.cached_m0_session_facts_version === state2.cachedM0SessionFactsVersion && (row.cached_m0_upgrade_state ?? null) === (state2.cachedM0UpgradeState ?? null) && (row.cached_m0_system_hash ?? "") === (state2.cachedM0SystemHash ?? "") && (row.cached_m0_model_key ?? "") === (state2.cachedM0ModelKey ?? "") && (row.cached_m0_project_identity ?? null) === (state2.cachedM0ProjectIdentity ?? null);
+  return bufferEqualsNullable(row.cached_m0_bytes, state2.cachedM0Bytes) && (row.cached_m0_mural_data_url ?? null) === (state2.cachedM0MuralDataUrl ?? null) && (row.cached_m0_mural_hash ?? null) === (state2.cachedM0MuralHash ?? null) && row.cached_m0_project_memory_epoch === state2.cachedM0ProjectMemoryEpoch && (row.cached_m0_workspace_fingerprint ?? null) === (state2.cachedM0WorkspaceFingerprint ?? null) && row.cached_m0_project_user_profile_version === state2.cachedM0ProjectUserProfileVersion && row.cached_m0_max_compartment_seq === state2.cachedM0MaxCompartmentSeq && row.cached_m0_max_memory_id === state2.cachedM0MaxMemoryId && row.cached_m0_max_mutation_id === state2.cachedM0MaxMutationId && row.cached_m0_max_memory_mutation_id === state2.cachedM0MaxMemoryMutationId && row.cached_m0_materialized_at === state2.cachedM0MaterializedAt && row.cached_m0_session_facts_version === state2.cachedM0SessionFactsVersion && (row.cached_m0_upgrade_state ?? null) === (state2.cachedM0UpgradeState ?? null) && (row.cached_m0_system_hash ?? "") === (state2.cachedM0SystemHash ?? "") && piModelRefToCanonical(row.cached_m0_model_key ?? "") === piModelRefToCanonical(state2.cachedM0ModelKey ?? "") && (row.cached_m0_project_identity ?? null) === (state2.cachedM0ProjectIdentity ?? null);
 }
 function applyCachedRowToState(state2, row) {
   const markers = markersFromCachedRow(row);
@@ -38559,13 +40255,13 @@ function force80PerRunCap(usable, N) {
 function force95PerRunCap(usable, N) {
   return Math.min(FORCE95_MAX_CAP, Math.max(4 * N, Math.min(Math.round(0.5 * usable), 250000)));
 }
-function selectPerRunCap(snapshot) {
-  const usable = Math.max(1, Math.round(snapshot.contextLimit * snapshot.executeThresholdPercentage / 100));
-  if (snapshot.usagePercentage >= 95)
-    return force95PerRunCap(usable, snapshot.N);
-  if (snapshot.usagePercentage >= 80)
-    return force80PerRunCap(usable, snapshot.N);
-  return nonEmergencyPerRunCap(usable, snapshot.N);
+function selectPerRunCap(snapshot2) {
+  const usable = Math.max(1, Math.round(snapshot2.contextLimit * snapshot2.executeThresholdPercentage / 100));
+  if (snapshot2.usagePercentage >= 95)
+    return force95PerRunCap(usable, snapshot2.N);
+  if (snapshot2.usagePercentage >= 80)
+    return force80PerRunCap(usable, snapshot2.N);
+  return nonEmergencyPerRunCap(usable, snapshot2.N);
 }
 function boundaryMessageId(index, ordinal) {
   if (ordinal < 1 || ordinal > index.rawMessageCount)
@@ -38977,7 +40673,7 @@ function resolveWrapupProtectedTailBoundary(args) {
   });
   const eligibleEndOrdinal = Math.min(head.eligibleEndOrdinal, targetProtectedTailStart);
   const rawRangeFingerprint = computeRawRangeFingerprint(messages, offset, eligibleEndOrdinal);
-  const snapshot = {
+  const snapshot2 = {
     sessionId: ctx.sessionId,
     mode: "manual-wrapup",
     offset,
@@ -39007,7 +40703,7 @@ function resolveWrapupProtectedTailBoundary(args) {
     boundaryReason
   };
   return {
-    snapshot,
+    snapshot: snapshot2,
     rawMessagesAboveLastCompartment,
     anchorRawMessageCount,
     targetProtectedTailStart,
@@ -39026,46 +40722,46 @@ function getRawHistoryEligibility(db, sessionId) {
     hasRawBeyondLastCompartment: rawMessageCount >= offset
   };
 }
-function hasRunnableCompartmentWindow(snapshot) {
-  if (snapshot.offset >= snapshot.protectedTailStart)
+function hasRunnableCompartmentWindow(snapshot2) {
+  if (snapshot2.offset >= snapshot2.protectedTailStart)
     return false;
-  const forceMaterializationPercentage = escalationBands(snapshot.executeThresholdPercentage).forceMaterializationPercentage;
-  if (snapshot.usagePercentage >= forceMaterializationPercentage || snapshot.emergencyTailScale) {
-    return snapshot.trueRawEligibleTokens >= deriveMinForceEligibleTokens(snapshot.N) || snapshot.eligibleEndOrdinal > snapshot.offset;
+  const forceMaterializationPercentage = escalationBands(snapshot2.executeThresholdPercentage).forceMaterializationPercentage;
+  if (snapshot2.usagePercentage >= forceMaterializationPercentage || snapshot2.emergencyTailScale) {
+    return snapshot2.trueRawEligibleTokens >= deriveMinForceEligibleTokens(snapshot2.N) || snapshot2.eligibleEndOrdinal > snapshot2.offset;
   }
-  return snapshot.eligibleEndOrdinal > snapshot.offset;
+  return snapshot2.eligibleEndOrdinal > snapshot2.offset;
 }
 function validateBoundarySnapshot(args) {
-  const { snapshot } = args;
-  if (args.currentContextLimit && args.currentContextLimit !== snapshot.contextLimit) {
+  const { snapshot: snapshot2 } = args;
+  if (args.currentContextLimit && args.currentContextLimit !== snapshot2.contextLimit) {
     return {
       ok: false,
       reason: "model_or_limit_changed",
-      detail: `context limit changed from ${snapshot.contextLimit} to ${args.currentContextLimit}`
+      detail: `context limit changed from ${snapshot2.contextLimit} to ${args.currentContextLimit}`
     };
   }
-  const messages = readRawSessionMessages(snapshot.sessionId);
+  const messages = readRawSessionMessages(snapshot2.sessionId);
   const currentRawMessageCount = messages.reduce((max, message) => Math.max(max, message.ordinal), messages.length);
-  if (snapshot.rawMessageCountAtTrigger > currentRawMessageCount) {
+  if (snapshot2.rawMessageCountAtTrigger > currentRawMessageCount) {
     return { ok: false, reason: "stale_snapshot", detail: "raw message count shrank" };
   }
   const idsByOrdinal = new Map(messages.map((message) => [message.ordinal, message.id]));
   const idAt = (ordinal) => idsByOrdinal.get(ordinal) ?? null;
   const checks3 = [
-    [snapshot.offset, snapshot.offsetMessageId, "offset"],
-    [snapshot.rawMessageCountAtTrigger, snapshot.rawLastMessageIdAtTrigger, "last"]
+    [snapshot2.offset, snapshot2.offsetMessageId, "offset"],
+    [snapshot2.rawMessageCountAtTrigger, snapshot2.rawLastMessageIdAtTrigger, "last"]
   ];
-  if (snapshot.protectedTailStart <= snapshot.rawMessageCountAtTrigger) {
+  if (snapshot2.protectedTailStart <= snapshot2.rawMessageCountAtTrigger) {
     checks3.push([
-      snapshot.protectedTailStart,
-      snapshot.protectedTailStartMessageId,
+      snapshot2.protectedTailStart,
+      snapshot2.protectedTailStartMessageId,
       "protectedTailStart"
     ]);
   }
-  if (snapshot.eligibleEndOrdinal > snapshot.offset) {
+  if (snapshot2.eligibleEndOrdinal > snapshot2.offset) {
     checks3.push([
-      snapshot.eligibleEndOrdinal - 1,
-      snapshot.eligibleEndMessageId,
+      snapshot2.eligibleEndOrdinal - 1,
+      snapshot2.eligibleEndMessageId,
       "eligibleEnd"
     ]);
   }
@@ -39078,26 +40774,26 @@ function validateBoundarySnapshot(args) {
       };
     }
   }
-  const expectedOffset = Math.max(1, getLastCompartmentEndMessage(args.db, snapshot.sessionId) + 1);
-  if (expectedOffset !== snapshot.offset) {
+  const expectedOffset = Math.max(1, getLastCompartmentEndMessage(args.db, snapshot2.sessionId) + 1);
+  if (expectedOffset !== snapshot2.offset) {
     return {
       ok: false,
       reason: "stale_snapshot",
-      detail: `last compartment moved: offset ${snapshot.offset} -> ${expectedOffset}`
+      detail: `last compartment moved: offset ${snapshot2.offset} -> ${expectedOffset}`
     };
   }
-  const fingerprint = computeRawRangeFingerprint(messages, snapshot.offset, snapshot.eligibleEndOrdinal);
-  if (fingerprint !== snapshot.rawRangeFingerprint) {
+  const fingerprint = computeRawRangeFingerprint(messages, snapshot2.offset, snapshot2.eligibleEndOrdinal);
+  if (fingerprint !== snapshot2.rawRangeFingerprint) {
     return { ok: false, reason: "stale_snapshot", detail: "raw range fingerprint changed" };
   }
   return { ok: true };
 }
-function recordHighPressureNoEligibleHead(db, snapshot) {
-  const forceMaterializationPercentage = escalationBands(snapshot.executeThresholdPercentage).forceMaterializationPercentage;
-  if (snapshot.usagePercentage < forceMaterializationPercentage && !snapshot.emergencyTailScale) {
+function recordHighPressureNoEligibleHead(db, snapshot2) {
+  const forceMaterializationPercentage = escalationBands(snapshot2.executeThresholdPercentage).forceMaterializationPercentage;
+  if (snapshot2.usagePercentage < forceMaterializationPercentage && !snapshot2.emergencyTailScale) {
     return 0;
   }
-  return recordProtectedTailNoEligibleHead(db, snapshot.sessionId);
+  return recordProtectedTailNoEligibleHead(db, snapshot2.sessionId);
 }
 
 // src/hooks/magic-context/reference-seeds.generated.ts
@@ -42257,7 +43953,7 @@ async function executeContextRecomp(deps, options = {}) {
 }
 
 // src/hooks/magic-context/lkg-slot.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 var LKG_TOTAL_BYTES = 64 * 1024 * 1024;
 var LKG_SINGLE_SLOT_BYTES = 24 * 1024 * 1024;
 var LKG_METADATA_BYTES = 256;
@@ -42319,13 +44015,32 @@ function lkgContentFields(value) {
   }
 }
 function lkgContentDigestFromFields(fields) {
-  const hash2 = createHash15("sha256");
+  const hash2 = createHash16("sha256");
   for (const field of fields) {
     const value = typeof field === "symbol" ? field.description ?? "" : String(field);
     hash2.update(`${typeof field}:${value.length}:`).update(value).update("\x00");
   }
   return hash2.digest("base64url");
 }
+function incrementalLkgContentDigests(entries, prior) {
+  const aligned = prior !== undefined && prior.ids.length === prior.signatures.length && prior.signatures.length === prior.digests.length;
+  let reusedPrefix = 0;
+  if (aligned && prior) {
+    while (reusedPrefix < entries.length && reusedPrefix < prior.ids.length && entries[reusedPrefix]?.id === prior.ids[reusedPrefix] && entries[reusedPrefix]?.signature === prior.signatures[reusedPrefix]) {
+      reusedPrefix += 1;
+    }
+  }
+  const digests = [];
+  if (aligned && prior) {
+    for (let index = 0;index < reusedPrefix; index += 1) {
+      digests.push(prior.digests[index]);
+    }
+  }
+  for (let index = reusedPrefix;index < entries.length; index += 1) {
+    digests.push(lkgContentDigestFromFields(entries[index]?.fields ?? []));
+  }
+  return { digests, reusedPrefix };
+}
 function lkgContentDigest(message) {
   const fields = lkgContentFields(message);
   return fields ? lkgContentDigestFromFields(fields) : null;
@@ -42335,7 +44050,7 @@ function touch(sessionId, entry) {
   slots.set(sessionId, entry);
 }
 function captureSlot(sessionId, slot) {
-  if (slot.inputContentDigests.length !== slot.inputIdSeq.length || slot.inputContentDigests.some((digest) => digest.length === 0)) {
+  if (slot.inputContentDigests.length !== slot.inputIdSeq.length || slot.inputContentDigests.some((digest) => digest.length === 0) || slot.inputContentSignatures !== undefined && (slot.inputContentSignatures.length !== slot.inputIdSeq.length || slot.inputContentSignatures.some((signature) => signature.length === 0))) {
     return false;
   }
   const bytes = slotBytes(slot);
@@ -42368,7 +44083,8 @@ function captureSlot(sessionId, slot) {
     slot: {
       ...slot,
       inputIdSeq: [...slot.inputIdSeq],
-      inputContentDigests: [...slot.inputContentDigests]
+      inputContentDigests: [...slot.inputContentDigests],
+      inputContentSignatures: slot.inputContentSignatures ? [...slot.inputContentSignatures] : undefined
     },
     bytes
   };
@@ -42384,7 +44100,8 @@ function getSlot(sessionId) {
   return {
     ...entry.slot,
     inputIdSeq: [...entry.slot.inputIdSeq],
-    inputContentDigests: [...entry.slot.inputContentDigests]
+    inputContentDigests: [...entry.slot.inputContentDigests],
+    inputContentSignatures: entry.slot.inputContentSignatures ? [...entry.slot.inputContentSignatures] : undefined
   };
 }
 function dropSlot(sessionId, _reason) {
@@ -42654,4 +44371,4 @@ async function runUpgradeMemoryMigration(ctx, sessionId, migrationDirectory) {
   }
 }
 
-export { withContentLanguageDirective, buildPrimaryLanguageDirective, cortexKitUserConfigBasePath, cortexKitProjectConfigBasePath, resolveLegacyConfigSources, resolveLegacyConfigSourcesForHarness, migrateMagicContextConfigLocations, exports_external, DEFAULT_PROTECTED_TAGS, parseCron, nextOccurrence, nextDueAtMs, promptSurfaceConfigIdentity, resolvePromptSurface, resolveModelConfigOrDefault, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, DEFAULT_HISTORIAN_TIMEOUT_MS, DEFAULT_LOCAL_EMBEDDING_MODEL, MagicContextConfigSchema, getOpenCodeDbPath, removeMcOwnedCompactionMarkers, isFailClosedBlockingError, shouldBypassFailClosedBlock, resolveAgentNameFromMessages, createFailClosedController, recordHookInitFailure, clearHookInitFailure, getLastHookInitFailure, 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, applyMirroredNoteCompileFields, 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, LKG_SNAPSHOT_ARRAY, LKG_SNAPSHOT_OBJECT, LKG_SNAPSHOT_KEY, LKG_SNAPSHOT_STRING, LKG_SNAPSHOT_NUMBER, LKG_SNAPSHOT_BOOLEAN, LKG_SNAPSHOT_NULL, LKG_SNAPSHOT_UNDEFINED, lkgContentDigestFromFields, 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, promptSurfaceConfigIdentity, resolvePromptSurface, resolveModelConfigOrDefault, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, DEFAULT_HISTORIAN_TIMEOUT_MS, DEFAULT_LOCAL_EMBEDDING_MODEL, MagicContextConfigSchema, getOpenCodeDbPath, removeMcOwnedCompactionMarkers, isFailClosedBlockingError, shouldBypassFailClosedBlock, resolveAgentNameFromMessages, createFailClosedController, recordHookInitFailure, clearHookInitFailure, getLastHookInitFailure, ProjectIdentityError, resolveProjectIdentityStrict, takeDubiousOwnershipProjectIdentityWarning, resolveProjectIdentity, resolveProjectIdentityForSession, normalizeStoredProjectPath, storedPathBelongsToIdentity, isLinkedGitWorktree, recordSessionProjectIdentity, beginBootQuietPeriod, bootQuietRemainingMs, scheduleAfterBootQuiet, rpcPortDir, rpcPortFilePath, isPidAlive, parseRpcPortFile, registerModuleNoteEvaluationBridge, getModuleNoteEvaluationBridge, getContextStoreUuid, ensureContextStoreUuid, getAuthorityManagedMarker, reconcileAuthorityProject, checksumAuthoritySeedRows, prepareAuthority, drainAuthority, getMirrorCursor, applyMirroredNoteCompileFields, 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, getMergedReasoningStrippedIds, addMergedReasoningStrippedIds, getTrailingBlankDecisions, addTrailingBlankDecisions, 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, CTX_REDUCE_KEEP, estimateImageTokensFromDataUrl, normalizeTodoStateJson, buildSyntheticTodoPart, computeSyntheticCallId, isSyntheticTodoPart, tailHygieneStructuralSignature, sameTailHygieneStructuralSignature, refreshTailHygieneBaseline, effectiveTailHygiene, assertTailHygieneContentUnchanged, CHANNEL1_SENTINEL, CHANNEL1_FLOOR_TOKENS, toolOutputTokens, decideChannel1, evaluateChannel2, buildChannel2Reminder, buildChannel1Reminder, estimateEmergencyDropReclaimTokens, planEmergencyDrop, AGE_RECLAIM_MIN_TOKENS, getOldestActiveUnprotectedToolTags, getActiveToolTagsForAgeReclaim, getTriggerTagTokenUpperBound, getActiveTagTokenTotalsByMessage, tagTokenCountIsNull, backfillTagTokenCounts, insertTag, updateTagStatus, updateTagDropMode, updateCavemanDepth, updateTagMessageId, deleteTagsByMessageId, getMaxTagNumberBySession, getTagNumberByMessageId, deriveTagLoadFloor, getTagsBySession, getActiveTagsBySession, getTailHygieneTags, 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, connectionFileExists, 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, resolveMuralWire, 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, LKG_SNAPSHOT_ARRAY, LKG_SNAPSHOT_OBJECT, LKG_SNAPSHOT_KEY, LKG_SNAPSHOT_STRING, LKG_SNAPSHOT_NUMBER, LKG_SNAPSHOT_BOOLEAN, LKG_SNAPSHOT_NULL, LKG_SNAPSHOT_UNDEFINED, incrementalLkgContentDigests, lkgContentDigest, captureSlot, getSlot, dropSlot, noteEntry, getActiveCompartmentRun, markActiveCompartmentRunPublished, registerActiveCompartmentRun, startCompartmentAgent, isRecompFailure, isRecompSkip, isRecompComplete, extractRecompReason, contextualizeUpgradeReason, setRecompStarting, setRecompNote, setRecompTerminal, runManagedRecomp, runManagedUpgrade };