@cortexkit/opencode-magic-context 0.17.2 → 0.19.0

package/dist/index.js

@@ -11403,7 +11403,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -11664,7 +11664,7 @@ var formatMap, stringProcessor = (schema, ctx, _json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -15017,10 +15017,56 @@ var init_magic_context = __esm(() => {
   });
 });
 
-// src/shared/logger.ts
-import * as fs from "node:fs";
+// src/shared/harness.ts
+function getHarness() {
+  return currentHarness;
+}
+var currentHarness = "opencode";
+
+// src/shared/data-path.ts
 import * as os from "node:os";
 import * as path from "node:path";
+function getDataDir() {
+  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+}
+function getMagicContextTempDir(harness = getHarness()) {
+  return path.join(os.tmpdir(), harness, "magic-context");
+}
+function getMagicContextLogPath(harness = getHarness()) {
+  return path.join(getMagicContextTempDir(harness), "magic-context.log");
+}
+function getProjectMagicContextDir(directory) {
+  return path.join(directory, ".opencode", "magic-context");
+}
+function getProjectMagicContextHistorianDir(directory) {
+  return path.join(getProjectMagicContextDir(directory), "historian");
+}
+function getOpenCodeStorageDir() {
+  return path.join(getDataDir(), "opencode", "storage");
+}
+function getMagicContextStorageDir() {
+  return path.join(getDataDir(), "cortexkit", "magic-context");
+}
+function getLegacyOpenCodeMagicContextStorageDir() {
+  return path.join(getOpenCodeStorageDir(), "plugin", "magic-context");
+}
+function getCacheDir() {
+  return process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
+}
+var init_data_path = () => {};
+
+// src/shared/logger.ts
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+function ensureDir(filePath) {
+  const dir = path2.dirname(filePath);
+  if (dir === lastEnsuredDir)
+    return;
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    lastEnsuredDir = dir;
+  } catch {}
+}
 function flush() {
   if (flushTimer) {
     clearTimeout(flushTimer);
@@ -15031,6 +15077,8 @@ function flush() {
   const data = buffer.join("");
   buffer = [];
   try {
+    const logFile = getMagicContextLogPath();
+    ensureDir(logFile);
     fs.appendFileSync(logFile, data);
   } catch {}
 }
@@ -15061,9 +15109,9 @@ ${data.stack}` : ""}` : ` ${JSON.stringify(data)}`;
 function sessionLog(sessionId, message, data) {
   log(`[magic-context][${sessionId}] ${message}`, data);
 }
-var logFile, isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50;
+var isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50, lastEnsuredDir = null;
 var init_logger = __esm(() => {
-  logFile = path.join(os.tmpdir(), "magic-context.log");
+  init_data_path();
   buffer = [];
   if (!isTestEnv) {
     process.on("exit", flush);
@@ -15122,6 +15170,161 @@ var init_model_requirements = __esm(() => {
   };
 });
 
+// src/features/magic-context/overflow-detection.ts
+function extractErrorMessage(error51) {
+  if (!error51)
+    return "";
+  if (typeof error51 === "string")
+    return error51;
+  if (typeof error51 === "object") {
+    const obj = error51;
+    const nested = obj.error;
+    if (nested && typeof nested.message === "string" && nested.message.length > 0) {
+      return nested.message;
+    }
+  }
+  if (error51 instanceof Error)
+    return error51.message;
+  if (typeof error51 === "object") {
+    const obj = error51;
+    if (typeof obj.message === "string")
+      return obj.message;
+    if (typeof obj.responseBody === "string")
+      return obj.responseBody;
+    try {
+      return JSON.stringify(error51);
+    } catch {
+      return String(error51);
+    }
+  }
+  return String(error51);
+}
+function detectOverflow(error51) {
+  const message = extractErrorMessage(error51);
+  if (!message) {
+    return { isOverflow: false };
+  }
+  const hasStatus413 = /\b413\b/.test(message) && /(entity|payload|context|prompt)/i.test(message);
+  let matched;
+  for (const pattern of OVERFLOW_PATTERNS) {
+    if (pattern.test(message)) {
+      matched = pattern;
+      break;
+    }
+  }
+  if (!matched && !hasStatus413) {
+    return { isOverflow: false };
+  }
+  const reportedLimit = parseReportedLimit(message);
+  return {
+    isOverflow: true,
+    reportedLimit,
+    matchedPattern: matched?.source
+  };
+}
+function parseReportedLimit(message) {
+  if (!message)
+    return;
+  for (const pattern of LIMIT_EXTRACTION_PATTERNS) {
+    const match = message.match(pattern);
+    if (!match)
+      continue;
+    const raw = match[1];
+    if (!raw)
+      continue;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value))
+      continue;
+    if (value < MIN_PLAUSIBLE_LIMIT || value > MAX_PLAUSIBLE_LIMIT)
+      continue;
+    return value;
+  }
+  return;
+}
+var OVERFLOW_PATTERNS, LIMIT_EXTRACTION_PATTERNS, MIN_PLAUSIBLE_LIMIT = 1024, MAX_PLAUSIBLE_LIMIT = 1e7;
+var init_overflow_detection = __esm(() => {
+  OVERFLOW_PATTERNS = [
+    /prompt is too long/i,
+    /input is too long for requested model/i,
+    /exceeds the context window/i,
+    /input token count.*exceeds the maximum/i,
+    /maximum prompt length is \d+/i,
+    /reduce the length of the messages/i,
+    /maximum context length is \d+ tokens/i,
+    /exceeds the limit of \d+/i,
+    /exceeds the available context size/i,
+    /greater than the context length/i,
+    /context window exceeds limit/i,
+    /exceeded model token limit/i,
+    /context[_ ]length[_ ]exceeded/i,
+    /request entity too large/i,
+    /context length is only \d+ tokens/i,
+    /input length.*exceeds.*context length/i,
+    /prompt too long; exceeded (?:max )?context length/i,
+    /too large for model with \d+ maximum context length/i,
+    /model_context_window_exceeded/i,
+    /context size has been exceeded/i
+  ];
+  LIMIT_EXTRACTION_PATTERNS = [
+    /maximum prompt length is (\d+)/i,
+    /maximum context length is (\d+) tokens?/i,
+    /context length is only (\d+) tokens?/i,
+    /exceeds the limit of (\d+)/i,
+    /too large for model with (\d+) maximum context length/i,
+    /context size.*(\d+) tokens?/i,
+    /exceeds? the context length of (\d+)/i,
+    /max(?:imum)?.*context.*?(\d+)/i
+  ];
+});
+
+// src/shared/resolve-fallbacks.ts
+function resolveFallbackChain(agentName, userFallbacks) {
+  const userList = normalizeUserFallbacks(userFallbacks);
+  if (userList.length > 0) {
+    return dedupe(userList.filter(isValidModelSpec));
+  }
+  const builtin = getAgentFallbackModels(agentName);
+  if (!builtin || builtin.length === 0)
+    return [];
+  return dedupe(builtin.filter(isValidModelSpec));
+}
+function normalizeUserFallbacks(userFallbacks) {
+  if (!userFallbacks)
+    return [];
+  if (typeof userFallbacks === "string") {
+    const trimmed = userFallbacks.trim();
+    return trimmed ? [trimmed] : [];
+  }
+  return userFallbacks.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function isValidModelSpec(spec) {
+  const slash = spec.indexOf("/");
+  return slash > 0 && slash < spec.length - 1;
+}
+function dedupe(list) {
+  const seen = new Set;
+  const out = [];
+  for (const item of list) {
+    if (seen.has(item))
+      continue;
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+function parseProviderModel(spec) {
+  const slash = spec.indexOf("/");
+  if (slash < 1 || slash >= spec.length - 1)
+    return null;
+  return {
+    providerID: spec.slice(0, slash).trim(),
+    modelID: spec.slice(slash + 1).trim()
+  };
+}
+var init_resolve_fallbacks = __esm(() => {
+  init_model_requirements();
+});
+
 // src/shared/model-suggestion-retry.ts
 function extractMessage(error51) {
   if (typeof error51 === "string")
@@ -15177,6 +15380,9 @@ function parseModelSuggestion(error51) {
   };
 }
 async function promptWithTimeout(client, args, timeoutMs, signal) {
+  if (signal?.aborted) {
+    throw new Error("prompt aborted by external signal");
+  }
   const controller = new AbortController;
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   const onExternalAbort = () => controller.abort();
@@ -15199,16 +15405,39 @@ async function promptWithTimeout(client, args, timeoutMs, signal) {
     signal?.removeEventListener("abort", onExternalAbort);
   }
 }
-async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
-  const timeoutMs = options.timeoutMs ?? 300000;
+function isNonRetryable(error51, externalSignal) {
+  if (externalSignal?.aborted)
+    return true;
+  if (error51 instanceof Error) {
+    if (error51.name === "AbortError")
+      return true;
+    if (error51.message === "prompt aborted by external signal")
+      return true;
+    if (/^prompt timed out after \d+ms$/.test(error51.message))
+      return true;
+  }
+  if (detectOverflow(error51).isOverflow)
+    return true;
+  return false;
+}
+function shortErr(error51) {
+  if (error51 instanceof Error) {
+    return error51.name && error51.name !== "Error" ? `${error51.name}: ${error51.message}` : error51.message;
+  }
+  return extractMessage(error51);
+}
+async function attemptOnce(client, args, timeoutMs, signal, callContext, label) {
   try {
-    await promptWithTimeout(client, args, timeoutMs, options.signal);
+    await promptWithTimeout(client, args, timeoutMs, signal);
+    return;
   } catch (error51) {
+    if (isNonRetryable(error51, signal))
+      throw error51;
     const suggestion = parseModelSuggestion(error51);
     if (!suggestion || !args.body.model) {
       throw error51;
     }
-    log("[model-suggestion-retry] Model not found, retrying with suggestion", {
+    log(`[${callContext}] ${label}: model not found, retrying with suggestion`, {
       original: `${suggestion.providerID}/${suggestion.modelID}`,
       suggested: suggestion.suggestion
     });
@@ -15221,11 +15450,59 @@ async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
           modelID: suggestion.suggestion
         }
       }
-    }, timeoutMs, options.signal);
+    }, timeoutMs, signal);
+  }
+}
+async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 300000;
+  const callContext = options.callContext ?? "subagent";
+  const fallbacks = options.fallbackModels ?? [];
+  const explicitPrimaryLabel = args.body.model?.providerID && args.body.model.modelID ? `${args.body.model.providerID}/${args.body.model.modelID}` : "primary";
+  let lastError = null;
+  try {
+    await attemptOnce(client, args, timeoutMs, options.signal, callContext, explicitPrimaryLabel);
+    return;
+  } catch (error51) {
+    lastError = error51;
+    if (isNonRetryable(error51, options.signal))
+      throw error51;
+    if (fallbacks.length === 0) {
+      throw error51;
+    }
+    log(`[${callContext}] primary (${explicitPrimaryLabel}) failed: ${shortErr(error51)}; trying ${fallbacks.length} fallback(s)`);
+  }
+  for (let i = 0;i < fallbacks.length; i += 1) {
+    const parsed = parseProviderModel(fallbacks[i]);
+    if (!parsed) {
+      log(`[${callContext}] skipping invalid fallback spec: ${fallbacks[i]}`);
+      continue;
+    }
+    const label = `${parsed.providerID}/${parsed.modelID}`;
+    const attemptArgs = {
+      ...args,
+      body: { ...args.body, model: parsed }
+    };
+    try {
+      await attemptOnce(client, attemptArgs, timeoutMs, options.signal, callContext, label);
+      log(`[${callContext}] fallback succeeded with ${label} (attempt ${i + 2}/${fallbacks.length + 1})`);
+      return;
+    } catch (error51) {
+      lastError = error51;
+      if (isNonRetryable(error51, options.signal))
+        throw error51;
+      const remaining = fallbacks.length - i - 1;
+      if (remaining > 0) {
+        log(`[${callContext}] ${label} failed: ${shortErr(error51)}; ${remaining} fallback(s) left`);
+      }
+    }
   }
+  log(`[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks].join(", ")}; last error: ${shortErr(lastError)}`);
+  throw lastError ?? new Error("All fallback models failed");
 }
 var init_model_suggestion_retry = __esm(() => {
+  init_overflow_detection();
   init_logger();
+  init_resolve_fallbacks();
 });
 
 // src/shared/normalize-sdk-response.ts
@@ -15257,6 +15534,7 @@ var init_shared = __esm(() => {
   init_logger();
   init_model_requirements();
   init_model_suggestion_retry();
+  init_resolve_fallbacks();
 });
 
 // src/shared/record-type-guard.ts
@@ -147908,21 +148186,36 @@ var init_read_session_formatting = __esm(() => {
   tokenizer = new src_default(exports_claude);
 });
 
+// src/shared/stable-json.ts
+function stableStringify(value, seen = new WeakSet) {
+  if (value === undefined)
+    return "undefined";
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value) ?? String(value);
+  if (seen.has(value))
+    return '"[Circular]"';
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(([a], [b]) => {
+    if (a < b)
+      return -1;
+    if (a > b)
+      return 1;
+    return 0;
+  });
+  return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child, seen)}`).join(",")}}`;
+}
+
 // src/features/magic-context/tool-definition-tokens.ts
+import { createHash } from "node:crypto";
 function keyFor(providerID, modelID, agentName) {
   const agent = agentName && agentName.length > 0 ? agentName : "default";
   return `${providerID}/${modelID}/${agent}`;
 }
 function fingerprintFor(description, parameters) {
-  const descLen = description.length;
-  if (parameters === undefined)
-    return `${descLen}:none`;
-  if (parameters === null)
-    return `${descLen}:null`;
-  if (typeof parameters !== "object")
-    return `${descLen}:${typeof parameters}`;
-  const keys = Object.keys(parameters);
-  return `${descLen}:obj:${keys.length}:${keys.sort().join(",")}`;
+  return createHash("sha256").update(description).update("\x00").update(stableStringify(parameters)).digest("hex");
 }
 function setDatabase(db) {
   persistenceDb = db;
@@ -155760,12 +156053,6 @@ var require_src2 = __commonJS((exports, module) => {
   };
 });
 
-// src/shared/harness.ts
-function getHarness() {
-  return currentHarness;
-}
-var currentHarness = "opencode";
-
 // src/features/magic-context/compartment-storage.ts
 function getInsertCompartmentStatement(db) {
   let stmt = insertCompartmentStatements.get(db);
@@ -155839,6 +156126,10 @@ function getLastCompartmentEndMessage(db, sessionId) {
   const row = db.prepare("SELECT MAX(end_message) as max_end FROM compartments WHERE session_id = ?").get(sessionId);
   return row?.max_end ?? -1;
 }
+function getCompartmentsByEndMessageId(db, sessionId, endMessageId) {
+  const rows = db.prepare("SELECT * FROM compartments WHERE session_id = ? AND end_message_id = ? ORDER BY sequence ASC").all(sessionId, endMessageId).filter(isCompartmentRow);
+  return rows.map(toCompartment);
+}
 function appendCompartments(db, sessionId, compartments) {
   if (compartments.length === 0)
     return;
@@ -156342,7 +156633,7 @@ var init_compartment_prompt = __esm(() => {
 });
 
 // src/shared/opencode-config-dir.ts
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { join as join7, resolve as resolve3 } from "node:path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
@@ -156350,9 +156641,9 @@ function getCliConfigDir() {
     return resolve3(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join7(homedir5(), ".config", "opencode");
+    return join7(homedir6(), ".config", "opencode");
   }
-  return join7(process.env.XDG_CONFIG_HOME || join7(homedir5(), ".config"), "opencode");
+  return join7(process.env.XDG_CONFIG_HOME || join7(homedir6(), ".config"), "opencode");
 }
 function getOpenCodeConfigDir(_options) {
   return getCliConfigDir();
@@ -156583,11 +156874,11 @@ __export(exports_conflict_warning_hook, {
   cleanupConflictWarnings: () => cleanupConflictWarnings
 });
 import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
-import { homedir as homedir6, platform as platform2 } from "node:os";
+import { homedir as homedir7, platform as platform2 } from "node:os";
 import { join as join9 } from "node:path";
 function getDesktopStatePath() {
   const os2 = platform2();
-  const home = homedir6();
+  const home = homedir7();
   if (os2 === "darwin") {
     return join9(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
@@ -156866,26 +157157,6 @@ var init_conflict_warning_hook = __esm(() => {
   cachedDesktopStateByDir = new Map;
 });
 
-// src/shared/data-path.ts
-import * as os2 from "node:os";
-import * as path2 from "node:path";
-function getDataDir() {
-  return process.env.XDG_DATA_HOME ?? path2.join(os2.homedir(), ".local", "share");
-}
-function getOpenCodeStorageDir() {
-  return path2.join(getDataDir(), "opencode", "storage");
-}
-function getMagicContextStorageDir() {
-  return path2.join(getDataDir(), "cortexkit", "magic-context");
-}
-function getLegacyOpenCodeMagicContextStorageDir() {
-  return path2.join(getOpenCodeStorageDir(), "plugin", "magic-context");
-}
-function getCacheDir() {
-  return process.env.XDG_CACHE_HOME ?? path2.join(os2.homedir(), ".cache");
-}
-var init_data_path = () => {};
-
 // src/shared/error-message.ts
 function getErrorMessage(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
@@ -157143,7 +157414,7 @@ var exports_native_binding = {};
 __export(exports_native_binding, {
   resolveBetterSqliteNativeBinding: () => resolveBetterSqliteNativeBinding
 });
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { createRequire } from "node:module";
 import * as path3 from "node:path";
 function logInfo(message) {
@@ -157243,7 +157514,7 @@ async function resolveBetterSqliteNativeBinding() {
       }
       logWarn(`cached binary at ${cachedPath} has wrong ABI (${cachedProbe.actual ?? "unknown"} != ${expected}); refetching`);
     }
-    mkdirSync2(path3.dirname(cachedPath), { recursive: true });
+    mkdirSync3(path3.dirname(cachedPath), { recursive: true });
     const nodeFileBytes = await downloadElectronPrebuild(pkgVersion, expected);
     writeFileSync4(cachedPath, nodeFileBytes);
     logInfo(`cached Electron prebuild at ${cachedPath} (${(nodeFileBytes.length / 1024).toFixed(1)} KB)`);
@@ -157421,13 +157692,13 @@ var init_embedding_cache = __esm(() => {
 });
 
 // src/features/magic-context/memory/normalize-hash.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function normalizeMemoryContent(content) {
   return content.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function computeNormalizedHash(content) {
   const normalized = normalizeMemoryContent(content);
-  return createHash("md5").update(normalized).digest("hex");
+  return createHash2("md5").update(normalized).digest("hex");
 }
 var init_normalize_hash = () => {};
 
@@ -158021,9 +158292,9 @@ __export(exports_read_session_db, {
   findLastAssistantModelFromOpenCodeDb: () => findLastAssistantModelFromOpenCodeDb,
   closeReadOnlySessionDb: () => closeReadOnlySessionDb
 });
-import { join as join12 } from "node:path";
+import { join as join11 } from "node:path";
 function getOpenCodeDbPath() {
-  return join12(getDataDir(), "opencode", "opencode.db");
+  return join11(getDataDir(), "opencode", "opencode.db");
 }
 function closeCachedReadOnlyDb() {
   if (!cachedReadOnlyDb) {
@@ -158130,10 +158401,36 @@ function cosineSimilarity(a, b) {
   return denominator === 0 ? 0 : dotProduct / denominator;
 }
 
+// src/features/magic-context/memory/embedding-identity.ts
+function normalizeEndpoint(endpoint) {
+  return endpoint?.trim().replace(/\/+$/, "") ?? "";
+}
+function getEmbeddingProviderIdentity(config2) {
+  if (config2.provider === "off") {
+    return "embedding-provider:off";
+  }
+  const identityInput = config2.provider === "openai-compatible" ? {
+    provider: "openai-compatible",
+    model: config2.model.trim(),
+    endpoint: normalizeEndpoint(config2.endpoint),
+    apiKeyPresent: Boolean(config2.api_key?.trim())
+  } : {
+    provider: "local",
+    model: config2.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
+    endpoint: "",
+    apiKeyPresent: false
+  };
+  return `embedding-provider:${computeNormalizedHash(JSON.stringify(identityInput))}`;
+}
+var init_embedding_identity = __esm(() => {
+  init_magic_context();
+  init_normalize_hash();
+});
+
 // src/features/magic-context/memory/embedding-local.ts
-import { mkdirSync as mkdirSync3 } from "node:fs";
+import { mkdirSync as mkdirSync4 } from "node:fs";
 import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { join as join13 } from "node:path";
 async function acquireModelLoadLock(lockPath) {
   const waitStart = Date.now();
   while (true) {
@@ -158248,7 +158545,7 @@ class LocalEmbeddingProvider {
   initPromise = null;
   constructor(model = DEFAULT_LOCAL_EMBEDDING_MODEL) {
     this.model = model;
-    this.modelId = `local:${model}`;
+    this.modelId = getEmbeddingProviderIdentity({ provider: "local", model });
   }
   async initialize() {
     if (this.pipeline) {
@@ -158267,15 +158564,15 @@ class LocalEmbeddingProvider {
         if (LogLevel && "ERROR" in LogLevel) {
           env.logLevel = LogLevel.ERROR;
         }
-        const modelCacheDir = join14(getMagicContextStorageDir(), "models");
+        const modelCacheDir = join13(getMagicContextStorageDir(), "models");
         try {
-          mkdirSync3(modelCacheDir, { recursive: true });
+          mkdirSync4(modelCacheDir, { recursive: true });
           env.cacheDir = modelCacheDir;
         } catch {
           log("[magic-context] could not create model cache dir, using library default");
         }
         const createPipeline = transformersModule.pipeline;
-        const lockPath = join14(modelCacheDir, ".load.lock");
+        const lockPath = join13(modelCacheDir, ".load.lock");
         const releaseLock = await acquireModelLoadLock(lockPath);
         const stopHeartbeat = startLockHeartbeat(lockPath);
         try {
@@ -158390,12 +158687,13 @@ var init_embedding_local = __esm(() => {
   init_magic_context();
   init_data_path();
   init_logger();
+  init_embedding_identity();
   STALE_LOCK_MS = 3 * 60000;
   MAX_LOCK_WAIT_MS = 5 * 60000;
 });
 
 // src/features/magic-context/memory/embedding-openai.ts
-function normalizeEndpoint(endpoint) {
+function normalizeEndpoint2(endpoint) {
   return endpoint?.trim().replace(/\/+$/, "") ?? "";
 }
 
@@ -158410,10 +158708,15 @@ class OpenAICompatibleEmbeddingProvider {
   openLogged = false;
   halfOpenProbeInFlight = false;
   constructor(options) {
-    this.endpoint = normalizeEndpoint(options.endpoint);
+    this.endpoint = normalizeEndpoint2(options.endpoint);
     this.model = options.model?.trim() ?? "";
     this.apiKey = options.apiKey?.trim() ?? "";
-    this.modelId = `openai-compat:${this.endpoint}:${this.model}`;
+    this.modelId = getEmbeddingProviderIdentity({
+      provider: "openai-compatible",
+      endpoint: this.endpoint,
+      model: this.model,
+      ...this.apiKey ? { api_key: this.apiKey } : {}
+    });
   }
   async initialize() {
     if (this.initialized)
@@ -158595,6 +158898,7 @@ class OpenAICompatibleEmbeddingProvider {
 var FAILURE_THRESHOLD = 3, FAILURE_WINDOW_MS = 60000, OPEN_DURATION_MS, FETCH_TIMEOUT_MS = 30000;
 var init_embedding_openai = __esm(() => {
   init_logger();
+  init_embedding_identity();
   OPEN_DURATION_MS = 5 * 60000;
 });
 
@@ -158632,17 +158936,8 @@ function resolveEmbeddingConfig(config2) {
   }
   return { provider: "off" };
 }
-function resolveModelId(config2) {
-  if (config2.provider === "off") {
-    return "off";
-  }
-  if (config2.provider === "openai-compatible") {
-    const endpoint = config2.endpoint.trim();
-    const model = config2.model.trim();
-    const keyHash = config2.api_key ? computeNormalizedHash(config2.api_key) : "nokey";
-    return `openai-compat:${endpoint}:${model}:${keyHash}`;
-  }
-  return config2.model.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL;
+function resolveProviderIdentity(config2) {
+  return getEmbeddingProviderIdentity(config2);
 }
 function createProvider(config2) {
   if (config2.provider === "off") {
@@ -158666,10 +158961,10 @@ function getOrCreateProvider() {
 }
 function initializeEmbedding(config2) {
   const nextConfig = resolveEmbeddingConfig(config2);
-  const nextModelId = resolveModelId(nextConfig);
+  const nextProviderIdentity = resolveProviderIdentity(nextConfig);
   const previousProvider = provider;
-  const previousModelId = previousProvider?.modelId ?? resolveModelId(embeddingConfig);
-  if (previousModelId === nextModelId) {
+  const previousProviderIdentity = previousProvider?.modelId ?? resolveProviderIdentity(embeddingConfig);
+  if (previousProviderIdentity === nextProviderIdentity) {
     embeddingConfig = nextConfig;
     return;
   }
@@ -158796,9 +159091,9 @@ var DEFAULT_EMBEDDING_CONFIG, embeddingConfig, provider = null, loadUnembeddedMe
 var init_embedding = __esm(() => {
   init_magic_context();
   init_logger();
+  init_embedding_identity();
   init_embedding_local();
   init_embedding_openai();
-  init_normalize_hash();
   init_storage_memory_embeddings();
   DEFAULT_EMBEDDING_CONFIG = {
     provider: "local",
@@ -158845,7 +159140,7 @@ var init_storage_memory_fts = __esm(() => {
 
 // src/features/magic-context/memory/project-identity.ts
 import { execSync } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import path4 from "node:path";
 function getRootCommitHash(directory) {
   try {
@@ -158864,7 +159159,7 @@ function getRootCommitHash(directory) {
 }
 function directoryFallback(directory) {
   const canonical = path4.resolve(directory);
-  const hash2 = createHash2("md5").update(canonical).digest("hex").slice(0, 12);
+  const hash2 = createHash3("md5").update(canonical).digest("hex").slice(0, 12);
   return `dir:${hash2}`;
 }
 function resolveProjectIdentity(directory) {
@@ -159914,6 +160209,9 @@ var init_migrations = __esm(async () => {
                     embedding BLOB NOT NULL,
                     model_id TEXT NOT NULL,
                     created_at INTEGER NOT NULL,
+                    -- FK-cascade audit (v12): git_commit_embeddings.sha -> git_commits.sha
+                    -- uses ON DELETE CASCADE, so SQLite PRAGMA foreign_keys must be ON on
+                    -- every connection and v12 cleans historical orphan rows.
                     FOREIGN KEY(sha) REFERENCES git_commits(sha) ON DELETE CASCADE
                 );
 
@@ -160034,15 +160332,57 @@ var init_migrations = __esm(async () => {
                 WHERE type = 'tool' AND tool_owner_message_id IS NULL;
             `);
       }
+    },
+    {
+      version: 11,
+      description: "Add todo state synthesis columns to session_meta",
+      up: (db) => {
+        const cols = db.prepare("PRAGMA table_info(session_meta)").all();
+        if (!cols.some((c) => c.name === "last_todo_state")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN last_todo_state TEXT DEFAULT ''");
+        }
+        if (!cols.some((c) => c.name === "todo_synthetic_call_id")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN todo_synthetic_call_id TEXT DEFAULT ''");
+        }
+        if (!cols.some((c) => c.name === "todo_synthetic_anchor_message_id")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN todo_synthetic_anchor_message_id TEXT DEFAULT ''");
+        }
+        if (!cols.some((c) => c.name === "todo_synthetic_state_json")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN todo_synthetic_state_json TEXT DEFAULT ''");
+        }
+      }
+    },
+    {
+      version: 12,
+      description: "Clean orphan rows from FK-cascade embedding tables",
+      up: (db) => {
+        const hasTable = (name2) => Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name2));
+        const memoryEmbeddings = hasTable("memory_embeddings") ? db.prepare(`DELETE FROM memory_embeddings
+                           WHERE memory_id NOT IN (SELECT id FROM memories)`).run().changes : 0;
+        log(`[migrations] v12 cleaned ${memoryEmbeddings} orphan memory_embeddings row(s)`);
+        const gitCommitEmbeddings = hasTable("git_commit_embeddings") ? db.prepare(`DELETE FROM git_commit_embeddings
+                           WHERE sha NOT IN (SELECT sha FROM git_commits)`).run().changes : 0;
+        log(`[migrations] v12 cleaned ${gitCommitEmbeddings} orphan git_commit_embeddings row(s)`);
+      }
+    },
+    {
+      version: 13,
+      description: "Add pending_compaction_marker_state column for deferred marker drain",
+      up: (db) => {
+        const cols = db.prepare("PRAGMA table_info(session_meta)").all();
+        if (!cols.some((c) => c.name === "pending_compaction_marker_state")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN pending_compaction_marker_state TEXT");
+        }
+      }
     }
   ];
 });
 
 // src/features/magic-context/tool-owner-backfill.ts
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join14 } from "node:path";
 function resolveOpencodeDbPath() {
-  return join15(getDataDir(), "opencode", "opencode.db");
+  return join14(getDataDir(), "opencode", "opencode.db");
 }
 function ensureBackfillStateTable(db) {
   db.exec(`
@@ -160287,24 +160627,24 @@ var init_tool_owner_backfill = __esm(() => {
 });
 
 // src/features/magic-context/storage-db.ts
-import { copyFileSync, cpSync, existsSync as existsSync11, mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join16 } from "node:path";
+import { copyFileSync, cpSync, existsSync as existsSync11, mkdirSync as mkdirSync5 } from "node:fs";
+import { join as join15 } from "node:path";
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join16(dbDir, "context.db") };
+  return { dbDir, dbPath: join15(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   if (existsSync11(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join16(legacyDir, "context.db");
+  const legacyDbPath = join15(legacyDir, "context.db");
   if (!existsSync11(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
-  mkdirSync4(targetDbDir, { recursive: true });
+  mkdirSync5(targetDbDir, { recursive: true });
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
-    const dst = join16(targetDbDir, `context.db${suffix}`);
+    const dst = join15(targetDbDir, `context.db${suffix}`);
     if (existsSync11(src)) {
       try {
         copyFileSync(src, dst);
@@ -160313,8 +160653,8 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join16(legacyDir, "models");
-  const targetModelsDir = join16(targetDbDir, "models");
+  const legacyModelsDir = join15(legacyDir, "models");
+  const targetModelsDir = join15(targetDbDir, "models");
   if (existsSync11(legacyModelsDir) && !existsSync11(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
@@ -160324,9 +160664,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
 }
 function initializeDatabase(db) {
+  db.exec("PRAGMA foreign_keys=ON");
   db.exec("PRAGMA journal_mode=WAL");
   db.exec("PRAGMA busy_timeout=5000");
-  db.exec("PRAGMA foreign_keys=ON");
   db.exec(`
     CREATE TABLE IF NOT EXISTS tags (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -160424,6 +160764,9 @@ function initializeDatabase(db) {
     );
 
     CREATE TABLE IF NOT EXISTS memory_embeddings (
+      -- FK-cascade audit (v12): memory_embeddings.memory_id -> memories.id
+      -- uses ON DELETE CASCADE, so SQLite PRAGMA foreign_keys must be ON on
+      -- every connection and v12 cleans historical orphan rows.
       memory_id INTEGER PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
       embedding BLOB NOT NULL,
       model_id TEXT
@@ -160516,6 +160859,10 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       note_nudge_trigger_message_id TEXT DEFAULT '',
       note_nudge_sticky_text TEXT DEFAULT '',
       note_nudge_sticky_message_id TEXT DEFAULT '',
+      last_todo_state TEXT DEFAULT '',
+      todo_synthetic_call_id TEXT DEFAULT '',
+      todo_synthetic_anchor_message_id TEXT DEFAULT '',
+      todo_synthetic_state_json TEXT DEFAULT '',
       is_subagent INTEGER DEFAULT 0,
       last_context_percentage REAL DEFAULT 0,
       last_input_tokens INTEGER DEFAULT 0,
@@ -160527,7 +160874,13 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       system_prompt_hash TEXT DEFAULT '',
       memory_block_cache TEXT DEFAULT '',
       memory_block_count INTEGER DEFAULT 0,
-      memory_block_ids TEXT DEFAULT ''
+      memory_block_ids TEXT DEFAULT '',
+      -- pending_compaction_marker_state: intentionally NULLABLE without a
+      -- default. Absence of a deferred marker is SQL NULL; presence is a
+      -- valid JSON blob written via setPendingCompactionMarkerState.
+      -- Excluded from healNullTextColumns. Readers filter IS NOT NULL AND
+      -- != empty-string defensively. Plan v6 section 3.
+      pending_compaction_marker_state TEXT
     );
 
     CREATE INDEX IF NOT EXISTS idx_tags_session_tag_number ON tags(session_id, tag_number);
@@ -160580,6 +160933,10 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "note_nudge_trigger_message_id", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "note_nudge_sticky_text", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "note_nudge_sticky_message_id", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "last_todo_state", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "todo_synthetic_call_id", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "todo_synthetic_anchor_message_id", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "todo_synthetic_state_json", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "note_last_read_at", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "times_execute_threshold_reached", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "compartment_in_progress", "INTEGER DEFAULT 0");
@@ -160611,6 +160968,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "recomp_partial_range_end", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "detected_context_limit", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "needs_emergency_recovery", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "pending_compaction_marker_state", "TEXT");
   ensureColumn(db, "tags", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "pending_ops", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "source_contents", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
@@ -160644,6 +161002,10 @@ function healNullTextColumns(db) {
     ["note_nudge_trigger_message_id", ""],
     ["note_nudge_sticky_text", ""],
     ["note_nudge_sticky_message_id", ""],
+    ["last_todo_state", ""],
+    ["todo_synthetic_call_id", ""],
+    ["todo_synthetic_anchor_message_id", ""],
+    ["todo_synthetic_state_json", ""],
     ["system_prompt_hash", ""],
     ["stripped_placeholder_ids", ""],
     ["memory_block_cache", ""],
@@ -160696,7 +161058,7 @@ function openDatabase() {
   }
   try {
     migrateLegacyStorageIfNeeded(dbPath, dbDir);
-    mkdirSync4(dbDir, { recursive: true });
+    mkdirSync5(dbDir, { recursive: true });
     const db = new Database(dbPath);
     initializeDatabase(db);
     runMigrations(db);
@@ -160749,7 +161111,7 @@ function isSessionMetaRow(row) {
   if (row === null || typeof row !== "object")
     return false;
   const r = row;
-  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && isStringOrNull(r.cache_ttl) && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && isStringOrNull(r.last_nudge_band) && isStringOrNull(r.last_transform_error) && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && isNumberOrNull(r.times_execute_threshold_reached) && isNumberOrNull(r.compartment_in_progress) && (r.system_prompt_hash === null || typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number") && isNumberOrNull(r.system_prompt_tokens) && isNumberOrNull(r.conversation_tokens) && isNumberOrNull(r.tool_call_tokens) && isNumberOrNull(r.cleared_reasoning_through_tag);
+  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && isStringOrNull(r.cache_ttl) && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && isStringOrNull(r.last_nudge_band) && isStringOrNull(r.last_transform_error) && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && isNumberOrNull(r.times_execute_threshold_reached) && isNumberOrNull(r.compartment_in_progress) && (r.system_prompt_hash === null || typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number") && isNumberOrNull(r.system_prompt_tokens) && isNumberOrNull(r.conversation_tokens) && isNumberOrNull(r.tool_call_tokens) && isNumberOrNull(r.cleared_reasoning_through_tag) && isStringOrNull(r.last_todo_state);
 }
 function getDefaultSessionMeta(sessionId) {
   return {
@@ -160769,7 +161131,8 @@ function getDefaultSessionMeta(sessionId) {
     systemPromptTokens: 0,
     conversationTokens: 0,
     toolCallTokens: 0,
-    clearedReasoningThroughTag: 0
+    clearedReasoningThroughTag: 0,
+    lastTodoState: ""
   };
 }
 function ensureSessionMetaRow(db, sessionId) {
@@ -160781,6 +161144,7 @@ function toSessionMeta(row) {
   const transformErrorRaw = typeof row.last_transform_error === "string" ? row.last_transform_error : "";
   const cacheTtlRaw = typeof row.cache_ttl === "string" && row.cache_ttl.length > 0 ? row.cache_ttl : "5m";
   const systemPromptHashRaw = row.system_prompt_hash == null ? "" : row.system_prompt_hash;
+  const lastTodoStateRaw = typeof row.last_todo_state === "string" ? row.last_todo_state : "";
   const numOrZero = (value) => typeof value === "number" ? value : 0;
   return {
     sessionId: row.session_id,
@@ -160799,7 +161163,8 @@ function toSessionMeta(row) {
     systemPromptTokens: numOrZero(row.system_prompt_tokens),
     conversationTokens: numOrZero(row.conversation_tokens),
     toolCallTokens: numOrZero(row.tool_call_tokens),
-    clearedReasoningThroughTag: numOrZero(row.cleared_reasoning_through_tag)
+    clearedReasoningThroughTag: numOrZero(row.cleared_reasoning_through_tag),
+    lastTodoState: lastTodoStateRaw
   };
 }
 var META_COLUMNS, BOOLEAN_META_KEYS;
@@ -160820,7 +161185,8 @@ var init_storage_meta_shared = __esm(() => {
     systemPromptTokens: "system_prompt_tokens",
     conversationTokens: "conversation_tokens",
     toolCallTokens: "tool_call_tokens",
-    clearedReasoningThroughTag: "cleared_reasoning_through_tag"
+    clearedReasoningThroughTag: "cleared_reasoning_through_tag",
+    lastTodoState: "last_todo_state"
   };
   BOOLEAN_META_KEYS = new Set(["isSubagent", "compartmentInProgress"]);
 });
@@ -160856,6 +161222,12 @@ function isPersistedNoteNudgeRow(row) {
   const r = row;
   return typeof r.note_nudge_trigger_pending === "number" && typeof r.note_nudge_trigger_message_id === "string" && typeof r.note_nudge_sticky_text === "string" && typeof r.note_nudge_sticky_message_id === "string";
 }
+function isPersistedTodoSyntheticAnchorRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.todo_synthetic_call_id === "string" && typeof r.todo_synthetic_anchor_message_id === "string" && typeof r.todo_synthetic_state_json === "string";
+}
 function isPersistedHistorianFailureRow(row) {
   if (row === null || typeof row !== "object")
     return false;
@@ -160978,6 +161350,29 @@ function setPersistedDeliveredNoteNudge(db, sessionId, text, messageId = "") {
 function clearPersistedNoteNudge(db, sessionId) {
   db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 0, note_nudge_trigger_message_id = '', note_nudge_sticky_text = '', note_nudge_sticky_message_id = '' WHERE session_id = ?").run(sessionId);
 }
+function getPersistedTodoSyntheticAnchor(db, sessionId) {
+  const result = db.prepare("SELECT todo_synthetic_call_id, todo_synthetic_anchor_message_id, todo_synthetic_state_json FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!isPersistedTodoSyntheticAnchorRow(result)) {
+    return null;
+  }
+  if (result.todo_synthetic_call_id.length === 0 || result.todo_synthetic_anchor_message_id.length === 0) {
+    return null;
+  }
+  return {
+    callId: result.todo_synthetic_call_id,
+    messageId: result.todo_synthetic_anchor_message_id,
+    stateJson: result.todo_synthetic_state_json
+  };
+}
+function setPersistedTodoSyntheticAnchor(db, sessionId, callId, messageId, stateJson) {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET todo_synthetic_call_id = ?, todo_synthetic_anchor_message_id = ?, todo_synthetic_state_json = ? WHERE session_id = ?").run(callId, messageId, stateJson, sessionId);
+  })();
+}
+function clearPersistedTodoSyntheticAnchor(db, sessionId) {
+  db.prepare("UPDATE session_meta SET todo_synthetic_call_id = '', todo_synthetic_anchor_message_id = '', todo_synthetic_state_json = '' WHERE session_id = ?").run(sessionId);
+}
 function getNoteLastReadAt(db, sessionId) {
   try {
     const result = db.prepare("SELECT note_last_read_at FROM session_meta WHERE session_id = ?").get(sessionId);
@@ -161104,6 +161499,39 @@ function removeStrippedPlaceholderId(db, sessionId, messageId) {
   setStrippedPlaceholderIds(db, sessionId, ids);
   return true;
 }
+function isPendingCompactionMarker(value) {
+  return typeof value === "object" && value !== null && typeof value.ordinal === "number" && typeof value.endMessageId === "string" && typeof value.publishedAt === "number";
+}
+function getPendingCompactionMarkerState(db, sessionId) {
+  const row = db.prepare("SELECT pending_compaction_marker_state FROM session_meta WHERE session_id = ?").get(sessionId);
+  const raw = row?.pending_compaction_marker_state;
+  if (raw === null || raw === undefined || raw === "")
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (isPendingCompactionMarker(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+function setPendingCompactionMarkerState(db, sessionId, state) {
+  ensureSessionMetaRow(db, sessionId);
+  const blob = state ? stableStringify(state) : null;
+  db.prepare("UPDATE session_meta SET pending_compaction_marker_state = ? WHERE session_id = ?").run(blob, sessionId);
+}
+function clearPendingCompactionMarkerStateIf(db, sessionId, expected) {
+  const expectedBlob = stableStringify(expected);
+  const result = db.prepare(`UPDATE session_meta SET pending_compaction_marker_state = NULL
+             WHERE session_id = ? AND pending_compaction_marker_state = ?`).run(sessionId, expectedBlob);
+  return result.changes > 0;
+}
+function getSessionsWithPendingMarker(db) {
+  const rows = db.prepare(`SELECT session_id FROM session_meta
+             WHERE pending_compaction_marker_state IS NOT NULL
+               AND pending_compaction_marker_state != ''`).all();
+  return rows.map((r) => r.session_id);
+}
 var init_storage_meta_persisted = __esm(() => {
   init_logger();
   init_storage_meta_shared();
@@ -161130,7 +161558,7 @@ var init_resolve_subagent_fallback = __esm(async () => {
 
 // src/features/magic-context/storage-meta-session.ts
 function getOrCreateSessionMeta(db, sessionId) {
-  const result = db.prepare("SELECT session_id, last_response_time, cache_ttl, counter, last_nudge_tokens, last_nudge_band, last_transform_error, is_subagent, last_context_percentage, last_input_tokens, times_execute_threshold_reached, compartment_in_progress, system_prompt_hash, system_prompt_tokens, conversation_tokens, tool_call_tokens, cleared_reasoning_through_tag FROM session_meta WHERE session_id = ?").get(sessionId);
+  const result = db.prepare("SELECT session_id, last_response_time, cache_ttl, counter, last_nudge_tokens, last_nudge_band, last_transform_error, is_subagent, last_context_percentage, last_input_tokens, times_execute_threshold_reached, compartment_in_progress, system_prompt_hash, system_prompt_tokens, conversation_tokens, tool_call_tokens, cleared_reasoning_through_tag, last_todo_state FROM session_meta WHERE session_id = ?").get(sessionId);
   if (isSessionMetaRow(result)) {
     return toSessionMeta(result);
   }
@@ -161631,12 +162059,12 @@ var init_storage = __esm(async () => {
 });
 
 // src/shared/models-dev-cache.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
 import { homedir as homedir8, platform as platform3 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join16 } from "node:path";
 function hashFast(input) {
-  return createHash3("sha1").update(input).digest("hex");
+  return createHash4("sha1").update(input).digest("hex");
 }
 function getModelsJsonPath() {
   const explicit = process.env.OPENCODE_MODELS_PATH?.trim();
@@ -161645,15 +162073,15 @@ function getModelsJsonPath() {
   const cacheBase = getCacheDir();
   const source = process.env.OPENCODE_MODELS_URL?.trim();
   const filename = source && source !== "https://models.dev" ? `models-${hashFast(source)}.json` : "models.json";
-  return join17(cacheBase, "opencode", filename);
+  return join16(cacheBase, "opencode", filename);
 }
 function getOpencodeConfigPath() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  const configDir = envDir ? envDir : platform3() === "win32" ? join17(homedir8(), ".config", "opencode") : join17(process.env.XDG_CONFIG_HOME || join17(homedir8(), ".config"), "opencode");
-  const jsonc = join17(configDir, "opencode.jsonc");
+  const configDir = envDir ? envDir : platform3() === "win32" ? join16(homedir8(), ".config", "opencode") : join16(process.env.XDG_CONFIG_HOME || join16(homedir8(), ".config"), "opencode");
+  const jsonc = join16(configDir, "opencode.jsonc");
   if (existsSync12(jsonc))
     return jsonc;
-  const json2 = join17(configDir, "opencode.json");
+  const json2 = join16(configDir, "opencode.json");
   if (existsSync12(json2))
     return json2;
   return null;
@@ -161704,9 +162132,7 @@ function loadModelsDevMetadataFromFile() {
   try {
     const configPath = getOpencodeConfigPath();
     if (configPath && existsSync12(configPath)) {
-      let raw = readFileSync8(configPath, "utf-8");
-      raw = raw.replace(/"(?:[^"\\]|\\.)*"|\/\/.*$/gm, (match) => match.startsWith('"') ? match : "");
-      const config2 = JSON.parse(raw);
+      const config2 = parseJsonc(readFileSync8(configPath, "utf-8"));
       if (config2.provider && typeof config2.provider === "object") {
         for (const [providerId, provider2] of Object.entries(config2.provider)) {
           if (!provider2?.models || typeof provider2.models !== "object")
@@ -161778,6 +162204,7 @@ function getModelsDevContextLimit(providerID, modelID) {
 var RELOAD_INTERVAL_MS, apiCache = null, apiLoadedAt = 0, recentlySeenApiSizes, oscillationLogged = false, fileCache = null, fileLastAttempt = 0;
 var init_models_dev_cache = __esm(() => {
   init_data_path();
+  init_jsonc_parser();
   init_logger();
   RELOAD_INTERVAL_MS = 5 * 60 * 1000;
   recentlySeenApiSizes = new Set;
@@ -161791,25 +162218,359 @@ __export(exports_rpc_notifications, {
   drainNotifications: () => drainNotifications
 });
 function pushNotification(type, payload, sessionId) {
-  queue2.push({ type, payload, sessionId });
+  queue2.push({ id: nextNotificationId++, type, payload, sessionId });
   if (queue2.length > 100) {
     queue2 = queue2.slice(-50);
   }
 }
-function drainNotifications() {
+function drainNotifications(lastReceivedId = 0) {
   lastDrainAt = Date.now();
-  const result = queue2;
-  queue2 = [];
-  return result;
+  if (lastReceivedId > 0) {
+    queue2 = queue2.filter((notification) => notification.id > lastReceivedId);
+  }
+  return [...queue2];
 }
 function isTuiConnected() {
   return lastDrainAt > 0 && Date.now() - lastDrainAt < TUI_CONNECTED_WINDOW_MS;
 }
-var queue2, lastDrainAt = 0, TUI_CONNECTED_WINDOW_MS = 3000;
+var queue2, nextNotificationId = 1, lastDrainAt = 0, TUI_CONNECTED_WINDOW_MS = 3000;
 var init_rpc_notifications = __esm(() => {
   queue2 = [];
 });
 
+// src/features/magic-context/compaction-marker.ts
+import { join as join17 } from "node:path";
+function randomBase62(length) {
+  const chars = [];
+  for (let i = 0;i < length; i++) {
+    chars.push(BASE62_CHARS[Math.floor(Math.random() * BASE62_CHARS.length)]);
+  }
+  return chars.join("");
+}
+function generateId(prefix, timestampMs, counter = 0n) {
+  const encoded = BigInt(timestampMs) * 0x1000n + counter;
+  const hex3 = encoded.toString(16).padStart(14, "0");
+  return `${prefix}_${hex3}${randomBase62(14)}`;
+}
+function generateMessageId(timestampMs, counter = 0n) {
+  return generateId("msg", timestampMs, counter);
+}
+function generatePartId(timestampMs, counter = 0n) {
+  return generateId("prt", timestampMs, counter);
+}
+function getOpenCodeDbPath3() {
+  return join17(getDataDir(), "opencode", "opencode.db");
+}
+function isOpenCodeSchemaCompatible(db, dbPath) {
+  if (cachedSchemaCompatible?.path === dbPath) {
+    return cachedSchemaCompatible.compatible;
+  }
+  try {
+    const messageCols = new Set(db.prepare("PRAGMA table_info(message)").all().map((r) => r.name ?? "").filter((n) => n.length > 0));
+    const partCols = new Set(db.prepare("PRAGMA table_info(part)").all().map((r) => r.name ?? "").filter((n) => n.length > 0));
+    const missingMessage = REQUIRED_MESSAGE_COLUMNS.filter((c) => !messageCols.has(c));
+    const missingPart = REQUIRED_PART_COLUMNS.filter((c) => !partCols.has(c));
+    if (missingMessage.length > 0 || missingPart.length > 0) {
+      log(`[magic-context] compaction-marker: OpenCode DB schema missing required columns ` + `(message: [${missingMessage.join(", ")}], part: [${missingPart.join(", ")}]). ` + `Marker injection disabled for this process. ` + `This usually means OpenCode was updated and magic-context is out of date.`);
+      cachedSchemaCompatible = { path: dbPath, compatible: false };
+      return false;
+    }
+    cachedSchemaCompatible = { path: dbPath, compatible: true };
+    return true;
+  } catch (error51) {
+    log(`[magic-context] compaction-marker: schema probe failed: ${error51 instanceof Error ? error51.message : String(error51)}. ` + `Marker injection disabled until next process restart.`);
+    cachedSchemaCompatible = { path: dbPath, compatible: false };
+    return false;
+  }
+}
+function getWritableOpenCodeDb() {
+  const dbPath = getOpenCodeDbPath3();
+  if (cachedWriteDb?.path === dbPath) {
+    return cachedWriteDb.db;
+  }
+  if (cachedWriteDb) {
+    try {
+      closeQuietly(cachedWriteDb.db);
+    } catch {}
+  }
+  const db = new Database(dbPath);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA busy_timeout=5000");
+  cachedWriteDb = { path: dbPath, db };
+  return db;
+}
+function findBoundaryUserMessage(sessionId, endOrdinal) {
+  const db = getWritableOpenCodeDb();
+  const rows = db.prepare(`SELECT id, time_created, data
+             FROM message
+             WHERE session_id = ?
+               AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
+                        AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')
+             ORDER BY time_created ASC, id ASC
+             LIMIT ?`).all(sessionId, endOrdinal);
+  let bestMatch = null;
+  for (const row of rows) {
+    try {
+      const info = JSON.parse(row.data);
+      if (info.role === "user") {
+        bestMatch = { id: row.id, timeCreated: row.time_created };
+      }
+    } catch {}
+  }
+  return bestMatch;
+}
+function getOpenCodeMessageById(sessionId, messageId) {
+  const db = getWritableOpenCodeDb();
+  const row = db.prepare(`SELECT id FROM message WHERE session_id = ? AND id = ? LIMIT 1`).get(sessionId, messageId);
+  return row ?? null;
+}
+function injectCompactionMarker(args) {
+  const db = getWritableOpenCodeDb();
+  if (!isOpenCodeSchemaCompatible(db, getOpenCodeDbPath3())) {
+    return null;
+  }
+  const boundary = findBoundaryUserMessage(args.sessionId, args.endOrdinal);
+  if (!boundary) {
+    log(`[magic-context] compaction-marker: no user message found at or before ordinal ${args.endOrdinal}`);
+    return null;
+  }
+  const boundaryTime = boundary.timeCreated;
+  const summaryMsgId = generateMessageId(boundaryTime + 1, 1n);
+  const compactionPartId = generatePartId(boundaryTime, 1n);
+  const summaryPartId = generatePartId(boundaryTime + 1, 2n);
+  const summaryMsgData = JSON.stringify({
+    role: "assistant",
+    parentID: boundary.id,
+    summary: true,
+    finish: "stop",
+    mode: "compaction",
+    agent: "compaction",
+    path: { cwd: args.directory, root: args.directory },
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    modelID: "magic-context",
+    providerID: "magic-context",
+    time: { created: boundaryTime + 1 }
+  });
+  try {
+    db.transaction(() => {
+      db.prepare("INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)").run(compactionPartId, boundary.id, args.sessionId, boundaryTime, boundaryTime, '{"type":"compaction","auto":true}');
+      db.prepare("INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?)").run(summaryMsgId, args.sessionId, boundaryTime + 1, boundaryTime + 1, summaryMsgData);
+      db.prepare("INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)").run(summaryPartId, summaryMsgId, args.sessionId, boundaryTime + 1, boundaryTime + 1, JSON.stringify({ type: "text", text: args.summaryText }));
+    })();
+    log(`[magic-context] compaction-marker: injected boundary at user msg ${boundary.id} (ordinal ~${args.endOrdinal}), summary msg ${summaryMsgId}`);
+    return {
+      boundaryMessageId: boundary.id,
+      summaryMessageId: summaryMsgId,
+      compactionPartId,
+      summaryPartId
+    };
+  } catch (error51) {
+    log(`[magic-context] compaction-marker: injection failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    return null;
+  }
+}
+function removeCompactionMarker(state) {
+  try {
+    const db = getWritableOpenCodeDb();
+    db.transaction(() => {
+      db.prepare("DELETE FROM part WHERE id = ?").run(state.summaryPartId);
+      db.prepare("DELETE FROM message WHERE id = ?").run(state.summaryMessageId);
+      db.prepare("DELETE FROM part WHERE id = ?").run(state.compactionPartId);
+    })();
+    return true;
+  } catch (error51) {
+    log(`[magic-context] compaction-marker: removal failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    return false;
+  }
+}
+var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", cachedWriteDb = null, REQUIRED_MESSAGE_COLUMNS, REQUIRED_PART_COLUMNS, cachedSchemaCompatible = null;
+var init_compaction_marker = __esm(async () => {
+  init_data_path();
+  init_logger();
+  await init_sqlite();
+  REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
+  REQUIRED_PART_COLUMNS = [
+    "id",
+    "message_id",
+    "session_id",
+    "time_created",
+    "time_updated",
+    "data"
+  ];
+});
+
+// src/hooks/magic-context/compaction-marker-manager.ts
+import { join as join18 } from "node:path";
+function validatePendingTarget(db, sessionId, pending) {
+  const ocMessage = getOpenCodeMessageById(sessionId, pending.endMessageId);
+  if (!ocMessage) {
+    return "compartment-removed";
+  }
+  const compartments = getCompartmentsByEndMessageId(db, sessionId, pending.endMessageId);
+  if (compartments.length === 0) {
+    return "compartment-removed";
+  }
+  if (compartments.length > 1) {
+    log(`[magic-context][${sessionId}] WARNING: ${compartments.length} compartments share endMessageId=${pending.endMessageId} — schema invariant violated; treating as stale`);
+    return "compartment-removed";
+  }
+  const compartment = compartments[0];
+  if (compartment.endMessage !== pending.ordinal) {
+    return "target-superseded";
+  }
+  return "ok";
+}
+function applyDeferredCompactionMarker(db, sessionId, pending, directory) {
+  try {
+    const validation = validatePendingTarget(db, sessionId, pending);
+    if (validation !== "ok") {
+      sessionLog(sessionId, `compaction-marker drain: stale-skip (${validation}) for ordinal ${pending.ordinal} endMessageId=${pending.endMessageId}`);
+      return { kind: "stale-skip", reason: validation };
+    }
+    const existing = getPersistedCompactionMarkerState(db, sessionId);
+    if (existing && existing.boundaryOrdinal >= pending.ordinal) {
+      return { kind: "already-current" };
+    }
+    if (existing) {
+      const removed = removeCompactionMarker(existing);
+      if (!removed) {
+        return {
+          kind: "retryable-failure",
+          error: new Error(`failed to remove old compaction marker at ordinal ${existing.boundaryOrdinal}`)
+        };
+      }
+      sessionLog(sessionId, `compaction-marker drain: removed old boundary at ordinal ${existing.boundaryOrdinal}, advancing to ${pending.ordinal}`);
+    }
+    const result = injectCompactionMarker({
+      sessionId,
+      endOrdinal: pending.ordinal,
+      summaryText: MARKER_SUMMARY_TEXT,
+      directory: directory ?? process.cwd()
+    });
+    if (!result) {
+      return {
+        kind: "retryable-failure",
+        error: new Error(`injectCompactionMarker returned null for ordinal ${pending.ordinal}; will retry`)
+      };
+    }
+    setPersistedCompactionMarkerState(db, sessionId, {
+      ...result,
+      boundaryOrdinal: pending.ordinal
+    });
+    sessionLog(sessionId, `compaction-marker drain: applied at ordinal ${pending.ordinal}, boundary user msg ${result.boundaryMessageId}`);
+    return { kind: "applied", markerOrdinal: pending.ordinal };
+  } catch (err) {
+    const error51 = err instanceof Error ? err : new Error(String(err));
+    sessionLog(sessionId, `compaction-marker drain: retryable failure for ordinal ${pending.ordinal}:`, error51);
+    return { kind: "retryable-failure", error: error51 };
+  }
+}
+function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd, directory) {
+  const existing = getPersistedCompactionMarkerState(db, sessionId);
+  if (existing) {
+    if (existing.boundaryOrdinal === lastCompartmentEnd) {
+      return;
+    }
+    try {
+      removeCompactionMarker(existing);
+      setPersistedCompactionMarkerState(db, sessionId, null);
+      sessionLog(sessionId, `compaction-marker: removed old boundary at ordinal ${existing.boundaryOrdinal}, moving to ${lastCompartmentEnd}`);
+    } catch (error51) {
+      sessionLog(sessionId, `compaction-marker: failed to remove old boundary at ordinal ${existing.boundaryOrdinal}, proceeding with new injection:`, error51);
+    }
+  }
+  const result = injectCompactionMarker({
+    sessionId,
+    endOrdinal: lastCompartmentEnd,
+    summaryText: MARKER_SUMMARY_TEXT,
+    directory: directory ?? process.cwd()
+  });
+  if (result) {
+    setPersistedCompactionMarkerState(db, sessionId, {
+      ...result,
+      boundaryOrdinal: lastCompartmentEnd
+    });
+    sessionLog(sessionId, `compaction-marker: injected at ordinal ${lastCompartmentEnd}, boundary user msg ${result.boundaryMessageId}`);
+  }
+}
+function removeCompactionMarkerForSession(db, sessionId) {
+  const existing = getPersistedCompactionMarkerState(db, sessionId);
+  if (existing) {
+    try {
+      removeCompactionMarker(existing);
+      setPersistedCompactionMarkerState(db, sessionId, null);
+      sessionLog(sessionId, "compaction-marker: removed on session cleanup");
+    } catch (error51) {
+      setPersistedCompactionMarkerState(db, sessionId, null);
+      sessionLog(sessionId, "compaction-marker: removal failed during session cleanup, cleared persisted state:", error51);
+    }
+  }
+}
+function checkCompactionMarkerConsistency(db) {
+  const opencodeDbPath = join18(getDataDir(), "opencode", "opencode.db");
+  let opencodeDb;
+  try {
+    opencodeDb = new Database(opencodeDbPath, { readonly: true });
+  } catch (error51) {
+    log(`[magic-context] compaction-marker consistency check skipped: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    return;
+  }
+  try {
+    const persistedRows = db.prepare("SELECT session_id, compaction_marker_state FROM session_meta WHERE compaction_marker_state IS NOT NULL AND compaction_marker_state != ''").all();
+    if (persistedRows.length === 0)
+      return;
+    const checkMessage = opencodeDb.prepare("SELECT 1 FROM message WHERE id = ? LIMIT 1");
+    const checkPart = opencodeDb.prepare("SELECT 1 FROM part WHERE id = ? LIMIT 1");
+    let reconciledCount = 0;
+    for (const row of persistedRows) {
+      const state = getPersistedCompactionMarkerState(db, row.session_id);
+      if (!state)
+        continue;
+      const boundaryExists = checkMessage.get(state.boundaryMessageId) !== null;
+      const summaryMessageExists = checkMessage.get(state.summaryMessageId) !== null;
+      const compactionPartExists = checkPart.get(state.compactionPartId) !== null;
+      const summaryPartExists = checkPart.get(state.summaryPartId) !== null;
+      const allPresent = boundaryExists && summaryMessageExists && compactionPartExists && summaryPartExists;
+      if (allPresent)
+        continue;
+      let removedOk = false;
+      try {
+        removedOk = removeCompactionMarker(state);
+      } catch (error51) {
+        sessionLog(row.session_id, "compaction-marker consistency: partial cleanup of half-written marker failed:", error51);
+      }
+      if (removedOk) {
+        setPersistedCompactionMarkerState(db, row.session_id, null);
+        sessionLog(row.session_id, `compaction-marker consistency: cleared orphaned state (boundary=${boundaryExists} summary=${summaryMessageExists} cPart=${compactionPartExists} sPart=${summaryPartExists}); next publication will re-inject`);
+        reconciledCount++;
+      } else {
+        sessionLog(row.session_id, `compaction-marker consistency: cleanup failed for orphaned state (boundary=${boundaryExists} summary=${summaryMessageExists} cPart=${compactionPartExists} sPart=${summaryPartExists}); will retry on next startup`);
+      }
+    }
+    if (reconciledCount > 0) {
+      log(`[magic-context] compaction-marker consistency: reconciled ${reconciledCount} session(s) with orphaned marker state at startup`);
+    }
+  } catch (error51) {
+    log(`[magic-context] compaction-marker consistency check failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+  } finally {
+    try {
+      closeQuietly(opencodeDb);
+    } catch {}
+  }
+}
+var MARKER_SUMMARY_TEXT = "[Compacted by magic-context — session history is managed by the plugin]";
+var init_compaction_marker_manager = __esm(async () => {
+  init_compartment_storage();
+  init_storage_meta_persisted();
+  init_data_path();
+  init_logger();
+  await __promiseAll([
+    init_compaction_marker(),
+    init_sqlite()
+  ]);
+});
+
 // src/hooks/magic-context/compartment-parser.ts
 function parseCompartmentOutput(text) {
   const compartments = [];
@@ -162030,9 +162791,11 @@ var init_compartment_runner_validation = __esm(async () => {
 });
 
 // src/hooks/magic-context/compartment-runner-historian.ts
-import { mkdirSync as mkdirSync5, unlinkSync, writeFileSync as writeFileSync5 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join18 } from "node:path";
+import { mkdirSync as mkdirSync6, unlinkSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join19 } from "node:path";
+function historianResponseDumpDir(directory) {
+  return getProjectMagicContextHistorianDir(directory);
+}
 async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
     ...args,
@@ -162125,7 +162888,8 @@ async function runHistorianPrompt(args) {
     timeoutMs,
     dumpLabel,
     modelOverride,
-    agentId = HISTORIAN_AGENT
+    agentId = HISTORIAN_AGENT,
+    fallbackModels
   } = args;
   let agentSessionId = null;
   try {
@@ -162152,7 +162916,11 @@ async function runHistorianPrompt(args) {
             ...modelOverride ? { model: modelOverride } : {},
             parts: [{ type: "text", text: prompt, synthetic: true }]
           }
-        }, { timeoutMs: timeoutMs ?? DEFAULT_HISTORIAN_TIMEOUT_MS });
+        }, {
+          timeoutMs: timeoutMs ?? DEFAULT_HISTORIAN_TIMEOUT_MS,
+          fallbackModels: modelOverride ? undefined : fallbackModels,
+          callContext: agentId === HISTORIAN_EDITOR_AGENT ? "historian:editor" : "historian"
+        });
         sessionLog(parentSessionId, `historian: prompt completed (attempt ${retryIndex + 1}/${MAX_HISTORIAN_RETRIES + 1})`);
         break;
       } catch (error51) {
@@ -162178,7 +162946,7 @@ async function runHistorianPrompt(args) {
     if (!result) {
       return { ok: false, error: "Historian returned no assistant output." };
     }
-    const dumpPath = dumpHistorianResponse(parentSessionId, dumpLabel ?? "historian-response", result);
+    const dumpPath = dumpHistorianResponse(parentSessionId, sessionDirectory, dumpLabel ?? "historian-response", result);
     return { ok: true, result, dumpPath };
   } catch (modelError) {
     const desc = describeError(modelError);
@@ -162270,12 +163038,13 @@ function cleanupHistorianDump(sessionId, dumpPath) {
     });
   }
 }
-function dumpHistorianResponse(sessionId, label, text) {
+function dumpHistorianResponse(sessionId, directory, label, text) {
   try {
-    mkdirSync5(HISTORIAN_RESPONSE_DUMP_DIR, { recursive: true });
+    const dumpDir = historianResponseDumpDir(directory);
+    mkdirSync6(dumpDir, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join18(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    const dumpPath = join19(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
     writeFileSync5(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
@@ -162293,14 +163062,14 @@ function dumpHistorianResponse(sessionId, label, text) {
 function sanitizeDumpName(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "-");
 }
-var HISTORIAN_RESPONSE_DUMP_DIR, MAX_HISTORIAN_RETRIES = 2;
+var MAX_HISTORIAN_RETRIES = 2;
 var init_compartment_runner_historian = __esm(async () => {
   init_magic_context();
   init_shared();
   init_assistant_message_extractor();
+  init_data_path();
   init_compartment_prompt();
   await init_compartment_runner_validation();
-  HISTORIAN_RESPONSE_DUMP_DIR = join18(tmpdir2(), "magic-context-historian");
 });
 
 // src/hooks/magic-context/compartment-runner-state-xml.ts
@@ -162602,16 +163371,24 @@ function trimMemoriesToBudget(sessionId, memories, budgetTokens) {
 function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectPath, injectionBudgetTokens, temporalAwareness) {
   const cached2 = injectionCache.get(sessionId);
   if (!isCacheBusting && cached2) {
-    if (cached2.compartmentEndMessageId.length > 0) {
-      const cutoffIndex2 = messages.findIndex((message) => message.info.id === cached2.compartmentEndMessageId);
-      if (cutoffIndex2 >= 0) {
-        const remaining = messages.slice(cutoffIndex2 + 1);
-        messages.splice(0, messages.length, ...remaining);
-      } else {
-        sessionLog(sessionId, `compartment injection: cached boundary ${cached2.compartmentEndMessageId} not in messages (already trimmed), reusing cache`);
+    if (cached2.kind === "empty") {
+      return null;
+    }
+    const prepared = cached2.injection;
+    if (prepared.compartmentEndMessageId === null) {
+      sessionLog(sessionId, "compartment injection cache in degraded mode (null boundary), forcing rebuild");
+    } else {
+      if (prepared.compartmentEndMessageId.length > 0) {
+        const cutoffIndex2 = messages.findIndex((message) => message.info.id === prepared.compartmentEndMessageId);
+        if (cutoffIndex2 >= 0) {
+          const remaining = messages.slice(cutoffIndex2 + 1);
+          messages.splice(0, messages.length, ...remaining);
+        } else {
+          sessionLog(sessionId, `compartment injection: cached boundary ${prepared.compartmentEndMessageId} not in messages (already trimmed), reusing cache`);
+        }
       }
+      return { ...prepared, rebuiltFromDb: false };
     }
-    return cached2;
   }
   const compartments = getCompartments(db, sessionId);
   const facts = getSessionFacts(db, sessionId);
@@ -162643,7 +163420,11 @@ function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, pr
     }
   }
   if (compartments.length === 0 && facts.length === 0 && !memoryBlock) {
-    injectionCache.delete(sessionId);
+    injectionCache.set(sessionId, {
+      kind: "empty",
+      compartmentEndMessageId: "",
+      renderedBytes: 0
+    });
     return null;
   }
   let dateRanges;
@@ -162676,9 +163457,10 @@ function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, pr
       compartmentCount: 0,
       skippedVisibleMessages: 0,
       factCount: facts.length,
-      memoryCount
+      memoryCount,
+      rebuiltFromDb: true
     };
-    injectionCache.set(sessionId, result2);
+    injectionCache.set(sessionId, { kind: "populated", injection: result2 });
     return result2;
   }
   const lastCompartment = compartments[compartments.length - 1];
@@ -162696,9 +163478,10 @@ function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, pr
       compartmentCount: compartments.length,
       skippedVisibleMessages: 0,
       factCount: facts.length,
-      memoryCount
+      memoryCount,
+      rebuiltFromDb: true
     };
-    injectionCache.set(sessionId, result2);
+    injectionCache.set(sessionId, { kind: "populated", injection: result2 });
     return result2;
   }
   let skippedVisibleMessages = 0;
@@ -162707,17 +163490,20 @@ function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, pr
     skippedVisibleMessages = cutoffIndex + 1;
     const remaining = messages.slice(cutoffIndex + 1);
     messages.splice(0, messages.length, ...remaining);
+  } else {
+    sessionLog(sessionId, `compartment injection entering degraded mode: boundary ${lastEndMessageId} not in visible messages`);
   }
   const result = {
     block,
     compartmentEndMessage: lastEnd,
-    compartmentEndMessageId: lastEndMessageId,
+    compartmentEndMessageId: cutoffIndex >= 0 ? lastEndMessageId : null,
     compartmentCount: compartments.length,
     skippedVisibleMessages,
     factCount: facts.length,
-    memoryCount
+    memoryCount,
+    rebuiltFromDb: true
   };
-  injectionCache.set(sessionId, result);
+  injectionCache.set(sessionId, { kind: "populated", injection: result });
   return result;
 }
 function renderCompartmentInjection(sessionId, messages, prepared) {
@@ -163009,9 +163795,18 @@ async function executePartialRecompInternal(deps, range) {
       }
       setRecompPartialRange(db, sessionId, null);
       clearCompressionDepthRange(db, sessionId, snapStart, snapEnd);
-      clearInjectionCache(sessionId);
-      deps.onInjectionCacheCleared?.(sessionId);
+      if (deps.preserveInjectionCacheUntilConsumed !== true) {
+        clearInjectionCache(sessionId);
+      }
+      deps.onCompartmentStatePublished?.(sessionId);
       const lastEnd = merged[merged.length - 1]?.endMessage ?? snapEnd;
+      if (deps.experimentalCompactionMarkers && lastEnd > 0) {
+        updateCompactionMarkerAfterPublication(db, sessionId, lastEnd, deps.directory);
+        const stalePending = getPendingCompactionMarkerState(db, sessionId);
+        if (stalePending) {
+          clearPendingCompactionMarkerStateIf(db, sessionId, stalePending);
+        }
+      }
       return { compartmentCount: merged.length, lastEndMessage: lastEnd };
     };
     const protectedTailStart = getProtectedTailStartOrdinal(sessionId);
@@ -163117,6 +163912,7 @@ Historian pass ${passCount + 1}, attempt ${passAttempt} started for messages ${c
         dumpLabelBase: `partial-recomp-${sessionId}-${chunk.startIndex}-${chunk.endIndex}-pass-${passCount + 1}`,
         timeoutMs: historianTimeoutMs,
         fallbackModelId: deps.fallbackModelId,
+        fallbackModels: deps.fallbackModels,
         twoPass: deps.historianTwoPass,
         callbacks: {
           onRepairRetry: async (error51) => {
@@ -163210,6 +164006,7 @@ var init_compartment_runner_partial_recomp = __esm(async () => {
   init_send_session_notification();
   await __promiseAll([
     init_storage_meta(),
+    init_compaction_marker_manager(),
     init_compartment_runner_historian(),
     init_compartment_runner_validation(),
     init_inject_compartments(),
@@ -163278,269 +164075,6 @@ var init_derive_budgets = __esm(() => {
   init_models_dev_cache();
 });
 
-// src/features/magic-context/compaction-marker.ts
-import { join as join19 } from "node:path";
-function randomBase62(length) {
-  const chars = [];
-  for (let i = 0;i < length; i++) {
-    chars.push(BASE62_CHARS[Math.floor(Math.random() * BASE62_CHARS.length)]);
-  }
-  return chars.join("");
-}
-function generateId(prefix, timestampMs, counter = 0n) {
-  const encoded = BigInt(timestampMs) * 0x1000n + counter;
-  const hex3 = encoded.toString(16).padStart(14, "0");
-  return `${prefix}_${hex3}${randomBase62(14)}`;
-}
-function generateMessageId(timestampMs, counter = 0n) {
-  return generateId("msg", timestampMs, counter);
-}
-function generatePartId(timestampMs, counter = 0n) {
-  return generateId("prt", timestampMs, counter);
-}
-function getOpenCodeDbPath3() {
-  return join19(getDataDir(), "opencode", "opencode.db");
-}
-function isOpenCodeSchemaCompatible(db, dbPath) {
-  if (cachedSchemaCompatible?.path === dbPath) {
-    return cachedSchemaCompatible.compatible;
-  }
-  try {
-    const messageCols = new Set(db.prepare("PRAGMA table_info(message)").all().map((r) => r.name ?? "").filter((n) => n.length > 0));
-    const partCols = new Set(db.prepare("PRAGMA table_info(part)").all().map((r) => r.name ?? "").filter((n) => n.length > 0));
-    const missingMessage = REQUIRED_MESSAGE_COLUMNS.filter((c) => !messageCols.has(c));
-    const missingPart = REQUIRED_PART_COLUMNS.filter((c) => !partCols.has(c));
-    if (missingMessage.length > 0 || missingPart.length > 0) {
-      log(`[magic-context] compaction-marker: OpenCode DB schema missing required columns ` + `(message: [${missingMessage.join(", ")}], part: [${missingPart.join(", ")}]). ` + `Marker injection disabled for this process. ` + `This usually means OpenCode was updated and magic-context is out of date.`);
-      cachedSchemaCompatible = { path: dbPath, compatible: false };
-      return false;
-    }
-    cachedSchemaCompatible = { path: dbPath, compatible: true };
-    return true;
-  } catch (error51) {
-    log(`[magic-context] compaction-marker: schema probe failed: ${error51 instanceof Error ? error51.message : String(error51)}. ` + `Marker injection disabled until next process restart.`);
-    cachedSchemaCompatible = { path: dbPath, compatible: false };
-    return false;
-  }
-}
-function getWritableOpenCodeDb() {
-  const dbPath = getOpenCodeDbPath3();
-  if (cachedWriteDb?.path === dbPath) {
-    return cachedWriteDb.db;
-  }
-  if (cachedWriteDb) {
-    try {
-      closeQuietly(cachedWriteDb.db);
-    } catch {}
-  }
-  const db = new Database(dbPath);
-  db.exec("PRAGMA journal_mode=WAL");
-  db.exec("PRAGMA busy_timeout=5000");
-  cachedWriteDb = { path: dbPath, db };
-  return db;
-}
-function findBoundaryUserMessage(sessionId, endOrdinal) {
-  const db = getWritableOpenCodeDb();
-  const rows = db.prepare(`SELECT id, time_created, data
-             FROM message
-             WHERE session_id = ?
-               AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
-                        AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')
-             ORDER BY time_created ASC, id ASC
-             LIMIT ?`).all(sessionId, endOrdinal);
-  let bestMatch = null;
-  for (const row of rows) {
-    try {
-      const info = JSON.parse(row.data);
-      if (info.role === "user") {
-        bestMatch = { id: row.id, timeCreated: row.time_created };
-      }
-    } catch {}
-  }
-  return bestMatch;
-}
-function injectCompactionMarker(args) {
-  const db = getWritableOpenCodeDb();
-  if (!isOpenCodeSchemaCompatible(db, getOpenCodeDbPath3())) {
-    return null;
-  }
-  const boundary = findBoundaryUserMessage(args.sessionId, args.endOrdinal);
-  if (!boundary) {
-    log(`[magic-context] compaction-marker: no user message found at or before ordinal ${args.endOrdinal}`);
-    return null;
-  }
-  const boundaryTime = boundary.timeCreated;
-  const summaryMsgId = generateMessageId(boundaryTime + 1, 1n);
-  const compactionPartId = generatePartId(boundaryTime, 1n);
-  const summaryPartId = generatePartId(boundaryTime + 1, 2n);
-  const summaryMsgData = JSON.stringify({
-    role: "assistant",
-    parentID: boundary.id,
-    summary: true,
-    finish: "stop",
-    mode: "compaction",
-    agent: "compaction",
-    path: { cwd: args.directory, root: args.directory },
-    cost: 0,
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    modelID: "magic-context",
-    providerID: "magic-context",
-    time: { created: boundaryTime + 1 }
-  });
-  try {
-    db.transaction(() => {
-      db.prepare("INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)").run(compactionPartId, boundary.id, args.sessionId, boundaryTime, boundaryTime, '{"type":"compaction","auto":true}');
-      db.prepare("INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?)").run(summaryMsgId, args.sessionId, boundaryTime + 1, boundaryTime + 1, summaryMsgData);
-      db.prepare("INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)").run(summaryPartId, summaryMsgId, args.sessionId, boundaryTime + 1, boundaryTime + 1, JSON.stringify({ type: "text", text: args.summaryText }));
-    })();
-    log(`[magic-context] compaction-marker: injected boundary at user msg ${boundary.id} (ordinal ~${args.endOrdinal}), summary msg ${summaryMsgId}`);
-    return {
-      boundaryMessageId: boundary.id,
-      summaryMessageId: summaryMsgId,
-      compactionPartId,
-      summaryPartId
-    };
-  } catch (error51) {
-    log(`[magic-context] compaction-marker: injection failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    return null;
-  }
-}
-function removeCompactionMarker(state) {
-  try {
-    const db = getWritableOpenCodeDb();
-    db.transaction(() => {
-      db.prepare("DELETE FROM part WHERE id = ?").run(state.summaryPartId);
-      db.prepare("DELETE FROM message WHERE id = ?").run(state.summaryMessageId);
-      db.prepare("DELETE FROM part WHERE id = ?").run(state.compactionPartId);
-    })();
-    return true;
-  } catch (error51) {
-    log(`[magic-context] compaction-marker: removal failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    return false;
-  }
-}
-var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", cachedWriteDb = null, REQUIRED_MESSAGE_COLUMNS, REQUIRED_PART_COLUMNS, cachedSchemaCompatible = null;
-var init_compaction_marker = __esm(async () => {
-  init_data_path();
-  init_logger();
-  await init_sqlite();
-  REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
-  REQUIRED_PART_COLUMNS = [
-    "id",
-    "message_id",
-    "session_id",
-    "time_created",
-    "time_updated",
-    "data"
-  ];
-});
-
-// src/hooks/magic-context/compaction-marker-manager.ts
-import { join as join20 } from "node:path";
-function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd, directory) {
-  const existing = getPersistedCompactionMarkerState(db, sessionId);
-  if (existing) {
-    if (existing.boundaryOrdinal === lastCompartmentEnd) {
-      return;
-    }
-    try {
-      removeCompactionMarker(existing);
-      setPersistedCompactionMarkerState(db, sessionId, null);
-      sessionLog(sessionId, `compaction-marker: removed old boundary at ordinal ${existing.boundaryOrdinal}, moving to ${lastCompartmentEnd}`);
-    } catch (error51) {
-      sessionLog(sessionId, `compaction-marker: failed to remove old boundary at ordinal ${existing.boundaryOrdinal}, proceeding with new injection:`, error51);
-    }
-  }
-  const result = injectCompactionMarker({
-    sessionId,
-    endOrdinal: lastCompartmentEnd,
-    summaryText: MARKER_SUMMARY_TEXT,
-    directory: directory ?? process.cwd()
-  });
-  if (result) {
-    setPersistedCompactionMarkerState(db, sessionId, {
-      ...result,
-      boundaryOrdinal: lastCompartmentEnd
-    });
-    sessionLog(sessionId, `compaction-marker: injected at ordinal ${lastCompartmentEnd}, boundary user msg ${result.boundaryMessageId}`);
-  }
-}
-function removeCompactionMarkerForSession(db, sessionId) {
-  const existing = getPersistedCompactionMarkerState(db, sessionId);
-  if (existing) {
-    try {
-      removeCompactionMarker(existing);
-      setPersistedCompactionMarkerState(db, sessionId, null);
-      sessionLog(sessionId, "compaction-marker: removed on session cleanup");
-    } catch (error51) {
-      setPersistedCompactionMarkerState(db, sessionId, null);
-      sessionLog(sessionId, "compaction-marker: removal failed during session cleanup, cleared persisted state:", error51);
-    }
-  }
-}
-function checkCompactionMarkerConsistency(db) {
-  const opencodeDbPath = join20(getDataDir(), "opencode", "opencode.db");
-  let opencodeDb;
-  try {
-    opencodeDb = new Database(opencodeDbPath, { readonly: true });
-  } catch (error51) {
-    log(`[magic-context] compaction-marker consistency check skipped: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    return;
-  }
-  try {
-    const persistedRows = db.prepare("SELECT session_id, compaction_marker_state FROM session_meta WHERE compaction_marker_state IS NOT NULL AND compaction_marker_state != ''").all();
-    if (persistedRows.length === 0)
-      return;
-    const checkMessage = opencodeDb.prepare("SELECT 1 FROM message WHERE id = ? LIMIT 1");
-    const checkPart = opencodeDb.prepare("SELECT 1 FROM part WHERE id = ? LIMIT 1");
-    let reconciledCount = 0;
-    for (const row of persistedRows) {
-      const state = getPersistedCompactionMarkerState(db, row.session_id);
-      if (!state)
-        continue;
-      const boundaryExists = checkMessage.get(state.boundaryMessageId) !== null;
-      const summaryMessageExists = checkMessage.get(state.summaryMessageId) !== null;
-      const compactionPartExists = checkPart.get(state.compactionPartId) !== null;
-      const summaryPartExists = checkPart.get(state.summaryPartId) !== null;
-      const allPresent = boundaryExists && summaryMessageExists && compactionPartExists && summaryPartExists;
-      if (allPresent)
-        continue;
-      let removedOk = false;
-      try {
-        removedOk = removeCompactionMarker(state);
-      } catch (error51) {
-        sessionLog(row.session_id, "compaction-marker consistency: partial cleanup of half-written marker failed:", error51);
-      }
-      if (removedOk) {
-        setPersistedCompactionMarkerState(db, row.session_id, null);
-        sessionLog(row.session_id, `compaction-marker consistency: cleared orphaned state (boundary=${boundaryExists} summary=${summaryMessageExists} cPart=${compactionPartExists} sPart=${summaryPartExists}); next publication will re-inject`);
-        reconciledCount++;
-      } else {
-        sessionLog(row.session_id, `compaction-marker consistency: cleanup failed for orphaned state (boundary=${boundaryExists} summary=${summaryMessageExists} cPart=${compactionPartExists} sPart=${summaryPartExists}); will retry on next startup`);
-      }
-    }
-    if (reconciledCount > 0) {
-      log(`[magic-context] compaction-marker consistency: reconciled ${reconciledCount} session(s) with orphaned marker state at startup`);
-    }
-  } catch (error51) {
-    log(`[magic-context] compaction-marker consistency check failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
-  } finally {
-    try {
-      closeQuietly(opencodeDb);
-    } catch {}
-  }
-}
-var MARKER_SUMMARY_TEXT = "[Compacted by magic-context — session history is managed by the plugin]";
-var init_compaction_marker_manager = __esm(async () => {
-  init_storage_meta_persisted();
-  init_data_path();
-  init_logger();
-  await __promiseAll([
-    init_compaction_marker(),
-    init_sqlite()
-  ]);
-});
-
 // src/hooks/magic-context/note-nudger.ts
 function getPersistedNoteNudgeDeliveredAt(_db, sessionId) {
   return lastDeliveredAt.get(sessionId) ?? 0;
@@ -163866,15 +164400,15 @@ var init_caveman = __esm(() => {
 });
 
 // src/hooks/magic-context/historian-state-file.ts
-import { mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join21 } from "node:path";
-function maybeWriteHistorianStateFile(sessionId, existingState) {
+import { mkdirSync as mkdirSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join20 } from "node:path";
+function maybeWriteHistorianStateFile(sessionId, existingState, directory) {
   if (existingState.length <= HISTORIAN_STATE_INLINE_THRESHOLD)
     return;
   try {
-    mkdirSync6(HISTORIAN_STATE_DIR, { recursive: true });
-    const path5 = join21(HISTORIAN_STATE_DIR, `state-${sessionId}-${Date.now()}.xml`);
+    const dir = getProjectMagicContextHistorianDir(directory);
+    mkdirSync7(dir, { recursive: true });
+    const path5 = join20(dir, `state-${sessionId}-${Date.now()}.xml`);
     writeFileSync6(path5, existingState, "utf8");
     return path5;
   } catch {
@@ -163888,9 +164422,9 @@ function cleanupHistorianStateFile(path5) {
     unlinkSync2(path5);
   } catch {}
 }
-var HISTORIAN_STATE_INLINE_THRESHOLD = 30000, HISTORIAN_STATE_DIR;
+var HISTORIAN_STATE_INLINE_THRESHOLD = 30000;
 var init_historian_state_file = __esm(() => {
-  HISTORIAN_STATE_DIR = join21(tmpdir3(), "magic-context-historian");
+  init_data_path();
 });
 
 // src/features/magic-context/memory/embedding-backfill.ts
@@ -164318,7 +164852,8 @@ async function runCompressorPass(args) {
     targetTokens,
     outputCount,
     outputDepth,
-    historianTimeoutMs
+    historianTimeoutMs,
+    fallbackModels
   } = args;
   const prompt = buildCompressorPrompt(compartments, currentTokens, targetTokens, outputDepth, outputCount);
   let agentSessionId = null;
@@ -164340,7 +164875,11 @@ async function runCompressorPass(args) {
         agent: HISTORIAN_AGENT2,
         parts: [{ type: "text", text: prompt, synthetic: true }]
       }
-    }, { timeoutMs: historianTimeoutMs ?? DEFAULT_HISTORIAN_TIMEOUT_MS });
+    }, {
+      timeoutMs: historianTimeoutMs ?? DEFAULT_HISTORIAN_TIMEOUT_MS,
+      fallbackModels,
+      callContext: "compressor"
+    });
     const messagesResponse = await client.session.messages({
       path: { id: agentSessionId },
       query: { directory }
@@ -164497,7 +165036,7 @@ No new compartments or facts were written.`);
     const existingState = priorCompartments.length > 0 || priorFacts.length > 0 ? buildExistingStateXml(priorCompartments, priorFacts, memoryBlock) : memoryBlock ? `${memoryBlock}
 
 This is your first run. No existing compartments or facts.` : "This is your first run. No existing state.";
-    stateFilePath = maybeWriteHistorianStateFile(sessionId, existingState);
+    stateFilePath = maybeWriteHistorianStateFile(sessionId, existingState, directory);
     if (stateFilePath) {
       sessionLog(sessionId, `historian: existing state offloaded to file (${existingState.length} chars) → ${stateFilePath}`);
     }
@@ -164520,6 +165059,7 @@ ${chunk.text}`, { stateFilePath });
       dumpLabelBase: `incremental-${sessionId}-${chunk.startIndex}-${chunk.endIndex}`,
       timeoutMs: historianTimeoutMs,
       fallbackModelId: deps.fallbackModelId,
+      fallbackModels: deps.fallbackModels,
       twoPass: deps.historianTwoPass
     });
     if (!validatedPass.ok) {
@@ -164544,21 +165084,36 @@ Historian returned compartments that made no forward progress beyond raw message
 No new compartments or facts were written. Check the historian model/output and try again.`);
       return;
     }
+    const deferMarkerApplication = deps.preserveInjectionCacheUntilConsumed === true && deps.experimentalCompactionMarkers === true;
+    const lastCompartmentEnd = lastNewEnd;
+    const lastNewEndMessageId = newCompartments[newCompartments.length - 1]?.endMessageId;
     db.transaction(() => {
       appendCompartments(db, sessionId, newCompartments);
       replaceSessionFacts(db, sessionId, validatedPass.facts ?? []);
       clearHistorianFailureState(db, sessionId);
       clearEmergencyRecovery(db, sessionId);
+      if (deferMarkerApplication && lastNewEndMessageId) {
+        setPendingCompactionMarkerState(db, sessionId, {
+          ordinal: lastCompartmentEnd,
+          endMessageId: lastNewEndMessageId,
+          publishedAt: Date.now()
+        });
+      }
     })();
-    clearInjectionCache(sessionId);
-    deps.onInjectionCacheCleared?.(sessionId);
+    if (deps.preserveInjectionCacheUntilConsumed !== true) {
+      clearInjectionCache(sessionId);
+    }
+    deps.onCompartmentStatePublished?.(sessionId);
     if (deps.directory && deps.memoryEnabled !== false && deps.autoPromote !== false) {
       promoteSessionFactsToMemory(db, sessionId, resolveProjectIdentity(deps.directory), validatedPass.facts ?? []);
     }
-    const lastCompartmentEnd = lastNewEnd;
     queueDropsForCompartmentalizedMessages(db, sessionId, lastCompartmentEnd);
     if (deps.experimentalCompactionMarkers) {
-      updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd, sessionDirectory);
+      if (deferMarkerApplication) {
+        deps.onDeferredMarkerPending?.(sessionId);
+      } else {
+        updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd, sessionDirectory);
+      }
     }
     if (deps.historyBudgetTokens && deps.historyBudgetTokens > 0) {
       await runCompressionPassIfNeeded({
@@ -164568,6 +165123,7 @@ No new compartments or facts were written. Check the historian model/output and
         directory: sessionDirectory,
         historyBudgetTokens: deps.historyBudgetTokens,
         historianTimeoutMs,
+        fallbackModels: deps.fallbackModels,
         minCompartmentRatio: deps.compressorMinCompartmentRatio,
         maxMergeDepth: deps.compressorMaxMergeDepth
       });
@@ -164662,8 +165218,10 @@ async function executeContextRecompInternal(deps) {
       if (!promoted2)
         return null;
       clearCompressionDepth(db, sessionId);
-      clearInjectionCache(sessionId);
-      deps.onInjectionCacheCleared?.(sessionId);
+      if (deps.preserveInjectionCacheUntilConsumed !== true) {
+        clearInjectionCache(sessionId);
+      }
+      deps.onCompartmentStatePublished?.(sessionId);
       if (deps.directory && deps.memoryEnabled !== false && deps.autoPromote !== false) {
         promoteSessionFactsToMemory(db, sessionId, resolveProjectIdentity(deps.directory), promoted2.facts);
       }
@@ -164673,6 +165231,10 @@ async function executeContextRecompInternal(deps) {
       }
       if (deps.experimentalCompactionMarkers && lastCompartmentEnd2 > 0) {
         updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd2, deps.directory);
+        const stalePending = getPendingCompactionMarkerState(db, sessionId);
+        if (stalePending) {
+          clearPendingCompactionMarkerStateIf(db, sessionId, stalePending);
+        }
       }
       return [
         `Persisted ${promoted2.compartments.length} compartment${promoted2.compartments.length === 1 ? "" : "s"} from ${passCount} successful pass${passCount === 1 ? "" : "es"}.`,
@@ -164738,7 +165300,7 @@ Nothing was written.`;
 
 This is your first run. No existing compartments or facts.` : "This is your first run. No existing state.";
       cleanupHistorianStateFile(currentStateFilePath);
-      currentStateFilePath = maybeWriteHistorianStateFile(sessionId, existingState);
+      currentStateFilePath = maybeWriteHistorianStateFile(sessionId, existingState, sessionDirectory);
       const prompt = buildCompartmentAgentPrompt(existingState, `Messages ${chunk.startIndex}-${chunk.endIndex}:
 
 ${chunk.text}`, { stateFilePath: currentStateFilePath });
@@ -164756,6 +165318,7 @@ Historian pass ${passCount + 1}, attempt ${passAttempt} started for messages ${c
         dumpLabelBase: `recomp-${sessionId}-${chunk.startIndex}-${chunk.endIndex}-pass-${passCount + 1}`,
         timeoutMs: historianTimeoutMs,
         fallbackModelId: deps.fallbackModelId,
+        fallbackModels: deps.fallbackModels,
         twoPass: deps.historianTwoPass,
         callbacks: {
           onRepairRetry: async (error51) => {
@@ -164833,8 +165396,10 @@ Nothing was written.`;
       clearRecompStaging(db, sessionId);
     }
     clearCompressionDepth(db, sessionId);
-    clearInjectionCache(sessionId);
-    deps.onInjectionCacheCleared?.(sessionId);
+    if (deps.preserveInjectionCacheUntilConsumed !== true) {
+      clearInjectionCache(sessionId);
+    }
+    deps.onCompartmentStatePublished?.(sessionId);
     const finalCompartments = promoted?.compartments ?? candidateCompartments;
     const finalFacts = promoted?.facts ?? candidateFacts;
     if (deps.directory && deps.memoryEnabled !== false && deps.autoPromote !== false) {
@@ -164853,6 +165418,7 @@ Nothing was written.`;
         directory: sessionDirectory,
         historyBudgetTokens: deps.historyBudgetTokens,
         historianTimeoutMs,
+        fallbackModels: deps.fallbackModels,
         minCompartmentRatio: deps.compressorMinCompartmentRatio,
         maxMergeDepth: deps.compressorMaxMergeDepth
       });
@@ -164908,50 +165474,78 @@ __export(exports_compartment_runner, {
   startCompartmentAgent: () => startCompartmentAgent,
   runCompartmentAgent: () => runCompartmentAgent,
   registerActiveCompartmentRun: () => registerActiveCompartmentRun,
+  markActiveCompartmentRunPublished: () => markActiveCompartmentRunPublished,
   getActiveCompartmentRun: () => getActiveCompartmentRun,
   executeContextRecomp: () => executeContextRecomp
 });
 function getActiveCompartmentRun(sessionId) {
   return activeRuns.get(sessionId);
 }
+function markActiveCompartmentRunPublished(sessionId) {
+  const activeRun = activeRuns.get(sessionId);
+  if (activeRun)
+    activeRun.published = true;
+}
 function registerActiveCompartmentRun(sessionId, promise2) {
+  const activeRun = {
+    promise: Promise.resolve(),
+    published: false
+  };
   const wrapped = promise2.finally(() => {
-    if (activeRuns.get(sessionId) === wrapped) {
+    if (activeRuns.get(sessionId)?.promise === wrapped) {
       activeRuns.delete(sessionId);
     }
   });
-  activeRuns.set(sessionId, wrapped);
+  activeRun.promise = wrapped;
+  activeRuns.set(sessionId, activeRun);
+  return activeRun;
+}
+function withPublishedCallback(deps) {
+  return {
+    ...deps,
+    onCompartmentStatePublished: (sid) => {
+      markActiveCompartmentRunPublished(sid);
+      deps.onCompartmentStatePublished?.(sid);
+    }
+  };
 }
 function startCompartmentAgent(deps) {
   const existing = activeRuns.get(deps.sessionId);
   if (existing) {
     return;
   }
-  const promise2 = runCompartmentAgent(deps).catch((err) => {
+  const runnerDeps = withPublishedCallback(deps);
+  const promise2 = runCompartmentAgent(runnerDeps).catch((err) => {
     sessionLog(deps.sessionId, "compartment agent: unhandled rejection:", err);
     try {
       updateSessionMeta(deps.db, deps.sessionId, { compartmentInProgress: false });
     } catch {}
   }).finally(() => {
-    activeRuns.delete(deps.sessionId);
+    if (activeRuns.get(deps.sessionId)?.promise === promise2) {
+      activeRuns.delete(deps.sessionId);
+    }
   });
-  activeRuns.set(deps.sessionId, promise2);
+  activeRuns.set(deps.sessionId, { promise: promise2, published: false });
 }
 async function executeContextRecomp(deps, options = {}) {
   const { sessionId } = deps;
   if (activeRuns.has(sessionId)) {
     return "## Magic Recomp\n\nHistorian is already running for this session. Wait for it to finish, then try `/ctx-recomp` again.";
   }
-  const promise2 = options.range ? executePartialRecompInternal(deps, options.range) : executeContextRecompInternal(deps);
-  activeRuns.set(sessionId, promise2.then(() => {
+  const runnerDeps = withPublishedCallback(deps);
+  const promise2 = options.range ? executePartialRecompInternal(runnerDeps, options.range) : executeContextRecompInternal(runnerDeps);
+  const wrappedPromise = promise2.then(() => {
     return;
   }).catch((err) => {
     sessionLog(sessionId, "compartment agent: recomp unhandled rejection:", err);
-  }));
+  });
+  activeRuns.set(sessionId, { promise: wrappedPromise, published: false });
   try {
     return await promise2;
   } finally {
-    activeRuns.delete(sessionId);
+    if (activeRuns.get(sessionId)?.promise === wrappedPromise) {
+      activeRuns.delete(sessionId);
+    }
   }
 }
 var activeRuns;
@@ -164972,8 +165566,8 @@ var exports_tui_config = {};
 __export(exports_tui_config, {
   ensureTuiPluginEntry: () => ensureTuiPluginEntry
 });
-import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname7, join as join24 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname8, join as join23 } from "node:path";
 function isMagicContextEntry(entry) {
   if (!entry)
     return false;
@@ -164987,8 +165581,8 @@ function isMagicContextEntry(entry) {
 }
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join24(configDir, "tui.jsonc");
-  const jsonPath = join24(configDir, "tui.json");
+  const jsoncPath = join23(configDir, "tui.jsonc");
+  const jsonPath = join23(configDir, "tui.json");
   if (existsSync14(jsoncPath))
     return jsoncPath;
   if (existsSync14(jsonPath))
@@ -165000,7 +165594,7 @@ function ensureTuiPluginEntry() {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
     if (existsSync14(configPath)) {
-      const raw = readFileSync10(configPath, "utf-8");
+      const raw = readFileSync11(configPath, "utf-8");
       config2 = import_comment_json3.parse(raw) ?? {};
     }
     const plugins = Array.isArray(config2.plugin) ? config2.plugin.filter((p) => typeof p === "string") : [];
@@ -165019,7 +165613,7 @@ function ensureTuiPluginEntry() {
       plugins.push(PLUGIN_ENTRY);
     }
     config2.plugin = plugins;
-    mkdirSync8(dirname7(configPath), { recursive: true });
+    mkdirSync9(dirname8(configPath), { recursive: true });
     writeFileSync8(configPath, `${import_comment_json3.stringify(config2, null, 2)}
 `);
     log(`[magic-context] updated TUI plugin entry in ${configPath}`);
@@ -165130,34 +165724,20 @@ function loadConfigFile(configPath) {
     return null;
   }
 }
-function mergeConfigs(base, override, options = {}) {
-  const config2 = {
-    ...base,
-    ...override,
-    auto_update: options.allowUserOnlyFields ? override.auto_update : base.auto_update,
-    memory: {
-      ...base.memory ?? {},
-      ...override.memory ?? {}
-    },
-    embedding: override.embedding ?? base.embedding,
-    historian: override.historian ?? base.historian,
-    dreamer: override.dreamer ? {
-      ...base.dreamer ?? {},
-      ...override.dreamer
-    } : base.dreamer,
-    sidekick: override.sidekick ? {
-      ...base.sidekick ?? {},
-      ...override.sidekick
-    } : base.sidekick,
-    disabled_hooks: [
-      ...new Set([...base.disabled_hooks ?? [], ...override.disabled_hooks ?? []])
-    ],
-    command: {
-      ...base.command ?? {},
-      ...override.command ?? {}
+function deepMergeRawConfig(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overrideVal = override[key];
+    if (baseVal !== null && typeof baseVal === "object" && !Array.isArray(baseVal) && overrideVal !== null && typeof overrideVal === "object" && !Array.isArray(overrideVal)) {
+      result[key] = deepMergeRawConfig(baseVal, overrideVal);
+    } else if (key === "disabled_hooks" && Array.isArray(baseVal) && Array.isArray(overrideVal)) {
+      result[key] = [...new Set([...baseVal, ...overrideVal])];
+    } else {
+      result[key] = overrideVal;
     }
-  };
-  return config2;
+  }
+  return result;
 }
 function getProjectUserOnlyFields(config2) {
   return "auto_update" in config2 ? ["auto_update"] : [];
@@ -165298,30 +165878,38 @@ function loadPluginConfig(directory) {
   const projectDetected = rootDetected.format !== "none" ? rootDetected : dotOpenCodeDetected;
   const userLoaded = userDetected.format === "none" ? null : loadConfigFile(userDetected.path);
   const projectLoaded = projectDetected.format === "none" ? null : loadConfigFile(projectDetected.path);
-  let config2 = parsePluginConfig({});
   const allWarnings = [];
+  let mergedRaw = {};
   if (userLoaded) {
     allWarnings.push(...userLoaded.warnings.map((w) => `[user config] ${w}`));
-    const parsed = parsePluginConfig(userLoaded.config);
-    if (parsed.configWarnings?.length) {
-      allWarnings.push(...parsed.configWarnings.map((w) => `[user config] ${w}`));
-    }
-    config2 = mergeConfigs(config2, parsed, { allowUserOnlyFields: true });
+    mergedRaw = deepMergeRawConfig(mergedRaw, userLoaded.config);
   }
   if (projectLoaded) {
     allWarnings.push(...projectLoaded.warnings.map((w) => `[project config] ${w}`));
-    const parsed = parsePluginConfig(projectLoaded.config);
-    if (parsed.configWarnings?.length) {
-      allWarnings.push(...parsed.configWarnings.map((w) => `[project config] ${w}`));
-    }
-    const strippedUserOnlyFields = getProjectUserOnlyFields(projectLoaded.config);
+    const projectRaw = { ...projectLoaded.config };
+    const strippedUserOnlyFields = getProjectUserOnlyFields(projectRaw);
     if (strippedUserOnlyFields.length > 0) {
+      for (const key of strippedUserOnlyFields) {
+        delete projectRaw[key];
+      }
       allWarnings.push(`[project config] Ignoring ${strippedUserOnlyFields.join(", ")} from project config (security: these settings only honor user-level config)`);
     }
-    config2 = mergeConfigs(config2, parsed);
+    mergedRaw = deepMergeRawConfig(mergedRaw, projectRaw);
+  }
+  const config2 = parsePluginConfig(mergedRaw);
+  if (config2.configWarnings?.length) {
+    allWarnings.push(...config2.configWarnings.map((w) => {
+      if (userLoaded && projectLoaded)
+        return `[config] ${w}`;
+      if (userLoaded)
+        return `[user config] ${w}`;
+      return `[project config] ${w}`;
+    }));
   }
   if (allWarnings.length > 0) {
     config2.configWarnings = allWarnings;
+  } else if ("configWarnings" in config2) {
+    config2.configWarnings = undefined;
   }
   return config2;
 }
@@ -165722,6 +166310,7 @@ function buildDreamTaskPrompt(task, args) {
 init_shared();
 init_assistant_message_extractor();
 init_logger();
+init_resolve_fallbacks();
 
 // src/features/magic-context/sidekick/core.ts
 var SIDEKICK_SYSTEM_PROMPT = `You are Sidekick, a focused memory-retrieval subagent for an AI coding assistant.
@@ -165741,6 +166330,7 @@ function stripThinkingBlocks(text) {
 
 // src/features/magic-context/sidekick/agent.ts
 async function runSidekick(deps) {
+  const fallbackModels = resolveFallbackChain(SIDEKICK_AGENT, deps.config.fallback_models);
   let agentSessionId = null;
   try {
     const createResponse = await deps.client.session.create({
@@ -165763,7 +166353,7 @@ async function runSidekick(deps) {
         system: deps.config.system_prompt?.trim() || deps.config.prompt?.trim() || SIDEKICK_SYSTEM_PROMPT,
         parts: [{ type: "text", text: deps.userMessage, synthetic: true }]
       }
-    }, { timeoutMs: deps.config.timeout_ms });
+    }, { timeoutMs: deps.config.timeout_ms, fallbackModels, callContext: "sidekick" });
     const messagesResponse = await deps.client.session.messages({
       path: { id: agentSessionId },
       query: { directory: deps.sessionDirectory ?? deps.projectPath }
@@ -165801,41 +166391,41 @@ init_tool_definition_tokens();
 
 // src/hooks/auto-update-checker/index.ts
 init_logger();
-import { existsSync as existsSync6, mkdirSync, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname4, join as join6 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname5, join as join6 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
 init_logger();
 var import_comment_json2 = __toESM(require_src2(), 1);
 import { spawn } from "node:child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename, dirname as dirname3, join as join5 } from "node:path";
+import { basename, dirname as dirname4, join as join5 } from "node:path";
 
 // src/hooks/auto-update-checker/checker.ts
 init_logger();
 var import_comment_json = __toESM(require_src2(), 1);
 import { existsSync as existsSync4, readFileSync as readFileSync4, statSync, writeFileSync } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, resolve as resolve2 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/hooks/auto-update-checker/constants.ts
-import { homedir as homedir3, platform } from "node:os";
+import { homedir as homedir4, platform } from "node:os";
 import { join as join3 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/opencode-magic-context";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function getOpenCodeCacheRoot() {
   if (platform() === "win32") {
-    return join3(process.env.LOCALAPPDATA ?? homedir3(), "opencode");
+    return join3(process.env.LOCALAPPDATA ?? homedir4(), "opencode");
   }
-  return join3(homedir3(), ".cache", "opencode");
+  return join3(homedir4(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform() === "win32") {
-    return join3(process.env.APPDATA ?? join3(homedir3(), "AppData", "Roaming"), "opencode");
+    return join3(process.env.APPDATA ?? join3(homedir4(), "AppData", "Roaming"), "opencode");
   }
-  return join3(process.env.XDG_CONFIG_HOME ?? join3(homedir3(), ".config"), "opencode");
+  return join3(process.env.XDG_CONFIG_HOME ?? join3(homedir4(), ".config"), "opencode");
 }
 var CACHE_DIR = join3(getOpenCodeCacheRoot(), "packages");
 var USER_OPENCODE_CONFIG = join3(getOpenCodeConfigRoot(), "opencode.json");
@@ -165917,12 +166507,12 @@ function resolvePathPluginSpec(spec, configPath) {
   }
   if (isAbsolute2(spec) || /^[A-Za-z]:[\\/]/.test(spec))
     return spec;
-  return resolve2(dirname2(configPath), spec);
+  return resolve2(dirname3(configPath), spec);
 }
 function findPackageJsonUp(startPath) {
   try {
     const stat = statSync(startPath);
-    let dir = stat.isDirectory() ? startPath : dirname2(startPath);
+    let dir = stat.isDirectory() ? startPath : dirname3(startPath);
     for (let i = 0;i < 10; i++) {
       const pkgPath = join4(dir, "package.json");
       if (existsSync4(pkgPath)) {
@@ -165932,7 +166522,7 @@ function findPackageJsonUp(startPath) {
             return pkgPath;
         } catch {}
       }
-      const parent = dirname2(dir);
+      const parent = dirname3(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -165980,7 +166570,7 @@ function getLocalDevVersion(directory) {
 }
 function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
   try {
-    return findPackageJsonUp(dirname2(fileURLToPath(currentModuleUrl)));
+    return findPackageJsonUp(dirname3(fileURLToPath(currentModuleUrl)));
   } catch (err) {
     warn(`[auto-update-checker] Failed to resolve runtime package path: ${String(err)}`);
     return null;
@@ -166023,7 +166613,7 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join4(homedir4(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
+    join4(homedir5(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
@@ -166077,7 +166667,7 @@ function stripPackageNameFromPath(pathValue, packageName) {
   for (const segment of [...packageName.split("/")].reverse()) {
     if (basename(current) !== segment)
       return null;
-    current = dirname3(current);
+    current = dirname4(current);
   }
   return current;
 }
@@ -166140,19 +166730,19 @@ function removeInstalledPackage(installDir, packageName) {
 }
 function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
   if (runtimePackageJsonPath) {
-    const packageDir = dirname3(runtimePackageJsonPath);
+    const packageDir = dirname4(runtimePackageJsonPath);
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
     if (nodeModulesDir && basename(nodeModulesDir) === "node_modules") {
-      const installDir = dirname3(nodeModulesDir);
+      const installDir = dirname4(nodeModulesDir);
       const packageJsonPath = join5(installDir, "package.json");
       if (existsSync5(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
-  const legacyPackageJsonPath = join5(dirname3(CACHE_DIR), "package.json");
+  const legacyPackageJsonPath = join5(dirname4(CACHE_DIR), "package.json");
   if (existsSync5(legacyPackageJsonPath)) {
-    return { installDir: dirname3(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
+    return { installDir: dirname4(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
   }
   return null;
 }
@@ -166281,7 +166871,7 @@ function claimCheckSlot(storageDir, intervalMs) {
         }
       } catch {}
     }
-    mkdirSync(dirname4(file2), { recursive: true });
+    mkdirSync2(dirname5(file2), { recursive: true });
     const tmp = `${file2}.tmp.${process.pid}`;
     writeFileSync3(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
     renameSync(tmp, file2);
@@ -166379,15 +166969,16 @@ function createLiveSessionState() {
     variantBySession: new Map,
     agentBySession: new Map,
     historyRefreshSessions: new Set,
+    deferredHistoryRefreshSessions: new Set,
     systemPromptRefreshSessions: new Set,
     pendingMaterializationSessions: new Set,
+    deferredMaterializationSessions: new Set,
     sessionDirectoryBySession: new Map
   };
 }
 
 // src/index.ts
 init_conflict_warning_hook();
-
 // src/features/magic-context/dreamer/storage-dream-state.ts
 var getDreamStateStatements = new WeakMap;
 var setDreamStateStatements = new WeakMap;
@@ -166484,11 +167075,23 @@ function releaseLease(db, holderId) {
   })();
 }
 // src/features/magic-context/dreamer/queue.ts
+function hasActiveDreamLease(db) {
+  try {
+    return isLeaseActive(db);
+  } catch (error51) {
+    if (String(error51).includes("no such table: dream_state")) {
+      return false;
+    }
+    throw error51;
+  }
+}
 function enqueueDream(db, projectIdentity, reason, force = false) {
   const now = Date.now();
   return db.transaction(() => {
-    const staleThresholdMs = force ? 2 * 60 * 1000 : 120 * 60 * 1000;
-    db.prepare("DELETE FROM dream_queue WHERE project_path = ? AND started_at IS NOT NULL AND started_at < ?").run([projectIdentity, now - staleThresholdMs]);
+    if (!hasActiveDreamLease(db)) {
+      const staleThresholdMs = force ? 2 * 60 * 1000 : 120 * 60 * 1000;
+      db.prepare("DELETE FROM dream_queue WHERE project_path = ? AND started_at IS NOT NULL AND started_at < ?").run([projectIdentity, now - staleThresholdMs]);
+    }
     const existing = db.prepare("SELECT id FROM dream_queue WHERE project_path = ?").get(projectIdentity);
     if (existing) {
       return null;
@@ -166549,7 +167152,7 @@ init_data_path();
 init_logger();
 await init_sqlite();
 import { existsSync as existsSync9 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join12 } from "node:path";
 
 // src/features/magic-context/key-files/identify-key-files.ts
 init_logger();
@@ -166833,7 +167436,12 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
         system: DREAMER_SYSTEM_PROMPT,
         parts: [{ type: "text", text: prompt, synthetic: true }]
       }
-    }, { timeoutMs: Math.min(remainingMs, 5 * 60 * 1000), signal: abortController.signal });
+    }, {
+      timeoutMs: Math.min(remainingMs, 5 * 60 * 1000),
+      signal: abortController.signal,
+      fallbackModels: args.fallbackModels,
+      callContext: "dreamer:user-memories"
+    });
     const messagesResponse = await args.client.session.messages({
       path: { id: agentSessionId },
       query: { directory: args.sessionDirectory }
@@ -166892,7 +167500,8 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
     }
     return result;
   } catch (error51) {
-    log(`[dreamer] user-memories: review failed: ${getErrorMessage(error51)}`);
+    const errorDescription = describeError(error51);
+    log(`[dreamer] user-memories: review failed: ${errorDescription.brief}`, errorDescription.stackHead ? { stackHead: errorDescription.stackHead } : undefined);
     return result;
   } finally {
     clearInterval(leaseInterval);
@@ -166923,6 +167532,7 @@ function insertDreamRun(db, run) {
 
 // src/features/magic-context/dreamer/runner.ts
 var dreamProjectDirectories = new Map;
+var CIRCUIT_BREAKER_THRESHOLD = 3;
 function registerDreamProjectDirectory(projectIdentity, directory) {
   dreamProjectDirectories.set(projectIdentity, directory);
 }
@@ -166939,8 +167549,27 @@ function countNewIds(beforeIds, afterIds) {
   }
   return count;
 }
+function getCircuitBreakerSignature(error51, brief) {
+  if (error51 instanceof Error && error51.name && error51.name !== "Error") {
+    return error51.name;
+  }
+  const namedError = error51;
+  if (namedError && typeof namedError === "object" && typeof namedError.name === "string" && namedError.name.length > 0 && namedError.name !== "Error") {
+    return namedError.name;
+  }
+  return brief.split(":")[0]?.trim().split(/\s+/)[0] || brief || "unknown";
+}
+function shouldSkipCircuitBreaker(error51, brief) {
+  const namedError = error51;
+  const name2 = error51 instanceof Error ? error51.name : namedError && typeof namedError === "object" && typeof namedError.name === "string" ? namedError.name : "";
+  const combined = `${name2} ${brief}`.toLowerCase();
+  return name2 === "AbortError" || combined.includes("lease");
+}
+function logWithStackHead(message, stackHead) {
+  log(message, stackHead ? { stackHead } : undefined);
+}
 function getOpenCodeDbPath2() {
-  return join13(getDataDir(), "opencode", "opencode.db");
+  return join12(getDataDir(), "opencode", "opencode.db");
 }
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath2();
@@ -167015,9 +167644,11 @@ async function identifyKeyFilesForSession(args) {
       try {
         if (!renewLease(args.db, args.holderId)) {
           log(`[key-files][${args.sessionId}] lease renewal failed — aborting`);
+          args.onLeaseLost?.(`key-files:${args.sessionId}`);
           abortController.abort();
         }
-      } catch {
+      } catch (error51) {
+        args.onLeaseLost?.(`key-files:${args.sessionId}`, error51);
         abortController.abort();
       }
     }, 60000);
@@ -167044,7 +167675,12 @@ async function identifyKeyFilesForSession(args) {
           system: KEY_FILES_SYSTEM_PROMPT,
           parts: [{ type: "text", text: prompt, synthetic: true }]
         }
-      }, { timeoutMs: Math.min(remainingMs, 300000), signal: abortController.signal });
+      }, {
+        timeoutMs: Math.min(remainingMs, 300000),
+        signal: abortController.signal,
+        fallbackModels: args.fallbackModels,
+        callContext: `dreamer:key-files:${args.sessionId.slice(0, 12)}`
+      });
       const messagesResponse = await args.client.session.messages({
         path: { id: agentSessionId },
         query: { directory: args.sessionDirectory }
@@ -167067,6 +167703,10 @@ async function identifyKeyFilesForSession(args) {
       log(`[key-files][${args.sessionId}] could not parse agent output — using heuristic fallback`);
       applyHeuristicFallback();
     } catch (error51) {
+      if (args.isLeaseLost?.() || abortController.signal.aborted) {
+        log(`[key-files][${args.sessionId}] lease lost during identification — skipping heuristic fallback`);
+        throw error51;
+      }
       log(`[key-files][${args.sessionId}] identification failed: ${getErrorMessage(error51)} — using heuristic fallback`);
       try {
         applyHeuristicFallback();
@@ -167107,6 +167747,10 @@ async function identifyKeyFiles(args) {
   }
   log(`[key-files] evaluating ${sessionIds.length} active session(s) for ${args.projectIdentity}`);
   for (const sessionId of sessionIds) {
+    if (args.isLeaseLost?.()) {
+      log("[key-files] lease lost — stopping key-file identification");
+      break;
+    }
     if (Date.now() > args.deadline) {
       log("[key-files] deadline reached — stopping key-file identification");
       break;
@@ -167117,6 +167761,9 @@ async function identifyKeyFiles(args) {
       parentSessionId: args.parentSessionId,
       sessionDirectory: args.sessionDirectory,
       holderId: args.holderId,
+      fallbackModels: args.fallbackModels,
+      onLeaseLost: args.onLeaseLost,
+      isLeaseLost: args.isLeaseLost,
       deadline: args.deadline,
       sessionId,
       config: args.config
@@ -167170,8 +167817,53 @@ async function runDream(args) {
   const deadline = startedAt + args.maxRuntimeMinutes * 60 * 1000;
   const lastDreamAt = getDreamState(args.db, `last_dream_at:${args.projectIdentity}`) ?? getDreamState(args.db, "last_dream_at");
   log(`[dreamer] last dream at: ${lastDreamAt ?? "never"} (project=${args.projectIdentity})`);
+  let lastErrorSignature = null;
+  let consecutiveSameErrorFailures = 0;
+  let circuitBreakerTripped = false;
+  let lostLease = false;
+  let lostLeaseReason = null;
+  let lostLeaseRecorded = false;
+  const markLeaseLost = (phase, error51) => {
+    const detail = error51 ? `: ${getErrorMessage(error51)}` : "";
+    lostLeaseReason = `Dream lease lost during ${phase}${detail}`;
+    if (!lostLease) {
+      log(`[dreamer] FATAL: ${lostLeaseReason}; aborting all remaining dream work`);
+    } else {
+      log(`[dreamer] FATAL: ${lostLeaseReason}; dream work is already aborting`);
+    }
+    lostLease = true;
+  };
+  const recordLeaseLostTask = (phase) => {
+    if (lostLeaseRecorded)
+      return;
+    lostLeaseRecorded = true;
+    result.tasks.push({
+      name: "lease-lost",
+      durationMs: 0,
+      result: "",
+      error: lostLeaseReason ?? `Dream lease lost during ${phase}; aborted remaining work`
+    });
+  };
+  const verifyLeaseStillHeld = (phase) => {
+    if (lostLease)
+      return false;
+    try {
+      if (!renewLease(args.db, holderId)) {
+        markLeaseLost(phase);
+        return false;
+      }
+      return true;
+    } catch (error51) {
+      markLeaseLost(phase, error51);
+      return false;
+    }
+  };
   try {
     for (const taskName of args.tasks) {
+      if (!verifyLeaseStillHeld(`before task ${taskName}`)) {
+        recordLeaseLostTask(`before task ${taskName}`);
+        break;
+      }
       if (Date.now() > deadline) {
         log(`[dreamer] deadline reached, stopping after ${result.tasks.length} tasks`);
         break;
@@ -167184,18 +167876,20 @@ async function runDream(args) {
         try {
           if (!renewLease(args.db, holderId)) {
             log(`[dreamer] task ${taskName}: lease renewal failed — aborting LLM call`);
+            markLeaseLost(`task ${taskName} lease renewal`);
             taskAbortController.abort();
           }
         } catch (err) {
           log(`[dreamer] task ${taskName}: lease renewal threw — aborting LLM call: ${err}`);
+          markLeaseLost(`task ${taskName} lease renewal`, err);
           taskAbortController.abort();
         }
       }, 60000);
       try {
         const docsDir = args.sessionDirectory ?? args.projectIdentity;
         const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync9(join13(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync9(join13(docsDir, "STRUCTURE.md"))
+          architecture: existsSync9(join12(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync9(join12(docsDir, "STRUCTURE.md"))
         } : undefined;
         const userMemories = taskName === "archive-stale" ? getActiveUserMemories(args.db).map((um) => ({
           id: um.id,
@@ -167230,8 +167924,13 @@ async function runDream(args) {
           }
         }, {
           timeoutMs: args.taskTimeoutMinutes * 60 * 1000,
-          signal: taskAbortController.signal
+          signal: taskAbortController.signal,
+          fallbackModels: args.fallbackModels,
+          callContext: `dreamer:${taskName}`
         });
+        if (lostLease) {
+          throw new Error(lostLeaseReason ?? `Dream lease lost during ${taskName}`);
+        }
         const messagesResponse = await args.client.session.messages({
           path: { id: agentSessionId },
           query: { directory: args.sessionDirectory ?? args.projectIdentity }
@@ -167250,16 +167949,43 @@ async function runDream(args) {
           durationMs,
           result: taskResult
         });
+        lastErrorSignature = null;
+        consecutiveSameErrorFailures = 0;
       } catch (error51) {
         const durationMs = Date.now() - taskStartedAt;
-        const errorMsg = getErrorMessage(error51);
-        log(`[dreamer] task ${taskName}: failed after ${(durationMs / 1000).toFixed(1)}s — ${errorMsg}`);
+        const errorDescription = describeError(error51);
+        logWithStackHead(`[dreamer] task ${taskName}: failed after ${(durationMs / 1000).toFixed(1)}s — ${errorDescription.brief}`, errorDescription.stackHead);
         result.tasks.push({
           name: taskName,
           durationMs,
           result: null,
-          error: errorMsg
+          error: errorDescription.brief
         });
+        if (lostLease) {
+          lastErrorSignature = null;
+          consecutiveSameErrorFailures = 0;
+        } else if (shouldSkipCircuitBreaker(error51, errorDescription.brief)) {
+          lastErrorSignature = null;
+          consecutiveSameErrorFailures = 0;
+        } else {
+          const signature = getCircuitBreakerSignature(error51, errorDescription.brief);
+          if (signature === lastErrorSignature) {
+            consecutiveSameErrorFailures += 1;
+          } else {
+            lastErrorSignature = signature;
+            consecutiveSameErrorFailures = 1;
+          }
+          if (consecutiveSameErrorFailures >= CIRCUIT_BREAKER_THRESHOLD) {
+            circuitBreakerTripped = true;
+            log(`[dreamer] circuit breaker: ${consecutiveSameErrorFailures} consecutive ${signature} failures — aborting remaining tasks`);
+            result.tasks.push({
+              name: "circuit-breaker",
+              durationMs: 0,
+              result: "",
+              error: `Aborted remaining tasks: ${consecutiveSameErrorFailures} consecutive ${signature} failures. Configure dreamer model/fallback_models in magic-context.jsonc.`
+            });
+          }
+        }
       } finally {
         clearInterval(leaseRenewalInterval);
         if (agentSessionId) {
@@ -167271,10 +167997,32 @@ async function runDream(args) {
           });
         }
       }
+      if (lostLease) {
+        recordLeaseLostTask(`task ${taskName}`);
+        break;
+      }
+      if (circuitBreakerTripped) {
+        break;
+      }
+    }
+    if (lostLease) {
+      log("[dreamer] lease lost: skipping all post-task phases");
+      recordLeaseLostTask("post-task phases");
+    } else if (circuitBreakerTripped) {
+      log("[dreamer] circuit breaker: skipping post-task phases");
+      result.tasks.push({
+        name: "post-task-phases",
+        durationMs: 0,
+        result: "",
+        error: "Skipped post-task phases after circuit breaker tripped; configure dreamer model/fallback_models in magic-context.jsonc."
+      });
     }
-    if (args.experimentalUserMemories?.enabled && Date.now() <= deadline) {
+    if (!circuitBreakerTripped && !lostLease && args.experimentalUserMemories?.enabled && Date.now() <= deadline) {
       const umStart = Date.now();
       try {
+        if (!verifyLeaseStillHeld("before user-memory review")) {
+          throw new Error(lostLeaseReason ?? "Dream lease lost before user-memory review");
+        }
         const reviewResult = await reviewUserMemories({
           db: args.db,
           client: args.client,
@@ -167282,8 +168030,12 @@ async function runDream(args) {
           sessionDirectory: args.sessionDirectory,
           holderId,
           deadline,
-          promotionThreshold: args.experimentalUserMemories.promotionThreshold
+          promotionThreshold: args.experimentalUserMemories.promotionThreshold,
+          fallbackModels: args.fallbackModels
         });
+        if (!verifyLeaseStillHeld("after user-memory review")) {
+          throw new Error(lostLeaseReason ?? "Dream lease lost after user-memory review");
+        }
         const umOutput = `promoted=${reviewResult.promoted} merged=${reviewResult.merged} dismissed=${reviewResult.dismissed} consumed=${reviewResult.candidatesConsumed}`;
         if (reviewResult.promoted > 0 || reviewResult.merged > 0 || reviewResult.dismissed > 0) {
           log(`[dreamer] user-memories: ${umOutput}`);
@@ -167294,17 +168046,23 @@ async function runDream(args) {
           result: umOutput
         });
       } catch (error51) {
-        log(`[dreamer] user-memory review failed: ${getErrorMessage(error51)}`);
+        const errorDescription = describeError(error51);
+        logWithStackHead(`[dreamer] user-memory review failed: ${errorDescription.brief}`, errorDescription.stackHead);
         result.tasks.push({
           name: "user memories",
           durationMs: Date.now() - umStart,
           result: "",
-          error: getErrorMessage(error51)
+          error: errorDescription.brief
         });
       }
+      if (lostLease)
+        recordLeaseLostTask("user-memory review");
     }
-    if (Date.now() <= deadline) {
+    if (!circuitBreakerTripped && !lostLease && Date.now() <= deadline) {
       try {
+        if (!verifyLeaseStillHeld("before smart-note evaluation")) {
+          throw new Error(lostLeaseReason ?? "Dream lease lost before smart-note evaluation");
+        }
         await evaluateSmartNotes({
           db: args.db,
           client: args.client,
@@ -167313,15 +168071,27 @@ async function runDream(args) {
           sessionDirectory: args.sessionDirectory,
           holderId,
           deadline,
-          result
+          result,
+          fallbackModels: args.fallbackModels,
+          onLeaseLost: markLeaseLost,
+          isLeaseLost: () => lostLease
         });
+        if (!verifyLeaseStillHeld("after smart-note evaluation")) {
+          throw new Error(lostLeaseReason ?? "Dream lease lost after smart-note evaluation");
+        }
       } catch (error51) {
-        log(`[dreamer] smart note evaluation failed: ${getErrorMessage(error51)}`);
+        const errorDescription = describeError(error51);
+        logWithStackHead(`[dreamer] smart note evaluation failed: ${errorDescription.brief}`, errorDescription.stackHead);
       }
+      if (lostLease)
+        recordLeaseLostTask("smart-note evaluation");
     }
-    if (args.experimentalPinKeyFiles?.enabled && Date.now() <= deadline) {
+    if (!circuitBreakerTripped && !lostLease && args.experimentalPinKeyFiles?.enabled && Date.now() <= deadline) {
       const kfStart = Date.now();
       try {
+        if (!verifyLeaseStillHeld("before key-file identification")) {
+          throw new Error(lostLeaseReason ?? "Dream lease lost before key-file identification");
+        }
         await identifyKeyFiles({
           db: args.db,
           client: args.client,
@@ -167330,22 +168100,31 @@ async function runDream(args) {
           sessionDirectory: args.sessionDirectory ?? args.projectIdentity,
           holderId,
           deadline,
-          config: args.experimentalPinKeyFiles
+          config: args.experimentalPinKeyFiles,
+          fallbackModels: args.fallbackModels,
+          onLeaseLost: markLeaseLost,
+          isLeaseLost: () => lostLease
         });
+        if (!verifyLeaseStillHeld("after key-file identification")) {
+          throw new Error(lostLeaseReason ?? "Dream lease lost after key-file identification");
+        }
         result.tasks.push({
           name: "key files",
           durationMs: Date.now() - kfStart,
           result: "completed"
         });
       } catch (error51) {
-        log(`[key-files] identification phase failed: ${getErrorMessage(error51)}`);
+        const errorDescription = describeError(error51);
+        logWithStackHead(`[key-files] identification phase failed: ${errorDescription.brief}`, errorDescription.stackHead);
         result.tasks.push({
           name: "key files",
           durationMs: Date.now() - kfStart,
           result: "",
-          error: getErrorMessage(error51)
+          error: errorDescription.brief
         });
       }
+      if (lostLease)
+        recordLeaseLostTask("key-file identification");
     }
   } finally {
     releaseLease(args.db, holderId);
@@ -167378,9 +168157,15 @@ async function runDream(args) {
     smartNotesPending: result.smartNotesPending,
     memoryChanges: persistedMemoryChanges
   });
-  const POST_TASK_NAMES = new Set(["smart-notes", "user memories", "key files"]);
+  const POST_TASK_NAMES = new Set([
+    "smart-notes",
+    "user memories",
+    "key files",
+    "post-task-phases",
+    "circuit-breaker"
+  ]);
   const hasSuccessfulTask = result.tasks.some((t) => !t.error && !POST_TASK_NAMES.has(t.name));
-  if (hasSuccessfulTask) {
+  if (hasSuccessfulTask && !lostLease) {
     setDreamState(args.db, `last_dream_at:${args.projectIdentity}`, String(result.finishedAt));
     setDreamState(args.db, "last_dream_at", String(result.finishedAt));
   }
@@ -167429,9 +168214,11 @@ Only include notes whose conditions you could definitively evaluate. Skip notes
     try {
       if (!renewLease(args.db, args.holderId)) {
         log("[dreamer] smart notes: lease renewal failed — aborting");
+        args.onLeaseLost?.("smart notes");
         abortController.abort();
       }
-    } catch {
+    } catch (error51) {
+      args.onLeaseLost?.("smart notes", error51);
       abortController.abort();
     }
   }, 60000);
@@ -167457,7 +168244,12 @@ Only include notes whose conditions you could definitively evaluate. Skip notes
         system: DREAMER_SYSTEM_PROMPT,
         parts: [{ type: "text", text: evaluationPrompt, synthetic: true }]
       }
-    }, { timeoutMs: Math.min(remainingMs, 300000), signal: abortController.signal });
+    }, {
+      timeoutMs: Math.min(remainingMs, 300000),
+      signal: abortController.signal,
+      fallbackModels: args.fallbackModels,
+      callContext: "dreamer:smart-notes"
+    });
     const messagesResponse = await args.client.session.messages({
       path: { id: agentSessionId },
       query: { directory: args.sessionDirectory ?? args.projectIdentity }
@@ -167516,15 +168308,15 @@ Only include notes whose conditions you could definitively evaluate. Skip notes
     });
   } catch (error51) {
     const durationMs = Date.now() - taskStartedAt;
-    const errorMsg = getErrorMessage(error51);
+    const errorDescription = describeError(error51);
     args.result.smartNotesSurfaced = 0;
     args.result.smartNotesPending = pendingNotes.length;
-    log(`[dreamer] smart notes: failed after ${(durationMs / 1000).toFixed(1)}s — ${errorMsg}`);
+    logWithStackHead(`[dreamer] smart notes: failed after ${(durationMs / 1000).toFixed(1)}s — ${errorDescription.brief}`, errorDescription.stackHead);
     args.result.tasks.push({
       name: "smart-notes",
       durationMs,
       result: null,
-      error: errorMsg
+      error: errorDescription.brief
     });
   } finally {
     clearInterval(leaseInterval);
@@ -167557,7 +168349,8 @@ async function processDreamQueue(args) {
       maxRuntimeMinutes: args.maxRuntimeMinutes,
       sessionDirectory: projectDirectory,
       experimentalUserMemories: args.experimentalUserMemories,
-      experimentalPinKeyFiles: args.experimentalPinKeyFiles
+      experimentalPinKeyFiles: args.experimentalPinKeyFiles,
+      fallbackModels: args.fallbackModels
     });
   } catch (error51) {
     log(`[dreamer] runDream threw for ${entry.projectIdentity}: ${getErrorMessage(error51)}`);
@@ -168165,6 +168958,7 @@ function searchGitCommitsSync(db, projectPath, query, options) {
 init_embedding();
 init_project_identity();
 init_logger();
+init_resolve_fallbacks();
 await init_storage();
 var DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
 var activeTimer = null;
@@ -168251,7 +169045,8 @@ async function sweepProject(reg, origin) {
       maxRuntimeMinutes: reg.dreamerConfig.max_runtime_minutes,
       experimentalUserMemories: reg.experimentalUserMemories,
       experimentalPinKeyFiles: reg.experimentalPinKeyFiles,
-      projectIdentity: registrationIdentity
+      projectIdentity: registrationIdentity,
+      fallbackModels: resolveFallbackChain(DREAMER_AGENT, reg.dreamerConfig.fallback_models)
     });
   } catch (error51) {
     log(`[dreamer] timer-triggered queue processing failed for ${reg.directory}:`, error51);
@@ -168779,6 +169574,7 @@ function createTagger() {
 init_magic_context();
 init_project_identity();
 init_logger();
+init_resolve_fallbacks();
 await init_storage();
 
 // src/hooks/magic-context/command-handler.ts
@@ -169259,7 +170055,8 @@ Dreaming is not configured for this project.`, {});
     maxRuntimeMinutes: deps.dreamer.config.max_runtime_minutes,
     experimentalUserMemories: deps.dreamer.experimentalUserMemories,
     experimentalPinKeyFiles: deps.dreamer.experimentalPinKeyFiles,
-    projectIdentity: deps.dreamer.projectPath
+    projectIdentity: deps.dreamer.projectPath,
+    fallbackModels: deps.dreamer.fallbackModels
   });
   await deps.sendNotification(sessionId, result ? summarizeDreamResult(result) : "Dream queued, but another worker is already processing the queue.", {});
   throwSentinel("CTX-DREAM");
@@ -169555,113 +170352,8 @@ function clearSessionTracking(sessionId) {
   }
 }
 
-// src/features/magic-context/overflow-detection.ts
-var OVERFLOW_PATTERNS = [
-  /prompt is too long/i,
-  /input is too long for requested model/i,
-  /exceeds the context window/i,
-  /input token count.*exceeds the maximum/i,
-  /maximum prompt length is \d+/i,
-  /reduce the length of the messages/i,
-  /maximum context length is \d+ tokens/i,
-  /exceeds the limit of \d+/i,
-  /exceeds the available context size/i,
-  /greater than the context length/i,
-  /context window exceeds limit/i,
-  /exceeded model token limit/i,
-  /context[_ ]length[_ ]exceeded/i,
-  /request entity too large/i,
-  /context length is only \d+ tokens/i,
-  /input length.*exceeds.*context length/i,
-  /prompt too long; exceeded (?:max )?context length/i,
-  /too large for model with \d+ maximum context length/i,
-  /model_context_window_exceeded/i,
-  /context size has been exceeded/i
-];
-var LIMIT_EXTRACTION_PATTERNS = [
-  /maximum prompt length is (\d+)/i,
-  /maximum context length is (\d+) tokens?/i,
-  /context length is only (\d+) tokens?/i,
-  /exceeds the limit of (\d+)/i,
-  /too large for model with (\d+) maximum context length/i,
-  /context size.*(\d+) tokens?/i,
-  /exceeds? the context length of (\d+)/i,
-  /max(?:imum)?.*context.*?(\d+)/i
-];
-var MIN_PLAUSIBLE_LIMIT = 1024;
-var MAX_PLAUSIBLE_LIMIT = 1e7;
-function extractErrorMessage(error51) {
-  if (!error51)
-    return "";
-  if (typeof error51 === "string")
-    return error51;
-  if (typeof error51 === "object") {
-    const obj = error51;
-    const nested = obj.error;
-    if (nested && typeof nested.message === "string" && nested.message.length > 0) {
-      return nested.message;
-    }
-  }
-  if (error51 instanceof Error)
-    return error51.message;
-  if (typeof error51 === "object") {
-    const obj = error51;
-    if (typeof obj.message === "string")
-      return obj.message;
-    if (typeof obj.responseBody === "string")
-      return obj.responseBody;
-    try {
-      return JSON.stringify(error51);
-    } catch {
-      return String(error51);
-    }
-  }
-  return String(error51);
-}
-function detectOverflow(error51) {
-  const message = extractErrorMessage(error51);
-  if (!message) {
-    return { isOverflow: false };
-  }
-  const hasStatus413 = /\b413\b/.test(message) && /(entity|payload|context|prompt)/i.test(message);
-  let matched;
-  for (const pattern of OVERFLOW_PATTERNS) {
-    if (pattern.test(message)) {
-      matched = pattern;
-      break;
-    }
-  }
-  if (!matched && !hasStatus413) {
-    return { isOverflow: false };
-  }
-  const reportedLimit = parseReportedLimit(message);
-  return {
-    isOverflow: true,
-    reportedLimit,
-    matchedPattern: matched?.source
-  };
-}
-function parseReportedLimit(message) {
-  if (!message)
-    return;
-  for (const pattern of LIMIT_EXTRACTION_PATTERNS) {
-    const match = message.match(pattern);
-    if (!match)
-      continue;
-    const raw = match[1];
-    if (!raw)
-      continue;
-    const value = Number.parseInt(raw, 10);
-    if (!Number.isFinite(value))
-      continue;
-    if (value < MIN_PLAUSIBLE_LIMIT || value > MAX_PLAUSIBLE_LIMIT)
-      continue;
-    return value;
-  }
-  return;
-}
-
 // src/hooks/magic-context/event-handler.ts
+init_overflow_detection();
 init_storage_meta_persisted();
 init_logger();
 await __promiseAll([
@@ -169774,6 +170466,15 @@ init_project_identity();
 init_logger();
 await init_storage();
 
+// src/hooks/magic-context/cache-busting-signals.ts
+function canConsumeDeferredOnThisPass(args) {
+  if (args.justAwaitedPublication)
+    return true;
+  if (args.activeRunBlocksMaterialization)
+    return false;
+  return args.schedulerDecision === "execute" || args.contextPercentage >= FORCE_MATERIALIZE_PERCENTAGE;
+}
+
 // src/hooks/magic-context/caveman-cleanup.ts
 init_shared();
 init_caveman();
@@ -170521,6 +171222,9 @@ function clearCompressorCooldown(sessionId) {
 async function runCompartmentPhase(args) {
   let pendingCompartmentInjection = args.pendingCompartmentInjection;
   let compartmentInProgress = args.sessionMeta.compartmentInProgress;
+  let published = false;
+  let justAwaitedPublication = false;
+  let rebuiltHistoryThisPass = false;
   let lastCompartmentEnd = null;
   let rawMessageCount = null;
   let cachedProtectedTailStart = null;
@@ -170548,13 +171252,19 @@ async function runCompartmentPhase(args) {
     sessionLog(args.sessionId, reason);
     const timeoutMs = args.historianTimeoutMs ?? 120000;
     const timeout = new Promise((resolve4) => setTimeout(() => resolve4("timeout"), timeoutMs));
-    const result = await Promise.race([activeRun.then(() => "done"), timeout]);
+    const result = await Promise.race([activeRun.promise.then(() => "done"), timeout]);
     if (result === "timeout") {
       sessionLog(args.sessionId, `transform: compartment await timed out after ${timeoutMs}ms — proceeding without waiting`);
       return "timed_out";
     }
     sessionLog(args.sessionId, "transform: compartment agent completed, refreshing compartment coverage");
-    pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.resolvedSessionId, args.messages, args.cacheAlreadyBusting ?? false, args.projectPath, args.injectionBudgetTokens, args.experimentalTemporalAwareness);
+    justAwaitedPublication = activeRun.published;
+    published = published || activeRun.published;
+    const historyReprepareShouldBust = activeRun.published && args.deferredHistoryRefreshSessions.has(args.sessionId);
+    pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.resolvedSessionId, args.messages, historyReprepareShouldBust, args.projectPath, args.injectionBudgetTokens, args.experimentalTemporalAwareness);
+    if (historyReprepareShouldBust) {
+      rebuiltHistoryThisPass = true;
+    }
     return "completed";
   }
   if (args.canRunCompartments && args.sessionMeta.compartmentInProgress && !getActiveCompartmentRun(args.sessionId)) {
@@ -170575,6 +171285,7 @@ async function runCompartmentPhase(args) {
         historianChunkTokens: args.historianChunkTokens,
         historyBudgetTokens: args.historyBudgetTokens,
         historianTimeoutMs: args.historianTimeoutMs,
+        fallbackModels: args.fallbackModels,
         directory: args.compartmentDirectory,
         fallbackModelId: args.fallbackModelId,
         getNotificationParams: args.getNotificationParams,
@@ -170585,7 +171296,8 @@ async function runCompartmentPhase(args) {
         compressorMaxMergeDepth: args.compressorMaxMergeDepth,
         memoryEnabled: args.memoryEnabled,
         autoPromote: args.autoPromote,
-        onInjectionCacheCleared: args.onInjectionCacheCleared
+        onCompartmentStatePublished: args.onCompartmentStatePublished,
+        preserveInjectionCacheUntilConsumed: true
       });
       compartmentInProgress = true;
     }
@@ -170602,6 +171314,7 @@ async function runCompartmentPhase(args) {
         historianChunkTokens: args.historianChunkTokens,
         historyBudgetTokens: args.historyBudgetTokens,
         historianTimeoutMs: args.historianTimeoutMs,
+        fallbackModels: args.fallbackModels,
         directory: args.compartmentDirectory,
         fallbackModelId: args.fallbackModelId,
         getNotificationParams: args.getNotificationParams,
@@ -170612,7 +171325,8 @@ async function runCompartmentPhase(args) {
         compressorMaxMergeDepth: args.compressorMaxMergeDepth,
         memoryEnabled: args.memoryEnabled,
         autoPromote: args.autoPromote,
-        onInjectionCacheCleared: args.onInjectionCacheCleared
+        onCompartmentStatePublished: args.onCompartmentStatePublished,
+        preserveInjectionCacheUntilConsumed: true
       });
       activeRun = getActiveCompartmentRun(args.sessionId);
     } else if (!activeRun && hasEligibleHistoryForCompartment()) {
@@ -170632,7 +171346,7 @@ async function runCompartmentPhase(args) {
       }
     }
   }
-  if (args.cacheAlreadyBusting && args.historyBudgetTokens && args.historyBudgetTokens > 0 && args.client && !compartmentInProgress && !awaitedCompartmentRun && !isCompressorOnCooldown(args.sessionId, args.compressorCooldownMs ?? DEFAULT_COMPRESSOR_COOLDOWN_MS)) {
+  if (args.safeForBackgroundCompression && !args.suppressBackgroundCompressionThisPass && args.historyBudgetTokens && args.historyBudgetTokens > 0 && args.client && !compartmentInProgress && !awaitedCompartmentRun && !isCompressorOnCooldown(args.sessionId, args.compressorCooldownMs ?? DEFAULT_COMPRESSOR_COOLDOWN_MS)) {
     markCompressorRun(args.sessionId);
     const compressorPromise = runCompressionPassIfNeeded({
       client: args.client,
@@ -170641,10 +171355,14 @@ async function runCompartmentPhase(args) {
       directory: args.compartmentDirectory,
       historyBudgetTokens: args.historyBudgetTokens,
       historianTimeoutMs: args.historianTimeoutMs,
+      fallbackModels: args.fallbackModels,
       minCompartmentRatio: args.compressorMinCompartmentRatio,
       maxMergeDepth: args.compressorMaxMergeDepth
     }).then((compressed) => {
       if (compressed) {
+        markActiveCompartmentRunPublished(args.sessionId);
+        published = true;
+        args.deferredHistoryRefreshSessions.add(args.sessionId);
         sessionLog(args.sessionId, "independent compressor completed in background — compressed history will appear on next cache-busting pass");
       }
     }).catch((error51) => {
@@ -170652,7 +171370,14 @@ async function runCompartmentPhase(args) {
     });
     registerActiveCompartmentRun(args.sessionId, compressorPromise);
   }
-  return { pendingCompartmentInjection, awaitedCompartmentRun, compartmentInProgress };
+  return {
+    pendingCompartmentInjection,
+    awaitedCompartmentRun,
+    compartmentInProgress,
+    published,
+    justAwaitedPublication,
+    rebuiltHistoryThisPass
+  };
 }
 
 // src/hooks/magic-context/transform-context-state.ts
@@ -170738,6 +171463,46 @@ function countMessagesSinceLastUser(messages) {
   }
   return messagesSinceLastUser;
 }
+function injectToolPartIntoLatestAssistant(messages, part) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.info.role !== "assistant")
+      continue;
+    if (typeof message.info.id !== "string")
+      continue;
+    if (hasToolPartWithCallId(message, part.callID)) {
+      return message.info.id;
+    }
+    message.parts.push(part);
+    return message.info.id;
+  }
+  return null;
+}
+function injectToolPartIntoAssistantById(messages, messageId, part) {
+  for (const message of messages) {
+    if (message.info.id !== messageId)
+      continue;
+    if (message.info.role !== "assistant")
+      continue;
+    if (hasToolPartWithCallId(message, part.callID))
+      return true;
+    message.parts.push(part);
+    return true;
+  }
+  return false;
+}
+function hasToolPartWithCallId(message, callId) {
+  for (const part of message.parts) {
+    if (part === null || typeof part !== "object")
+      continue;
+    const p = part;
+    if (p.type !== "tool")
+      continue;
+    if (p.callID === callId)
+      return true;
+  }
+  return false;
+}
 function appendReminderToUserMessage(message, reminder) {
   for (const part of message.parts) {
     if (!isTextPart(part)) {
@@ -171974,7 +172739,10 @@ function clearAutoSearchForSession(sessionId) {
 }
 
 // src/hooks/magic-context/transform-postprocess-phase.ts
-await init_compartment_runner();
+await __promiseAll([
+  init_compaction_marker_manager(),
+  init_compartment_runner()
+]);
 
 // src/hooks/magic-context/heuristic-cleanup.ts
 init_shared();
@@ -172247,6 +173015,84 @@ function isVisibleNoteReadPart(part) {
   return false;
 }
 
+// src/hooks/magic-context/todo-view.ts
+import { createHash as createHash5 } from "node:crypto";
+var TERMINAL_STATUSES = new Set(["completed", "cancelled"]);
+var TITLE_DONE_STATUSES = new Set(["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
+    });
+  }
+  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 hash2 = createHash5("sha256").update(stateJson).digest("hex").slice(0, 16);
+  return `${SYNTHETIC_CALL_ID_PREFIX}${hash2}`;
+}
+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))
+        continue;
+      result.push({
+        content: item.content,
+        status: item.status,
+        priority: item.priority
+      });
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function isTodoItem(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const todo = value;
+  return typeof todo.content === "string" && typeof todo.status === "string" && typeof todo.priority === "string";
+}
+
 // src/hooks/magic-context/transform-stage-logger.ts
 init_logger();
 function logTransformTiming(sessionId, stage, startMs, extra) {
@@ -172256,26 +173102,34 @@ function logTransformTiming(sessionId, stage, startMs, extra) {
 }
 
 // src/hooks/magic-context/transform-postprocess-phase.ts
+var DEGRADE_CACHE_WARNING_THRESHOLD = 10;
+var degradedCacheCountBySession = new Map;
+function resetDegradedCacheCount(sessionId) {
+  degradedCacheCountBySession.delete(sessionId);
+}
 async function runPostTransformPhase(args) {
   let didMutateFromPendingOperations = false;
   const isExplicitFlush = args.pendingMaterializationSessions.has(args.sessionId);
+  const deferredMaterializationWasPending = args.deferredMaterializationSessions.has(args.sessionId);
   const alreadyRanThisTurn = args.currentTurnId !== null && args.lastHeuristicsTurnId.get(args.sessionId) === args.currentTurnId;
   const forceMaterialization = args.fullFeatureMode && args.contextUsage.percentage >= args.forceMaterializationPercentage;
   const activeCompartmentRun = args.canRunCompartments ? getActiveCompartmentRun(args.sessionId) : undefined;
   const compartmentRunning = args.canRunCompartments && !args.awaitedCompartmentRun && activeCompartmentRun !== undefined;
   const emergencyBypassCompartmentGate = forceMaterialization;
-  const shouldReadPendingOps = isExplicitFlush || args.schedulerDecision === "execute" || forceMaterialization || compartmentRunning;
+  const deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
+  const materializationRequested = isExplicitFlush || deferredMaterialize;
+  const shouldReadPendingOps = materializationRequested || args.schedulerDecision === "execute" || forceMaterialization || compartmentRunning;
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
-  const shouldApplyPendingOps = (args.schedulerDecision === "execute" || isExplicitFlush || forceMaterialization) && (!compartmentRunning || emergencyBypassCompartmentGate);
-  const shouldRunHeuristics = (!compartmentRunning || emergencyBypassCompartmentGate) && (isExplicitFlush || forceMaterialization || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const shouldApplyPendingOps = (args.schedulerDecision === "execute" || materializationRequested || forceMaterialization) && (!compartmentRunning || emergencyBypassCompartmentGate);
+  const shouldRunHeuristics = (!compartmentRunning || emergencyBypassCompartmentGate) && (materializationRequested || forceMaterialization || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = shouldApplyPendingOps || shouldRunHeuristics;
   if (shouldRunHeuristics) {
     const subagentRerun = !args.fullFeatureMode && alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && !forceMaterialization;
-    const reason = isExplicitFlush ? "explicit_flush" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : subagentRerun ? `scheduler_execute_subagent_rerun (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})` : `scheduler_execute (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
+    const reason = isExplicitFlush ? "explicit_flush" : deferredMaterialize ? "deferred_materialization" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : subagentRerun ? `scheduler_execute_subagent_rerun (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})` : `scheduler_execute (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     sessionLog(args.sessionId, `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=${args.currentTurnId}`);
   }
-  if (alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && args.fullFeatureMode) {
+  if (alreadyRanThisTurn && args.schedulerDecision === "execute" && !materializationRequested && args.fullFeatureMode) {
     sessionLog(args.sessionId, `transform: skipping heuristics (already ran for turn ${args.currentTurnId})`);
   }
   if (compartmentRunning && hasPendingUserOps) {
@@ -172285,9 +173139,11 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, "transform: deferring pending ops — compartment agent in progress");
     }
   }
+  let explicitMaterializedSuccessfully = false;
+  let deferredMaterializedSuccessfully = false;
   try {
     if (shouldApplyPendingOps) {
-      const applyReason = isExplicitFlush ? "explicit_flush" : `scheduler_execute (scheduler=${args.schedulerDecision})`;
+      const applyReason = isExplicitFlush ? "explicit_flush" : deferredMaterialize ? "deferred_materialization" : `scheduler_execute (scheduler=${args.schedulerDecision})`;
       sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOps.length}, context=${args.contextUsage.percentage.toFixed(1)}%`);
       const pendingCountBefore = pendingOps.length;
       const tApply = performance.now();
@@ -172349,7 +173205,7 @@ async function runPostTransformPhase(args) {
         args.lastHeuristicsTurnId.set(args.sessionId, args.currentTurnId);
       }
     }
-    if (args.schedulerDecision === "execute" && !isExplicitFlush) {
+    if (args.schedulerDecision === "execute" && !materializationRequested) {
       updateSessionMeta(args.db, args.sessionId, { lastResponseTime: Date.now() });
     }
     args.batch?.finalize();
@@ -172357,6 +173213,12 @@ async function runPostTransformPhase(args) {
     if (args.sessionMeta.lastTransformError !== null) {
       updateSessionMeta(args.db, args.sessionId, { lastTransformError: null });
     }
+    if (shouldRunHeuristics) {
+      if (isExplicitFlush)
+        explicitMaterializedSuccessfully = true;
+      if (deferredMaterialize)
+        deferredMaterializedSuccessfully = true;
+    }
   } catch (error51) {
     sessionLog(args.sessionId, "transform failed applying pending operations:", error51);
     updateSessionMeta(args.db, args.sessionId, { lastTransformError: getErrorMessage(error51) });
@@ -172488,6 +173350,72 @@ async function runPostTransformPhase(args) {
     const anchoredMessageId = appendReminderToLatestUserMessage(args.messages, noteInstruction);
     markNoteNudgeDelivered(args.db, args.sessionId, noteInstruction, anchoredMessageId);
   }
+  if (args.fullFeatureMode) {
+    const persistedAnchor = getPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+    if (isCacheBustingPass) {
+      const part = buildSyntheticTodoPart(args.sessionMeta.lastTodoState);
+      if (part === null) {
+        if (persistedAnchor) {
+          clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+        }
+      } else if (persistedAnchor && persistedAnchor.callId === part.callID && injectToolPartIntoAssistantById(args.messages, persistedAnchor.messageId, part)) {
+        if (persistedAnchor.stateJson.length === 0) {
+          setPersistedTodoSyntheticAnchor(args.db, args.sessionId, persistedAnchor.callId, persistedAnchor.messageId, args.sessionMeta.lastTodoState);
+        }
+      } else {
+        const anchoredMessageId = injectToolPartIntoLatestAssistant(args.messages, part);
+        if (anchoredMessageId) {
+          setPersistedTodoSyntheticAnchor(args.db, args.sessionId, part.callID, anchoredMessageId, args.sessionMeta.lastTodoState);
+        } else if (persistedAnchor) {
+          clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+        }
+      }
+    } else if (persistedAnchor && persistedAnchor.stateJson.length > 0) {
+      const part = buildSyntheticTodoPart(persistedAnchor.stateJson);
+      if (part !== null && part.callID === persistedAnchor.callId) {
+        injectToolPartIntoAssistantById(args.messages, persistedAnchor.messageId, part);
+      }
+    }
+  }
+  const explicitRebuildHappened = args.historyRefreshExplicitBeforePrepare && args.rebuiltHistoryFromInitialPrepare;
+  const materializationSatisfied = !deferredMaterializationWasPending || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully;
+  const historyWasConsumedThisPass = args.historyRebuiltThisPass && (args.canConsumeDeferredLate || args.phaseJustAwaitedPublication || explicitRebuildHappened) && materializationSatisfied;
+  if (args.compartmentInjectionRebuiltFromDb && args.pendingCompartmentInjection) {
+    if (args.pendingCompartmentInjection.compartmentEndMessageId === null) {
+      const nextCount = (degradedCacheCountBySession.get(args.sessionId) ?? 0) + 1;
+      degradedCacheCountBySession.set(args.sessionId, nextCount);
+      if (nextCount === DEGRADE_CACHE_WARNING_THRESHOLD) {
+        sessionLog(args.sessionId, `WARNING: compartment injection cache has rebuilt with a degraded null boundary ${nextCount} consecutive times; investigate missing boundary messages`);
+      }
+    } else {
+      degradedCacheCountBySession.delete(args.sessionId);
+    }
+  }
+  let suppressV12HistoryDrain = false;
+  if (historyWasConsumedThisPass && args.deferredHistoryRefreshSessions.has(args.sessionId)) {
+    const pending = getPendingCompactionMarkerState(args.db, args.sessionId);
+    if (pending) {
+      const outcome = applyDeferredCompactionMarker(args.db, args.sessionId, pending, args.sessionDirectory);
+      switch (outcome.kind) {
+        case "applied":
+        case "already-current":
+        case "stale-skip":
+          clearPendingCompactionMarkerStateIf(args.db, args.sessionId, pending);
+          break;
+        case "retryable-failure":
+          sessionLog(args.sessionId, "compaction-marker drain: retryable failure; preserving deferred history refresh signal", outcome.error);
+          suppressV12HistoryDrain = true;
+          break;
+      }
+    }
+  }
+  const deferredHistoryDrainEligible = historyWasConsumedThisPass && !suppressV12HistoryDrain;
+  if (deferredHistoryDrainEligible) {
+    args.deferredHistoryRefreshSessions.delete(args.sessionId);
+  }
+  if (explicitMaterializedSuccessfully || deferredMaterializedSuccessfully) {
+    args.deferredMaterializationSessions.delete(args.sessionId);
+  }
   if (args.fullFeatureMode && args.autoSearch?.enabled && args.projectPath) {
     const visibleMemoryIds = getVisibleMemoryIds(args.db, args.sessionId) ?? undefined;
     try {
@@ -172510,6 +173438,7 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, "auto-search runner failed:", error51);
     }
   }
+  return { explicitMaterializedSuccessfully, deferredMaterializedSuccessfully };
 }
 
 // src/hooks/magic-context/nudge-placement-store.ts
@@ -172583,6 +173512,8 @@ function findLastAssistantModel(messages) {
 function createTransform(deps) {
   const loadedSessions = new Set;
   const lastEmergencyNotificationCount = new Map;
+  const deferredHistoryRefreshSessions = deps.deferredHistoryRefreshSessions ?? new Set;
+  const deferredMaterializationSessions = deps.deferredMaterializationSessions ?? new Set;
   return async (_input, output) => {
     const startTime = performance.now();
     const messages = output.messages;
@@ -172691,7 +173622,17 @@ function createTransform(deps) {
     }
     const historyBudgetTokens = resolveHistoryBudgetTokens(deps.historyBudgetPercentage, contextUsageEarly, deps.executeThresholdPercentage, deps.getModelKey?.(sessionId), deps.executeThresholdTokens);
     const schedulerDecisionEarly = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId));
-    const isCacheBusting = deps.historyRefreshSessions.has(sessionId);
+    const historyRefreshExplicitBeforePrepare = deps.historyRefreshSessions.has(sessionId);
+    const earlyActiveRunBlocksMaterialization = (getActiveCompartmentRun(sessionId) !== undefined || sessionMeta.compartmentInProgress) && contextUsageEarly.percentage < FORCE_MATERIALIZE_PERCENTAGE;
+    const canConsumeDeferredEarly = canConsumeDeferredOnThisPass({
+      schedulerDecision: schedulerDecisionEarly,
+      contextPercentage: contextUsageEarly.percentage,
+      justAwaitedPublication: false,
+      activeRunBlocksMaterialization: earlyActiveRunBlocksMaterialization
+    });
+    const consumingDeferredEarly = canConsumeDeferredEarly && deferredHistoryRefreshSessions.has(sessionId);
+    const isCacheBusting = historyRefreshExplicitBeforePrepare || consumingDeferredEarly;
+    const historyBustThisPass = isCacheBusting;
     if (historianFailureState.failureCount === 0) {
       lastEmergencyNotificationCount.delete(sessionId);
     }
@@ -172719,6 +173660,7 @@ function createTransform(deps) {
         historianChunkTokens: deps.getHistorianChunkTokens?.() ?? 20000,
         historyBudgetTokens,
         historianTimeoutMs: deps.historianTimeoutMs,
+        fallbackModels: deps.fallbackModels,
         directory: compartmentDirectory,
         fallbackModelId,
         getNotificationParams: () => notificationParams,
@@ -172730,9 +173672,10 @@ function createTransform(deps) {
         compressorMaxMergeDepth: deps.compressorMaxMergeDepth,
         memoryEnabled: deps.memoryConfig?.enabled,
         autoPromote: deps.memoryConfig?.autoPromote,
-        onInjectionCacheCleared: (sid) => {
-          deps.historyRefreshSessions.add(sid);
-          deps.pendingMaterializationSessions.add(sid);
+        preserveInjectionCacheUntilConsumed: true,
+        onCompartmentStatePublished: (sid) => {
+          deferredHistoryRefreshSessions.add(sid);
+          deferredMaterializationSessions.add(sid);
         }
       });
       skipCompartmentAwaitForThisPass = true;
@@ -172765,11 +173708,15 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
     logTransformTiming(sessionId, "emergencyRecoveryBlock", tFirstPass);
     const projectIdentity = deps.memoryConfig?.enabled ? resolveProjectIdentity(compartmentDirectory || process.cwd()) : undefined;
     let pendingCompartmentInjection = null;
+    let rebuiltHistoryFromInitialPrepare = false;
     if (fullFeatureMode) {
       const tInj = performance.now();
       pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectIdentity, deps.memoryConfig?.injectionBudgetTokens, deps.experimentalTemporalAwareness);
       logTransformTiming(sessionId, "prepareCompartmentInjection", tInj);
       if (isCacheBusting) {
+        rebuiltHistoryFromInitialPrepare = true;
+      }
+      if (historyRefreshExplicitBeforePrepare) {
         deps.historyRefreshSessions.delete(sessionId);
       }
     }
@@ -172888,6 +173835,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       historianChunkTokens: deps.getHistorianChunkTokens?.() ?? 20000,
       historyBudgetTokens,
       historianTimeoutMs: deps.historianTimeoutMs,
+      fallbackModels: deps.fallbackModels,
       compartmentDirectory,
       messages,
       pendingCompartmentInjection,
@@ -172895,7 +173843,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       projectPath: projectIdentity,
       injectionBudgetTokens: deps.memoryConfig?.injectionBudgetTokens,
       getNotificationParams: rawGetNotifParams ? () => rawGetNotifParams(sessionId) : undefined,
-      cacheAlreadyBusting: isCacheBusting || schedulerDecisionEarly === "execute",
+      safeForBackgroundCompression: isCacheBusting || schedulerDecisionEarly === "execute",
+      suppressBackgroundCompressionThisPass: historyBustThisPass,
+      deferredHistoryRefreshSessions,
       skipAwaitForThisPass: skipCompartmentAwaitForThisPass,
       experimentalCompactionMarkers: deps.experimentalCompactionMarkers,
       experimentalUserMemories: deps.experimentalUserMemories,
@@ -172906,9 +173856,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       compressorCooldownMs: deps.compressorCooldownMs,
       memoryEnabled: deps.memoryConfig?.enabled,
       autoPromote: deps.memoryConfig?.autoPromote,
-      onInjectionCacheCleared: (sid) => {
-        deps.historyRefreshSessions.add(sid);
-        deps.pendingMaterializationSessions.add(sid);
+      onCompartmentStatePublished: (sid) => {
+        deferredHistoryRefreshSessions.add(sid);
+        deferredMaterializationSessions.add(sid);
       }
     });
     pendingCompartmentInjection = compartmentPhase.pendingCompartmentInjection;
@@ -172916,6 +173866,15 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
     const compartmentInProgress = compartmentPhase.compartmentInProgress;
     sessionMeta = { ...sessionMeta, compartmentInProgress };
     logTransformTiming(sessionId, "compartmentPhase", tCompartmentPhase);
+    const lateActiveRunBlocksMaterialization = getActiveCompartmentRun(sessionId) !== undefined && contextUsageEarly.percentage < FORCE_MATERIALIZE_PERCENTAGE;
+    const canConsumeDeferredLate = canConsumeDeferredOnThisPass({
+      schedulerDecision: schedulerDecisionEarly,
+      contextPercentage: contextUsageEarly.percentage,
+      justAwaitedPublication: compartmentPhase.justAwaitedPublication,
+      activeRunBlocksMaterialization: lateActiveRunBlocksMaterialization
+    });
+    const wasEmergencyBlock = contextUsageEarly.percentage >= FORCE_MATERIALIZE_PERCENTAGE && compartmentPhase.justAwaitedPublication;
+    const historyRebuiltThisPass = wasEmergencyBlock ? compartmentPhase.rebuiltHistoryThisPass : rebuiltHistoryFromInitialPrepare || compartmentPhase.rebuiltHistoryThisPass;
     const tPostProcess = performance.now();
     await runPostTransformPhase({
       sessionId,
@@ -172931,10 +173890,18 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       fullFeatureMode,
       canRunCompartments,
       awaitedCompartmentRun,
+      phaseJustAwaitedPublication: compartmentPhase.justAwaitedPublication,
       compartmentInProgress,
+      historyRefreshExplicitBeforePrepare,
+      compartmentInjectionRebuiltFromDb: pendingCompartmentInjection?.rebuiltFromDb === true,
+      rebuiltHistoryFromInitialPrepare,
+      historyRebuiltThisPass,
+      canConsumeDeferredLate,
       sessionMeta,
       currentTurnId,
       pendingMaterializationSessions: deps.pendingMaterializationSessions,
+      deferredHistoryRefreshSessions,
+      deferredMaterializationSessions,
       lastHeuristicsTurnId: deps.lastHeuristicsTurnId,
       autoDropToolAge: deps.autoDropToolAge,
       dropToolStructure: deps.dropToolStructure ?? true,
@@ -172948,6 +173915,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       forceMaterializationPercentage: FORCE_MATERIALIZE_PERCENTAGE,
       hasRecentReduceCall,
       projectPath: deps.projectPath,
+      sessionDirectory,
       autoSearch: deps.autoSearch,
       cavemanTextCompression: deps.ctxReduceEnabled === false && !reducedMode ? deps.cavemanTextCompression : undefined,
       liveProviderID
@@ -173355,6 +174323,15 @@ function createEventHandler2(deps) {
       } catch (error51) {
         sessionLog(sessionId, "event session.compacted marker cleanup failed:", error51);
       }
+      try {
+        const pending = getPendingCompactionMarkerState(deps.db, sessionId);
+        if (pending) {
+          clearPendingCompactionMarkerStateIf(deps.db, sessionId, pending);
+        }
+      } catch (error51) {
+        sessionLog(sessionId, "event session.compacted pending-marker cleanup failed:", error51);
+      }
+      resetDegradedCacheCount(sessionId);
       clearMessageTokensCache(sessionId);
       deps.onSessionCacheInvalidated?.(sessionId);
       return;
@@ -173371,6 +174348,7 @@ function createEventHandler2(deps) {
       } catch (error51) {
         sessionLog(sessionId, "event session.deleted persistence failed:", error51);
       }
+      resetDegradedCacheCount(sessionId);
       deps.onSessionCacheInvalidated?.(sessionId);
       deps.onSessionDeleted?.(sessionId);
       deps.contextUsageMap.delete(sessionId);
@@ -173579,6 +174557,10 @@ function applyStickySnapshotCache(sessionId, fresh) {
     cache.delete(sessionId);
     return fresh;
   }
+  if (!hasInFlightEvidence(fresh)) {
+    cache.delete(sessionId);
+    return fresh;
+  }
   return {
     ...fresh,
     usagePercentage: cached2.snapshot.usagePercentage,
@@ -173592,6 +174574,9 @@ function applyStickySnapshotCache(sessionId, fresh) {
     toolDefinitionTokens: cached2.snapshot.toolDefinitionTokens
   };
 }
+function hasInFlightEvidence(snapshot) {
+  return snapshot.compartmentInProgress || snapshot.historianRunning || snapshot.pendingOpsCount > 0;
+}
 function clearSidebarSnapshotCache(sessionId) {
   cache.delete(sessionId);
 }
@@ -173692,8 +174677,10 @@ function createEventHook(args) {
       args.recentReduceBySession.delete(sessionId);
       args.toolUsageSinceUserTurn.delete(sessionId);
       args.historyRefreshSessions.delete(sessionId);
+      args.deferredHistoryRefreshSessions.delete(sessionId);
       args.systemPromptRefreshSessions.delete(sessionId);
       args.pendingMaterializationSessions.delete(sessionId);
+      args.deferredMaterializationSessions.delete(sessionId);
       args.lastHeuristicsTurnId.delete(sessionId);
       args.commitSeenLastPass?.delete(sessionId);
       clearNoteNudgeState(args.db, sessionId);
@@ -173728,9 +174715,17 @@ function createToolExecuteAfterHook(args) {
     if (typedInput.tool === "todowrite") {
       const todoArgs = typedInput.args;
       const todos = todoArgs?.todos;
-      if (Array.isArray(todos) && todos.length > 0 && todos.every((t) => t.status === "completed" || t.status === "cancelled")) {
-        const sessionMeta = getOrCreateSessionMeta(args.db, typedInput.sessionID);
-        if (!sessionMeta.isSubagent) {
+      const sessionMeta = Array.isArray(todos) ? getOrCreateSessionMeta(args.db, typedInput.sessionID) : null;
+      if (sessionMeta && !sessionMeta.isSubagent) {
+        const normalizedTodos = normalizeTodoStateJson(todos);
+        if (normalizedTodos !== null) {
+          updateSessionMeta(args.db, typedInput.sessionID, {
+            lastTodoState: normalizedTodos
+          });
+        }
+      }
+      if (Array.isArray(todos) && todos.length > 0 && todos.every((t) => typeof t === "object" && t !== null && (t.status === "completed" || t.status === "cancelled"))) {
+        if (sessionMeta && !sessionMeta.isSubagent) {
           onNoteTrigger(args.db, typedInput.sessionID, "todos_complete");
         }
       }
@@ -173746,9 +174741,9 @@ function createToolExecuteAfterHook(args) {
 init_send_session_notification();
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync13, readFileSync as readFileSync9, realpathSync } from "node:fs";
-import { join as join22, resolve as resolve4, sep } from "node:path";
+import { join as join21, resolve as resolve4, sep } from "node:path";
 
 // src/agents/magic-context-prompt.ts
 function getToolHistoryGuidance(dropToolStructure) {
@@ -173861,7 +174856,7 @@ var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join22(directory, filename);
+    const filePath = join21(directory, filename);
     try {
       if (existsSync13(filePath)) {
         const content = readFileSync9(filePath, "utf-8").trim();
@@ -174051,7 +175046,7 @@ ${sections.join(`
 `);
     if (systemContent.length === 0)
       return;
-    const currentHash = createHash4("md5").update(systemContent).digest("hex");
+    const currentHash = createHash6("md5").update(systemContent).digest("hex");
     if (!sessionMetaEarly) {
       return;
     }
@@ -174066,14 +175061,12 @@ ${sections.join(`
     } else if (previousHash === "" || previousHash === "0") {
       sessionLog(sessionId, `system prompt hash initialized: ${currentHash} (len=${systemContent.length})`);
     }
-    const systemPromptTokens = estimateTokens(systemContent);
     if (currentHash !== previousHash) {
+      const systemPromptTokens = estimateTokens(systemContent);
       updateSessionMeta(deps.db, sessionId, {
         systemPromptHash: currentHash,
         systemPromptTokens
       });
-    } else if (Math.abs(sessionMeta.systemPromptTokens - systemPromptTokens) > 50) {
-      updateSessionMeta(deps.db, sessionId, { systemPromptTokens });
     }
     if (isCacheBusting) {
       deps.systemPromptRefreshSessions.delete(sessionId);
@@ -174135,10 +175128,24 @@ function createMagicContextHook(deps) {
   }
   let lastScheduleCheckMs = 0;
   const getHistorianChunkTokens = () => deriveHistorianChunkTokens(resolveHistorianContextLimit(deps.config.historian?.model));
+  const historianFallbackModels = resolveFallbackChain(HISTORIAN_AGENT, deps.config.historian?.fallback_models);
   const nudgePlacements = createNudgePlacementStore(db);
   const historyRefreshSessions = deps.liveSessionState?.historyRefreshSessions ?? new Set;
+  const deferredHistoryRefreshSessions = deps.liveSessionState?.deferredHistoryRefreshSessions ?? new Set;
+  try {
+    const sessionsWithPending = getSessionsWithPendingMarker(db);
+    if (sessionsWithPending.length > 0) {
+      for (const sid of sessionsWithPending) {
+        deferredHistoryRefreshSessions.add(sid);
+      }
+      log(`[magic-context] rehydrated ${sessionsWithPending.length} session(s) with pending compaction-marker drain at hook init`);
+    }
+  } catch (error51) {
+    log("[magic-context] hook init: pending-marker rehydration failed:", error51);
+  }
   const systemPromptRefreshSessions = deps.liveSessionState?.systemPromptRefreshSessions ?? new Set;
   const pendingMaterializationSessions = deps.liveSessionState?.pendingMaterializationSessions ?? new Set;
+  const deferredMaterializationSessions = deps.liveSessionState?.deferredMaterializationSessions ?? new Set;
   const lastHeuristicsTurnId = new Map;
   const commitSeenLastPass = new Map;
   const variantBySession = deps.liveSessionState?.variantBySession ?? new Map;
@@ -174179,7 +175186,9 @@ function createMagicContextHook(deps) {
     dropToolStructure: deps.config.drop_tool_structure ?? true,
     clearReasoningAge: deps.config.clear_reasoning_age ?? 50,
     historyRefreshSessions,
+    deferredHistoryRefreshSessions,
     pendingMaterializationSessions,
+    deferredMaterializationSessions,
     lastHeuristicsTurnId,
     commitSeenLastPass,
     client: deps.client,
@@ -174194,6 +175203,7 @@ function createMagicContextHook(deps) {
     executeThresholdPercentage: deps.config.execute_threshold_percentage,
     executeThresholdTokens: deps.config.execute_threshold_tokens,
     historianTimeoutMs: deps.config.historian_timeout_ms ?? DEFAULT_HISTORIAN_TIMEOUT_MS,
+    fallbackModels: historianFallbackModels,
     getNotificationParams: (sessionId) => getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession),
     getModelKey: (sessionId) => {
       const model = liveModelBySession.get(sessionId);
@@ -174251,7 +175261,7 @@ function createMagicContextHook(deps) {
       return;
     }
     try {
-      checkScheduleAndEnqueue(db, dreaming.schedule);
+      checkScheduleAndEnqueue(db, dreaming.schedule, projectPath);
       lastScheduleCheckMs = now;
     } catch (error51) {
       log("[dreamer] scheduled enqueue check failed:", error51);
@@ -174271,7 +175281,9 @@ function createMagicContextHook(deps) {
         enabled: true,
         token_budget: deps.config.dreamer.pin_key_files.token_budget,
         min_reads: deps.config.dreamer.pin_key_files.min_reads
-      } : undefined
+      } : undefined,
+      fallbackModels: resolveFallbackChain(DREAMER_AGENT, deps.config.dreamer?.fallback_models),
+      projectIdentity: projectPath
     }).catch((error51) => {
       log("[dreamer] scheduled queue processing failed:", error51);
     });
@@ -174305,6 +175317,7 @@ function createMagicContextHook(deps) {
       sessionId,
       historianChunkTokens: getHistorianChunkTokens(),
       historianTimeoutMs: deps.config.historian_timeout_ms ?? DEFAULT_HISTORIAN_TIMEOUT_MS,
+      fallbackModels: historianFallbackModels,
       directory: deps.directory,
       fallbackModelId: (() => {
         const model = resolveLiveModel(sessionId);
@@ -174314,9 +175327,12 @@ function createMagicContextHook(deps) {
       historianTwoPass: deps.config.historian?.two_pass === true,
       memoryEnabled: deps.config.memory?.enabled,
       autoPromote: deps.config.memory?.auto_promote ?? true,
-      onInjectionCacheCleared: (sid) => {
+      onCompartmentStatePublished: (sid) => {
         historyRefreshSessions.add(sid);
         pendingMaterializationSessions.add(sid);
+      },
+      onDeferredMarkerPending: (sid) => {
+        deferredHistoryRefreshSessions.add(sid);
       }
     }, options),
     sendNotification: async (sessionId, text, params) => {
@@ -174344,7 +175360,8 @@ function createMagicContextHook(deps) {
         enabled: true,
         token_budget: deps.config.dreamer.pin_key_files.token_budget,
         min_reads: deps.config.dreamer.pin_key_files.min_reads
-      } : undefined
+      } : undefined,
+      fallbackModels: resolveFallbackChain(DREAMER_AGENT, deps.config.dreamer.fallback_models)
     } : undefined
   });
   const systemPromptHash = createSystemPromptHashHandler({
@@ -174381,8 +175398,10 @@ function createMagicContextHook(deps) {
     recentReduceBySession,
     toolUsageSinceUserTurn,
     historyRefreshSessions,
+    deferredHistoryRefreshSessions,
     systemPromptRefreshSessions,
     pendingMaterializationSessions,
+    deferredMaterializationSessions,
     lastHeuristicsTurnId,
     commitSeenLastPass,
     client: deps.client,
@@ -175006,19 +176025,7 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config2, liveSess
     }
     detail.nextNudgeAfter = detail.lastNudgeTokens + detail.nudgeInterval;
     try {
-      const compartments = db.prepare("SELECT content, title, start_message, end_message FROM compartments WHERE session_id = ?").all(sessionId);
-      const facts = db.prepare("SELECT content FROM session_facts WHERE session_id = ?").all(sessionId);
-      let histTokens = 0;
-      for (const c of compartments) {
-        histTokens += estimateTokens(`<compartment start="${c.start_message}" end="${c.end_message}" title="${c.title}">
-${c.content}
-</compartment>
-`);
-      }
-      for (const f of facts) {
-        histTokens += estimateTokens(`* ${f.content}
-`);
-      }
+      const histTokens = base.compartmentTokens + base.factTokens;
       detail.historyBlockTokens = histTokens;
       if (detail.contextLimit > 0) {
         const budget = Math.floor(detail.contextLimit * (Math.min(detail.executeThreshold, 80) / 100) * detail.historyBudgetPercentage);
@@ -175088,7 +176095,7 @@ function registerRpcHandlers(rpcServer, args) {
       memoryEnabled: config2.memory?.enabled,
       autoPromote: config2.memory?.auto_promote ?? true,
       getNotificationParams: () => getNotificationParams(sessionId),
-      onInjectionCacheCleared: (sid) => {
+      onCompartmentStatePublished: (sid) => {
         liveSessionState.historyRefreshSessions.add(sid);
         liveSessionState.pendingMaterializationSessions.add(sid);
       }
@@ -175099,8 +176106,9 @@ function registerRpcHandlers(rpcServer, args) {
     });
     return { ok: true };
   });
-  rpcServer.handle("pending-notifications", async () => {
-    const notifications = drainNotifications();
+  rpcServer.handle("pending-notifications", async (params) => {
+    const lastReceivedId = Number(params.lastReceivedId ?? 0);
+    const notifications = drainNotifications(Number.isFinite(lastReceivedId) ? lastReceivedId : 0);
     return { messages: notifications };
   });
 }
@@ -175191,7 +176199,7 @@ function normalizeLimit2(limit) {
   return Math.max(1, Math.floor(limit));
 }
 function getAllowedActions(deps) {
-  const allowed = deps.allowedActions?.length ? deps.allowedActions : [...CTX_MEMORY_DREAMER_ACTIONS];
+  const allowed = deps.allowedActions?.length ? deps.allowedActions : ["write", "delete"];
   return [...allowed];
 }
 function normalizeCategory(category) {
@@ -175297,7 +176305,7 @@ function createCtxMemoryTool(deps) {
   return tool2({
     description: CTX_MEMORY_DESCRIPTION,
     args: {
-      action: tool2.schema.enum(allowedActions).describe("Action to perform on memories"),
+      action: tool2.schema.enum([...CTX_MEMORY_DREAMER_ACTIONS]).describe("Action to perform on memories"),
       content: tool2.schema.string().optional().describe("Memory content (required for write, update, merge)"),
       category: tool2.schema.string().optional().describe("Memory category (required for write, optional filter for list, optional override for merge)"),
       id: tool2.schema.number().optional().describe("Memory ID (required for delete, update, archive)"),
@@ -176058,19 +177066,68 @@ init_models_dev_cache();
 
 // src/shared/rpc-server.ts
 init_logger();
-import { mkdirSync as mkdirSync7, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync7 } from "node:fs";
+import {
+  mkdirSync as mkdirSync8,
+  readdirSync,
+  readFileSync as readFileSync10,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync7
+} from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname6 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { createHash as createHash5 } from "node:crypto";
-import { join as join23 } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { join as join22 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
-  return createHash5("sha256").update(normalized).digest("hex").slice(0, 16);
+  return createHash7("sha256").update(normalized).digest("hex").slice(0, 16);
 }
-function rpcPortFilePath(storageDir, directory) {
-  return join23(storageDir, "rpc", projectHash(directory), "port");
+function rpcPortDir(storageDir, directory) {
+  return join22(storageDir, "rpc", projectHash(directory));
+}
+function rpcPortFilePath(storageDir, directory, pid = process.pid) {
+  return join22(rpcPortDir(storageDir, directory), `port-${pid}.json`);
+}
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function parseRpcPortFile(content, fallbackPid = 0) {
+  const trimmed = content.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const port2 = Number(parsed.port);
+      const pid = Number(parsed.pid);
+      const startedAt = Number(parsed.started_at);
+      if (!isValidPort(port2) || !Number.isInteger(pid) || pid <= 0)
+        return null;
+      return {
+        port: port2,
+        pid,
+        started_at: Number.isFinite(startedAt) ? startedAt : 0
+      };
+    } catch {
+      return null;
+    }
+  }
+  const port = Number.parseInt(trimmed, 10);
+  if (!isValidPort(port))
+    return null;
+  return { port, pid: fallbackPid, started_at: 0 };
+}
+function isValidPort(port) {
+  return Number.isInteger(port) && port > 0 && port <= 65535;
 }
 
 // src/shared/rpc-server.ts
@@ -176079,8 +177136,11 @@ class MagicContextRpcServer {
   port = 0;
   handlers = new Map;
   portFilePath;
+  portDir;
+  startedAt = Date.now();
   constructor(storageDir, directory) {
     this.portFilePath = rpcPortFilePath(storageDir, directory);
+    this.portDir = rpcPortDir(storageDir, directory);
   }
   handle(method, handler) {
     this.handlers.set(method, handler);
@@ -176101,10 +177161,15 @@ class MagicContextRpcServer {
         this.port = addr.port;
         this.server = server;
         try {
-          const dir = dirname6(this.portFilePath);
-          mkdirSync7(dir, { recursive: true });
+          this.warnIfOtherLiveInstance();
+          const dir = dirname7(this.portFilePath);
+          mkdirSync8(dir, { recursive: true });
           const tmpPath = `${this.portFilePath}.tmp`;
-          writeFileSync7(tmpPath, String(this.port), "utf-8");
+          writeFileSync7(tmpPath, JSON.stringify({
+            port: this.port,
+            pid: process.pid,
+            started_at: this.startedAt
+          }), "utf-8");
           renameSync2(tmpPath, this.portFilePath);
           log(`[rpc] server listening on 127.0.0.1:${this.port}`);
         } catch (err) {
@@ -176115,6 +177180,19 @@ class MagicContextRpcServer {
       server.unref();
     });
   }
+  warnIfOtherLiveInstance() {
+    try {
+      for (const entry of readdirSync(this.portDir)) {
+        if (!entry.startsWith("port-") || !entry.endsWith(".json"))
+          continue;
+        const record2 = parseRpcPortFile(readFileSync10(`${this.portDir}/${entry}`, "utf-8"));
+        if (!record2 || record2.pid === process.pid || !isPidAlive(record2.pid))
+          continue;
+        log(`[rpc] another Magic Context RPC server is active for this project (pid ${record2.pid}, port ${record2.port}); starting separate instance on a new port`);
+        return;
+      }
+    } catch {}
+  }
   stop() {
     if (this.server) {
       this.server.close();