@cortexkit/opencode-magic-context 0.37.0 → 0.38.0

package/dist/{index-0ze9p983.js → index-mmvhrqqb.js}

@@ -2,7 +2,7 @@ import {
   deriveTriggerBudget,
   modelSupportsVision,
   shouldEnforcePrivateStoragePermissions
-} from "./index-q0t189ay.js";
+} from "./index-9zhhvr4w.js";
 import {
   parseProviderModel
 } from "./index-td9depx5.js";
@@ -14,6 +14,7 @@ import {
 import {
   buildToolArcs,
   buildTrueRawTokenIndex,
+  byteSize,
   clearCachedM0M1,
   clearCompressionDepth,
   clearCompressionDepthRange,
@@ -417,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();
@@ -444,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(" ");
@@ -569,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;
@@ -744,6 +765,51 @@ function readPsProcessCommand(pid) {
     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));
@@ -765,12 +831,12 @@ function isPidIdentityPlausible(record) {
 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;
@@ -837,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
       };
@@ -5687,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 {
@@ -5739,6 +5829,7 @@ 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) {
@@ -5764,6 +5855,14 @@ function inspectRpcServerDiscovery(storageDir) {
     const identity = liveness === "dead" ? "implausible" : isPidIdentityPlausible(record);
     if (liveness === "alive" && identity === "plausible") {
       pids.add(record.pid);
+      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 {
@@ -5779,7 +5878,12 @@ 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) {
@@ -5804,6 +5908,25 @@ function logInconclusiveMigrationProbes(dbPath, discovery, piProbeState) {
     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) {
@@ -5812,7 +5935,12 @@ function enforceMigrationOnOpenGuard(db, dbPath, dbDir, latestSupportedVersion)
   }
   const discovery = inspectRpcServerDiscovery(dbDir);
   const piDiscovery = inspectLivePiProcesses();
-  const piPids = piDiscovery.processIds;
+  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);
@@ -5823,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 } : {}
   };
@@ -5832,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) => `confirmed OpenCode server PID ${pid}`),
-      ...piPids.map((pid) => `confirmed Pi harness PID ${pid}`)
-    ];
-    log(`[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.`);
+    log(formatLiveProcessMigrationRefusal(dbPath, persistedVersion, latestSupportedVersion, discovery.serverPids, piPids));
   }
   return false;
 }
@@ -6994,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) {
@@ -8578,6 +8703,17 @@ function addMergedReasoningStrippedIds(db, sessionId, ids) {
   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;
@@ -8587,7 +8723,7 @@ function parseTrailingBlankDecisions(raw) {
       return new Map;
     const decisions = new Map;
     for (const [id, decision] of Object.entries(parsed)) {
-      if (id.length > 0 && (decision === "keep" || decision === "strip")) {
+      if (id.length > 0 && isPersistedTrailingBlankDecision(decision)) {
         decisions.set(id, decision);
       }
     }
@@ -8600,7 +8736,7 @@ 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) {
+function addTrailingBlankDecisions(db, sessionId, additions, options) {
   const add = [...additions];
   if (add.length === 0)
     return true;
@@ -8611,7 +8747,8 @@ function addTrailingBlankDecisions(db, sessionId, additions) {
     const current = parseTrailingBlankDecisions(rawStored);
     let changed = false;
     for (const [id, decision] of add) {
-      if (!current.has(id)) {
+      const currentDecision = current.get(id);
+      if (currentDecision === undefined || id === options?.overwriteMessageId && currentDecision !== decision) {
         current.set(id, decision);
         changed = true;
       }
@@ -9387,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;
@@ -9430,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 [];
@@ -9465,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) {
@@ -9495,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 {
@@ -9504,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
@@ -9658,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) {
@@ -9764,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) {
@@ -9794,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);
@@ -10184,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)}`);
@@ -10464,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 {
@@ -10875,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")
@@ -10902,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()) {
@@ -11169,9 +12406,9 @@ function parseUserMemoryRow(row) {
 }
 
 // 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;
@@ -11369,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
@@ -12344,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 = [`
@@ -12629,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);
@@ -13020,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";
@@ -27686,7 +28923,7 @@ 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."),
@@ -27741,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.")
@@ -28093,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";
@@ -28467,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(() => {
@@ -28476,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);
@@ -28508,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();
@@ -28521,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();
     });
   }
@@ -28545,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;
@@ -28569,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();
             }
           });
         });
@@ -28785,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,
@@ -28877,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();
           };
         }));
       }
@@ -28937,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,
@@ -29015,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,
@@ -29407,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
   };
 }
@@ -29464,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();
   }
@@ -29521,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 });
@@ -29542,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
       });
@@ -30020,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
@@ -30065,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);
@@ -30303,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))
@@ -30812,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));
     }
   }
 }
@@ -31017,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) {
@@ -31050,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() {
@@ -31754,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") {
@@ -31957,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;
@@ -31972,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;
@@ -32446,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) {
@@ -32629,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 {
@@ -32663,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) => ({
@@ -32690,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 });
@@ -32807,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;
@@ -32821,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()}`;
@@ -32863,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();
@@ -32892,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);
@@ -32906,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 };
     }
@@ -32914,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
@@ -33124,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));
@@ -33597,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";
@@ -33605,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)];
@@ -35925,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) {
@@ -35971,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;
@@ -36597,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 {
@@ -39018,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)
@@ -39436,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,
@@ -39466,7 +40703,7 @@ function resolveWrapupProtectedTailBoundary(args) {
     boundaryReason
   };
   return {
-    snapshot,
+    snapshot: snapshot2,
     rawMessagesAboveLastCompartment,
     anchorRawMessageCount,
     targetProtectedTailStart,
@@ -39485,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"
     ]);
   }
@@ -39537,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
@@ -42716,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;
@@ -42778,7 +44015,7 @@ 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");
@@ -43134,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, 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, 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, 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 };
+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 };