@cortexkit/pi-magic-context 0.18.0 → 0.20.0

package/dist/subagent-entry.js

@@ -11277,7 +11277,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)
@@ -11538,7 +11538,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");
@@ -14891,10 +14891,63 @@ var init_magic_context = __esm(() => {
   });
 });
 
-// ../plugin/src/shared/logger.ts
-import * as fs from "node:fs";
+// ../plugin/src/shared/harness.ts
+function setHarness(value) {
+  if (harnessLocked && currentHarness !== value) {
+    throw new Error(`Magic Context: harness already locked to "${currentHarness}"; cannot change to "${value}"`);
+  }
+  currentHarness = value;
+  harnessLocked = true;
+}
+function getHarness() {
+  return currentHarness;
+}
+var currentHarness = "opencode", harnessLocked = false;
+
+// ../plugin/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 = () => {};
+
+// ../plugin/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);
@@ -14905,6 +14958,8 @@ function flush() {
   const data = buffer.join("");
   buffer = [];
   try {
+    const logFile = getMagicContextLogPath();
+    ensureDir(logFile);
     fs.appendFileSync(logFile, data);
   } catch {}
 }
@@ -14935,9 +14990,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);
@@ -14961,30 +15016,47 @@ function cosineSimilarity(a, b) {
   return denominator === 0 ? 0 : dotProduct / denominator;
 }
 
-// ../plugin/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");
+// ../plugin/src/features/magic-context/memory/normalize-hash.ts
+import { createHash } from "node:crypto";
+function normalizeMemoryContent(content) {
+  return content.toLowerCase().replace(/\s+/g, " ").trim();
 }
-function getMagicContextStorageDir() {
-  return path2.join(getDataDir(), "cortexkit", "magic-context");
+function computeNormalizedHash(content) {
+  const normalized = normalizeMemoryContent(content);
+  return createHash("md5").update(normalized).digest("hex");
 }
-function getLegacyOpenCodeMagicContextStorageDir() {
-  return path2.join(getOpenCodeStorageDir(), "plugin", "magic-context");
+var init_normalize_hash = () => {};
+
+// ../plugin/src/features/magic-context/memory/embedding-identity.ts
+function normalizeEndpoint(endpoint) {
+  return endpoint?.trim().replace(/\/+$/, "") ?? "";
 }
-function getCacheDir() {
-  return process.env.XDG_CACHE_HOME ?? path2.join(os2.homedir(), ".cache");
+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_data_path = () => {};
+var init_embedding_identity = __esm(() => {
+  init_magic_context();
+  init_normalize_hash();
+});
 
 // ../plugin/src/features/magic-context/memory/embedding-local.ts
-import { mkdirSync } from "node:fs";
+import { mkdirSync as mkdirSync2 } from "node:fs";
 import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join2 } from "node:path";
 async function acquireModelLoadLock(lockPath) {
   const waitStart = Date.now();
   while (true) {
@@ -15099,7 +15171,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) {
@@ -15118,15 +15190,15 @@ class LocalEmbeddingProvider {
         if (LogLevel && "ERROR" in LogLevel) {
           env.logLevel = LogLevel.ERROR;
         }
-        const modelCacheDir = join3(getMagicContextStorageDir(), "models");
+        const modelCacheDir = join2(getMagicContextStorageDir(), "models");
         try {
-          mkdirSync(modelCacheDir, { recursive: true });
+          mkdirSync2(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 = join3(modelCacheDir, ".load.lock");
+        const lockPath = join2(modelCacheDir, ".load.lock");
         const releaseLock = await acquireModelLoadLock(lockPath);
         const stopHeartbeat = startLockHeartbeat(lockPath);
         try {
@@ -15241,12 +15313,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;
 });
 
 // ../plugin/src/features/magic-context/memory/embedding-openai.ts
-function normalizeEndpoint(endpoint) {
+function normalizeEndpoint2(endpoint) {
   return endpoint?.trim().replace(/\/+$/, "") ?? "";
 }
 
@@ -15261,10 +15334,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)
@@ -15446,20 +15524,10 @@ 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;
 });
 
-// ../plugin/src/features/magic-context/memory/normalize-hash.ts
-import { createHash } 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");
-}
-var init_normalize_hash = () => {};
-
 // ../plugin/src/features/magic-context/memory/storage-memory-embeddings.ts
 var exports_storage_memory_embeddings = {};
 __export(exports_storage_memory_embeddings, {
@@ -15604,17 +15672,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") {
@@ -15638,10 +15697,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;
   }
@@ -15789,9 +15848,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",
@@ -15983,7 +16042,7 @@ var exports_native_binding = {};
 __export(exports_native_binding, {
   resolveBetterSqliteNativeBinding: () => resolveBetterSqliteNativeBinding
 });
-import { existsSync, mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync as mkdirSync3, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import * as path3 from "node:path";
 function logInfo(message) {
@@ -16083,7 +16142,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);
     writeFileSync(cachedPath, nodeFileBytes);
     logInfo(`cached Electron prebuild at ${cachedPath} (${(nodeFileBytes.length / 1024).toFixed(1)} KB)`);
@@ -23900,14 +23959,6 @@ var require_src2 = __commonJS((exports, module) => {
 });
 
 // ../plugin/src/hooks/magic-context/read-session-db.ts
-var exports_read_session_db = {};
-__export(exports_read_session_db, {
-  withReadOnlySessionDb: () => withReadOnlySessionDb,
-  getRawSessionMessageCountFromDb: () => getRawSessionMessageCountFromDb,
-  getMessageTimesFromOpenCodeDb: () => getMessageTimesFromOpenCodeDb,
-  findLastAssistantModelFromOpenCodeDb: () => findLastAssistantModelFromOpenCodeDb,
-  closeReadOnlySessionDb: () => closeReadOnlySessionDb
-});
 import { join as join8 } from "node:path";
 function getOpenCodeDbPath() {
   return join8(getDataDir(), "opencode", "opencode.db");
@@ -23937,9 +23988,6 @@ function getReadOnlySessionDb() {
 function withReadOnlySessionDb(fn) {
   return fn(getReadOnlySessionDb());
 }
-function closeReadOnlySessionDb() {
-  closeCachedReadOnlyDb();
-}
 function getRawSessionMessageCountFromDb(db, sessionId) {
   const row = db.prepare(`SELECT COUNT(*) as count FROM message WHERE session_id = ?
              AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
@@ -23965,34 +24013,6 @@ function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
   }
   return result;
 }
-function findLastAssistantModelFromOpenCodeDb(sessionId) {
-  try {
-    return withReadOnlySessionDb((db) => {
-      const row = db.prepare(`SELECT json_extract(data, '$.providerID') as providerID,
-                            json_extract(data, '$.modelID') as modelID,
-                            json_extract(data, '$.agent') as agent
-                     FROM message
-                     WHERE session_id = ?
-                       AND json_extract(data, '$.role') = 'assistant'
-                       AND json_extract(data, '$.providerID') IS NOT NULL
-                       AND json_extract(data, '$.modelID') IS NOT NULL
-                     ORDER BY time_created DESC
-                     LIMIT 1`).get(sessionId);
-      if (!row || typeof row.providerID !== "string" || typeof row.modelID !== "string") {
-        return null;
-      }
-      const agent = typeof row.agent === "string" && row.agent.length > 0 ? row.agent : undefined;
-      return {
-        providerID: row.providerID,
-        modelID: row.modelID,
-        ...agent ? { agent } : {}
-      };
-    });
-  } catch (error51) {
-    log("[magic-context] failed to recover live model from OpenCode DB:", error51);
-    return null;
-  }
-}
 var cachedReadOnlyDb = null;
 var init_read_session_db = __esm(async () => {
   init_data_path();
@@ -24005,7 +24025,7 @@ init_embedding();
 
 // ../plugin/src/features/magic-context/storage-db.ts
 init_data_path();
-import { copyFileSync, cpSync, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { copyFileSync, cpSync, existsSync as existsSync4, mkdirSync as mkdirSync4 } from "node:fs";
 import { join as join6 } from "node:path";
 
 // ../plugin/src/shared/error-message.ts
@@ -24088,6 +24108,119 @@ function safeString(value) {
 init_logger();
 await init_sqlite();
 
+// ../plugin/src/features/magic-context/key-files/project-key-files.ts
+init_logger();
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync2, readFileSync, realpathSync } from "node:fs";
+import { join as join4, resolve, sep } from "node:path";
+var MISSING_CONTENT_HASH = "<missing>";
+var ORPHAN_GRACE_MS = 7 * 24 * 60 * 60 * 1000;
+function sha256(input) {
+  return createHash2("sha256").update(input).digest("hex");
+}
+function resolveProjectPath(directory) {
+  if (!directory?.trim())
+    return null;
+  try {
+    return realpathSync(directory);
+  } catch {
+    return resolve(directory);
+  }
+}
+function rowToProjectKeyFile(row) {
+  return {
+    projectPath: String(row.project_path),
+    path: String(row.path),
+    content: String(row.content),
+    contentHash: String(row.content_hash),
+    localTokenEstimate: Number(row.local_token_estimate),
+    generatedAt: Number(row.generated_at),
+    generatedByModel: row.generated_by_model == null ? null : String(row.generated_by_model),
+    generationConfigHash: String(row.generation_config_hash),
+    staleReason: row.stale_reason == null ? null : String(row.stale_reason)
+  };
+}
+function readCurrentKeyFiles(db, projectPath) {
+  const resolvedProjectPath = resolveProjectPath(projectPath) ?? projectPath;
+  const rows = db.prepare(`SELECT project_path, path, content, content_hash, local_token_estimate,
+                    generated_at, generated_by_model, generation_config_hash, stale_reason
+               FROM project_key_files
+              WHERE project_path = ?
+              ORDER BY generated_at DESC, path ASC`).all(resolvedProjectPath);
+  return rows.map(rowToProjectKeyFile);
+}
+function getKeyFilesVersion(db, projectPath) {
+  const resolvedProjectPath = resolveProjectPath(projectPath) ?? projectPath;
+  const row = db.prepare("SELECT version FROM project_key_files_version WHERE project_path = ?").get(resolvedProjectPath);
+  return Number(row?.version ?? 0);
+}
+function bumpKeyFilesVersion(db, projectPath) {
+  const resolvedProjectPath = resolveProjectPath(projectPath) ?? projectPath;
+  db.prepare(`INSERT INTO project_key_files_version (project_path, version)
+         VALUES (?, 1)
+         ON CONFLICT(project_path) DO UPDATE SET version = version + 1`).run(resolvedProjectPath);
+  return getKeyFilesVersion(db, resolvedProjectPath);
+}
+function resolveCommitFiles(projectPath, files) {
+  return files.map((file2) => {
+    try {
+      const disk = readFileSync(join4(projectPath, file2.path));
+      return {
+        ...file2,
+        contentHash: sha256(disk),
+        staleReason: null
+      };
+    } catch {
+      return {
+        ...file2,
+        contentHash: MISSING_CONTENT_HASH,
+        staleReason: "missing"
+      };
+    }
+  });
+}
+function insertResolvedKeyFiles(db, projectPath, files, generatedAt, generatedByModel, generationConfigHash) {
+  const insert = db.prepare(`INSERT INTO project_key_files
+           (project_path, path, content, content_hash, local_token_estimate,
+            generated_at, generated_by_model, generation_config_hash, stale_reason)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+  for (const file2 of files) {
+    insert.run(projectPath, file2.path, file2.content, file2.contentHash, file2.localTokenEstimate, generatedAt, generatedByModel, generationConfigHash, file2.staleReason);
+  }
+}
+function deleteOrphanProjectKeyFiles(db, now = Date.now()) {
+  const cutoff = now - ORPHAN_GRACE_MS;
+  const rows = db.prepare(`SELECT project_path AS projectPath, MAX(generated_at) AS lastGen
+               FROM project_key_files
+              GROUP BY project_path
+             HAVING lastGen < ?`).all(cutoff);
+  let deletedProjects = 0;
+  for (const row of rows) {
+    if (existsSync2(row.projectPath))
+      continue;
+    try {
+      db.prepare("DELETE FROM project_key_files WHERE project_path = ?").run(row.projectPath);
+      db.prepare("DELETE FROM project_key_files_version WHERE project_path = ?").run(row.projectPath);
+      deletedProjects++;
+    } catch (error51) {
+      log(`[key-files] orphan GC failed for ${row.projectPath}:`, error51);
+    }
+  }
+  return deletedProjects;
+}
+function isRelativeProjectFile(projectPath, relativePath) {
+  if (!relativePath || relativePath.startsWith("/") || relativePath.includes(".."))
+    return false;
+  try {
+    const root = realpathSync(projectPath);
+    const absPath = resolve(projectPath, relativePath);
+    const real = realpathSync(absPath);
+    return real.startsWith(root + sep) || real === root;
+  } catch {
+    return false;
+  }
+}
+
 // ../plugin/src/features/magic-context/migrations.ts
 init_logger();
 var MIGRATIONS = [
@@ -24223,6 +24356,9 @@ var MIGRATIONS = [
                     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
                 );
 
@@ -24362,6 +24498,69 @@ var MIGRATIONS = [
         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 = (name) => Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name));
+      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");
+      }
+    }
+  },
+  {
+    version: 14,
+    description: "Add project-scoped key files and version counter",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS project_key_files (
+                    project_path           TEXT    NOT NULL,
+                    path                   TEXT    NOT NULL,
+                    content                TEXT    NOT NULL,
+                    content_hash           TEXT    NOT NULL,
+                    local_token_estimate   INTEGER NOT NULL,
+                    generated_at           INTEGER NOT NULL,
+                    generated_by_model     TEXT,
+                    generation_config_hash TEXT    NOT NULL,
+                    stale_reason           TEXT,
+                    PRIMARY KEY (project_path, path)
+                );
+
+                CREATE INDEX IF NOT EXISTS idx_project_key_files_project
+                    ON project_key_files(project_path);
+                CREATE INDEX IF NOT EXISTS idx_project_key_files_generated_at
+                    ON project_key_files(project_path, generated_at);
+
+                CREATE TABLE IF NOT EXISTS project_key_files_version (
+                    project_path TEXT    PRIMARY KEY,
+                    version      INTEGER NOT NULL DEFAULT 0
+                );
+            `);
+    }
+  },
+  {
+    version: 15,
+    description: "Add deferred_execute_state column for boundary execution drain",
+    up: (db) => {
+      const cols = db.prepare("PRAGMA table_info(session_meta)").all();
+      if (!cols.some((c) => c.name === "deferred_execute_state")) {
+        db.exec("ALTER TABLE session_meta ADD COLUMN deferred_execute_state TEXT");
+      }
+    }
   }
 ];
 function ensureMigrationsTable(db) {
@@ -157021,6 +157220,28 @@ function mergeCommitHashes(existing, next) {
   return merged;
 }
 
+// ../plugin/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(",")}}`;
+}
+
 // ../plugin/src/features/magic-context/tool-definition-tokens.ts
 var measurements = new Map;
 var fingerprints = new Map;
@@ -157055,7 +157276,7 @@ function loadToolDefinitionMeasurements(db) {
 // ../plugin/src/features/magic-context/tool-owner-backfill.ts
 init_data_path();
 init_logger();
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { join as join5 } from "node:path";
 var LEASE_DURATION_MS = 5 * 60 * 1000;
 var LEASE_RENEWAL_MS = 60 * 1000;
@@ -157095,7 +157316,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync2(opencodeDbPath)) {
+  if (!existsSync3(opencodeDbPath)) {
     log(`[backfill] OpenCode DB not found at ${opencodeDbPath} — marking all unbackfilled sessions as skipped. Lazy adoption (defense-in-depth) handles legacy rows at runtime.`);
     markAllUnbackfilledSessionsSkipped(db);
     result.sessionsSkippedNoOcDb = countSessionsByStatus(db, "skipped");
@@ -157306,18 +157527,18 @@ function resolveDatabasePath() {
   return { dbDir, dbPath: join6(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync3(targetDbPath))
+  if (existsSync4(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
   const legacyDbPath = join6(legacyDir, "context.db");
-  if (!existsSync3(legacyDbPath))
+  if (!existsSync4(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
-  mkdirSync3(targetDbDir, { recursive: true });
+  mkdirSync4(targetDbDir, { recursive: true });
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
     const dst = join6(targetDbDir, `context.db${suffix}`);
-    if (existsSync3(src)) {
+    if (existsSync4(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error51) {
@@ -157327,7 +157548,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
   const legacyModelsDir = join6(legacyDir, "models");
   const targetModelsDir = join6(targetDbDir, "models");
-  if (existsSync3(legacyModelsDir) && !existsSync3(targetModelsDir)) {
+  if (existsSync4(legacyModelsDir) && !existsSync4(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error51) {
@@ -157336,9 +157557,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,
@@ -157436,6 +157657,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
@@ -157472,6 +157696,26 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     );
     CREATE INDEX IF NOT EXISTS idx_dream_runs_project ON dream_runs(project_path, finished_at DESC);
 
+    CREATE TABLE IF NOT EXISTS project_key_files (
+      project_path           TEXT    NOT NULL,
+      path                   TEXT    NOT NULL,
+      content                TEXT    NOT NULL,
+      content_hash           TEXT    NOT NULL,
+      local_token_estimate   INTEGER NOT NULL,
+      generated_at           INTEGER NOT NULL,
+      generated_by_model     TEXT,
+      generation_config_hash TEXT    NOT NULL,
+      stale_reason           TEXT,
+      PRIMARY KEY (project_path, path)
+    );
+    CREATE INDEX IF NOT EXISTS idx_project_key_files_project ON project_key_files(project_path);
+    CREATE INDEX IF NOT EXISTS idx_project_key_files_generated_at ON project_key_files(project_path, generated_at);
+
+    CREATE TABLE IF NOT EXISTS project_key_files_version (
+      project_path TEXT    PRIMARY KEY,
+      version      INTEGER NOT NULL DEFAULT 0
+    );
+
     -- (smart_notes: see note above; merged into unified notes table by migration v1)
 
     CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
@@ -157543,7 +157787,17 @@ 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,
+      -- deferred_execute_state: intentionally NULLABLE without a default.
+      -- Absence is SQL NULL; presence is a JSON blob written via
+      -- setDeferredExecutePendingIfAbsent. Excluded from healNullTextColumns.
+      deferred_execute_state TEXT
     );
 
     CREATE INDEX IF NOT EXISTS idx_tags_session_tag_number ON tags(session_id, tag_number);
@@ -157631,6 +157885,8 @@ 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, "session_meta", "deferred_execute_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'");
@@ -157707,7 +157963,15 @@ function ensureColumn(db, table, column, definition) {
   if (rows.some((row) => row.name === column)) {
     return;
   }
-  db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  try {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  } catch (err) {
+    const recheck = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (recheck.some((row) => row.name === column)) {
+      return;
+    }
+    throw err;
+  }
 }
 function openDatabase() {
   const { dbDir, dbPath } = resolveDatabasePath();
@@ -157720,10 +157984,15 @@ function openDatabase() {
   }
   try {
     migrateLegacyStorageIfNeeded(dbPath, dbDir);
-    mkdirSync3(dbDir, { recursive: true });
+    mkdirSync4(dbDir, { recursive: true });
     const db = new Database(dbPath);
     initializeDatabase(db);
     runMigrations(db);
+    try {
+      deleteOrphanProjectKeyFiles(db);
+    } catch (error51) {
+      log(`[magic-context] key-files orphan GC failed: ${getErrorMessage(error51)}`);
+    }
     try {
       runToolOwnerBackfill(db);
     } catch (error51) {
@@ -157742,33 +158011,19 @@ function openDatabase() {
   }
 }
 
-// ../plugin/src/shared/harness.ts
-var currentHarness = "opencode";
-var harnessLocked = false;
-function setHarness(value) {
-  if (harnessLocked && currentHarness !== value) {
-    throw new Error(`Magic Context: harness already locked to "${currentHarness}"; cannot change to "${value}"`);
-  }
-  currentHarness = value;
-  harnessLocked = true;
-}
-function getHarness() {
-  return currentHarness;
-}
-
 // src/subagent-entry.ts
 init_logger();
 
 // src/config/index.ts
 init_magic_context();
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join7 } from "node:path";
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync4, readFileSync } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, isAbsolute, resolve } from "node:path";
+import { dirname as dirname3, isAbsolute, resolve as resolve2 } from "node:path";
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
 var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function substituteConfigVariables(input) {
@@ -157787,7 +158042,7 @@ function substituteConfigVariables(input) {
   if (fileMatches.length === 0) {
     return { text, warnings };
   }
-  const configDir = input.configPath ? dirname2(input.configPath) : process.cwd();
+  const configDir = input.configPath ? dirname3(input.configPath) : process.cwd();
   let output = "";
   let cursor = 0;
   for (const match of fileMatches) {
@@ -157805,17 +158060,17 @@ function substituteConfigVariables(input) {
     }
     let filePath = rawPath.trim();
     if (filePath.startsWith("~/")) {
-      filePath = resolve(homedir2(), filePath.slice(2));
+      filePath = resolve2(homedir2(), filePath.slice(2));
     } else if (!isAbsolute(filePath)) {
-      filePath = resolve(configDir, filePath);
+      filePath = resolve2(configDir, filePath);
     }
-    if (!existsSync4(filePath)) {
+    if (!existsSync5(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
     let contents;
     try {
-      contents = readFileSync(filePath, "utf-8").trim();
+      contents = readFileSync2(filePath, "utf-8").trim();
     } catch (error51) {
       const message = error51 instanceof Error ? error51.message : String(error51);
       warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
@@ -157840,11 +158095,11 @@ function getUserConfigPaths() {
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path4) => existsSync5(path4));
+  return paths.find((path4) => existsSync6(path4));
 }
 function loadConfigFile(path4, scope) {
   try {
-    const rawText = readFileSync2(path4, "utf-8");
+    const rawText = readFileSync3(path4, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
       configPath: path4
@@ -162453,6 +162708,61 @@ __export(exports_typebox, {
   Any: () => Any
 });
 // src/read-session-pi.ts
+function isMidTurnPi(event, _sessionId) {
+  const messages = event?.messages;
+  if (!Array.isArray(messages))
+    return false;
+  let latestAssistantIndex = -1;
+  let latestAssistant = null;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg !== null && typeof msg === "object") {
+      const record4 = msg;
+      if (record4.role === "assistant") {
+        latestAssistantIndex = i;
+        latestAssistant = record4;
+        break;
+      }
+    }
+  }
+  if (latestAssistant === null)
+    return false;
+  if (latestAssistant.stopReason === "toolUse")
+    return true;
+  const toolCallIds = getToolCallIds(latestAssistant.content);
+  if (toolCallIds.size === 0)
+    return false;
+  const pairedToolResultIds = new Set;
+  for (const msg of messages.slice(latestAssistantIndex + 1)) {
+    if (msg === null || typeof msg !== "object")
+      continue;
+    const record4 = msg;
+    if (record4.role !== "toolResult")
+      continue;
+    if (typeof record4.toolCallId === "string") {
+      pairedToolResultIds.add(record4.toolCallId);
+    }
+  }
+  for (const id of toolCallIds) {
+    if (!pairedToolResultIds.has(id))
+      return true;
+  }
+  return false;
+}
+function getToolCallIds(content) {
+  const ids = new Set;
+  if (!Array.isArray(content))
+    return ids;
+  for (const item of content) {
+    if (item === null || typeof item !== "object")
+      continue;
+    const record4 = item;
+    if (record4.type === "toolCall" && typeof record4.id === "string") {
+      ids.add(record4.id);
+    }
+  }
+  return ids;
+}
 function readPiSessionMessages(ctx) {
   const sm = ctx.sessionManager;
   if (sm === undefined)
@@ -162474,6 +162784,7 @@ function convertEntriesToRawMessages(entries) {
   const result = [];
   let nextOrdinal = 1;
   let pendingToolParts = [];
+  let pendingFirstRealId = "";
   for (const entry of entries) {
     if (!isMessageEntry(entry)) {
       continue;
@@ -162482,6 +162793,9 @@ function convertEntriesToRawMessages(entries) {
     const role = msg.role;
     if (role === "toolResult") {
       pendingToolParts.push(...synthesizeToolResultParts(msg));
+      if (pendingFirstRealId === "") {
+        pendingFirstRealId = entry.id;
+      }
       continue;
     }
     if (role === "user") {
@@ -162490,6 +162804,7 @@ function convertEntriesToRawMessages(entries) {
         ...synthesizeUserParts(msg)
       ];
       pendingToolParts = [];
+      pendingFirstRealId = "";
       result.push({
         ordinal: nextOrdinal++,
         id: entry.id,
@@ -162502,11 +162817,12 @@ function convertEntriesToRawMessages(entries) {
       if (pendingToolParts.length > 0) {
         result.push({
           ordinal: nextOrdinal++,
-          id: "",
+          id: pendingFirstRealId,
           role: "user",
           parts: pendingToolParts
         });
         pendingToolParts = [];
+        pendingFirstRealId = "";
       }
       result.push({
         ordinal: nextOrdinal++,
@@ -162526,7 +162842,7 @@ function convertEntriesToRawMessages(entries) {
   if (pendingToolParts.length > 0) {
     result.push({
       ordinal: nextOrdinal,
-      id: "",
+      id: pendingFirstRealId,
       role: "user",
       parts: pendingToolParts
     });
@@ -163027,7 +163343,7 @@ init_normalize_hash();
 
 // ../plugin/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";
 var GIT_TIMEOUT_MS = 5000;
 var resolvedCache = new Map;
@@ -163048,7 +163364,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) {
@@ -164113,6 +164429,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;
@@ -164189,6 +164511,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);
@@ -164293,6 +164638,52 @@ function setStrippedPlaceholderIds(db, sessionId, ids) {
   const json2 = ids.size > 0 ? JSON.stringify([...ids]) : "";
   db.prepare("UPDATE session_meta SET stripped_placeholder_ids = ? WHERE session_id = ?").run(json2, sessionId);
 }
+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 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 peekDeferredExecutePending(db, sessionId) {
+  const row = db.prepare("SELECT deferred_execute_state FROM session_meta WHERE session_id = ?").get(sessionId);
+  const raw = row?.deferred_execute_state;
+  if (raw === null || raw === undefined || raw === "")
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function setDeferredExecutePendingIfAbsent(db, sessionId, payload) {
+  ensureSessionMetaRow(db, sessionId);
+  const payloadBlob = stableStringify(payload);
+  const result = db.prepare(`UPDATE session_meta SET deferred_execute_state = ?
+             WHERE session_id = ? AND deferred_execute_state IS NULL`).run(payloadBlob, sessionId);
+  return result.changes > 0;
+}
+function clearDeferredExecutePendingIfMatches(db, sessionId, expected) {
+  const expectedBlob = stableStringify(expected);
+  const result = db.prepare(`UPDATE session_meta SET deferred_execute_state = NULL
+             WHERE session_id = ? AND deferred_execute_state = ?`).run(sessionId, expectedBlob);
+  return result.changes > 0;
+}
 // ../plugin/src/features/magic-context/resolve-subagent-fallback.ts
 init_logger();
 await init_read_session_db();
@@ -166209,16 +166600,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);
@@ -166250,7 +166649,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;
@@ -166283,9 +166686,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];
@@ -166303,9 +166707,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;
@@ -166314,17 +166719,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;
 }
 
@@ -166448,6 +166856,70 @@ function createCtxSearchTool(deps) {
   };
 }
 
+// src/tools/todowrite.ts
+var STATUS_VALUES = [
+  "pending",
+  "in_progress",
+  "completed",
+  "cancelled"
+];
+var PRIORITY_VALUES = ["high", "medium", "low"];
+var TodoItem = exports_typebox.Object({
+  content: exports_typebox.String({ description: "Brief description of the task" }),
+  status: exports_typebox.Union(STATUS_VALUES.map((v) => exports_typebox.Literal(v))),
+  priority: exports_typebox.Optional(exports_typebox.Union(PRIORITY_VALUES.map((v) => exports_typebox.Literal(v)))),
+  id: exports_typebox.Optional(exports_typebox.String({ description: "Optional stable id for the todo" }))
+});
+var TodowriteParams = exports_typebox.Object({
+  todos: exports_typebox.Array(TodoItem, {
+    description: "Replace the current task list with this complete set of todos. Include every task you intend to track this turn — pending, in_progress, completed, or cancelled — because the list overwrites previous state."
+  })
+});
+var TOOL_DESCRIPTION = [
+  "Manage your task list for this session.",
+  "",
+  "Use this tool to plan multi-step work, track in-flight tasks, and",
+  "mark progress as you complete steps. Pass the COMPLETE updated list",
+  "of todos every time — this tool replaces the prior list rather than",
+  "appending to it.",
+  "",
+  "Task states:",
+  "  - pending: not started yet",
+  "  - in_progress: currently working on (limit to ONE task at a time)",
+  "  - completed: finished successfully",
+  "  - cancelled: no longer needed",
+  "",
+  "Use this tool proactively for non-trivial work spanning 3+ steps.",
+  "Skip it for single-shot answers or trivial 1-2 step tasks."
+].join(`
+`);
+function createTodowriteTool() {
+  return {
+    name: "todowrite",
+    label: "Todos",
+    description: TOOL_DESCRIPTION,
+    parameters: TodowriteParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const todos = params.todos ?? [];
+      const completed = todos.filter((t) => t.status === "completed").length;
+      const active = todos.length - completed;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(todos, null, 2)
+          }
+        ],
+        details: {
+          todos,
+          title: `${active} todos`,
+          truncated: false
+        }
+      };
+    }
+  };
+}
+
 // src/tools/index.ts
 function registerMagicContextTools(pi, opts) {
   pi.registerTool(createCtxSearchTool({
@@ -166467,6 +166939,7 @@ function registerMagicContextTools(pi, opts) {
     dreamerEnabled: opts.dreamerEnabled ?? false
   }));
   pi.registerTool(createCtxExpandTool({ db: opts.db }));
+  pi.registerTool(createTodowriteTool());
   if (opts.ctxReduceEnabled === true) {
     pi.registerTool(createCtxReduceTool({
       db: opts.db,