@cortexkit/pi-magic-context 0.18.0 → 0.20.0

package/dist/index.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 path4 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(path4.dirname(cachedPath), { recursive: true });
+    mkdirSync3(path4.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)`);
@@ -16143,17 +16202,9 @@ function closeQuietly(db) {
 }
 
 // ../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 join5 } from "node:path";
+import { join as join4 } from "node:path";
 function getOpenCodeDbPath() {
-  return join5(getDataDir(), "opencode", "opencode.db");
+  return join4(getDataDir(), "opencode", "opencode.db");
 }
 function closeCachedReadOnlyDb() {
   if (!cachedReadOnlyDb) {
@@ -16180,9 +16231,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
@@ -16208,34 +16256,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();
@@ -16243,33 +16263,6 @@ var init_read_session_db = __esm(async () => {
   await init_sqlite();
 });
 
-// ../plugin/src/shared/rpc-notifications.ts
-var exports_rpc_notifications = {};
-__export(exports_rpc_notifications, {
-  pushNotification: () => pushNotification,
-  isTuiConnected: () => isTuiConnected,
-  drainNotifications: () => drainNotifications
-});
-function pushNotification(type, payload, sessionId) {
-  queue2.push({ type, payload, sessionId });
-  if (queue2.length > 100) {
-    queue2 = queue2.slice(-50);
-  }
-}
-function drainNotifications() {
-  lastDrainAt = Date.now();
-  const result = queue2;
-  queue2 = [];
-  return result;
-}
-function isTuiConnected() {
-  return lastDrainAt > 0 && Date.now() - lastDrainAt < TUI_CONNECTED_WINDOW_MS;
-}
-var queue2, lastDrainAt = 0, TUI_CONNECTED_WINDOW_MS = 3000;
-var init_rpc_notifications = __esm(() => {
-  queue2 = [];
-});
-
 // ../../node_modules/.bun/esprima@4.0.1/node_modules/esprima/dist/esprima.js
 var require_esprima = __commonJS((exports, module) => {
   (function webpackUniversalModuleDefinition(root, factory) {
@@ -23877,10 +23870,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join13 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join9 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join13(comment, inside, gap);
+    return join9(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -23902,13 +23895,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join13(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join9(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join13(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -23929,13 +23922,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join13(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join9(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join13(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -24027,10 +24020,38 @@ var require_src2 = __commonJS((exports, module) => {
   };
 });
 
+// ../plugin/src/shared/rpc-notifications.ts
+var exports_rpc_notifications = {};
+__export(exports_rpc_notifications, {
+  pushNotification: () => pushNotification,
+  isTuiConnected: () => isTuiConnected,
+  drainNotifications: () => drainNotifications
+});
+function pushNotification(type, payload, sessionId) {
+  queue2.push({ id: nextNotificationId++, type, payload, sessionId });
+  if (queue2.length > 100) {
+    queue2 = queue2.slice(-50);
+  }
+}
+function drainNotifications(lastReceivedId = 0) {
+  lastDrainAt = Date.now();
+  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, nextNotificationId = 1, lastDrainAt = 0, TUI_CONNECTED_WINDOW_MS = 3000;
+var init_rpc_notifications = __esm(() => {
+  queue2 = [];
+});
+
 // src/index.ts
 init_embedding();
 import { createRequire as createRequire2 } from "node:module";
-import { join as join15 } from "node:path";
+import { join as join18 } from "node:path";
 
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execSync } from "node:child_process";
@@ -157083,21 +157104,6 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     toolOnlyRanges
   };
 }
-
-// ../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;
-}
-
 // ../plugin/src/features/magic-context/compression-depth-storage.ts
 var incrementDepthStatements = new WeakMap;
 var totalDepthStatements = new WeakMap;
@@ -157773,7 +157779,7 @@ function escapeXmlContent(s) {
 }
 // ../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 join7 } from "node:path";
 
 // ../plugin/src/shared/error-message.ts
@@ -157856,6 +157862,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 createHash3 } from "node:crypto";
+import { existsSync as existsSync2, readFileSync, realpathSync } from "node:fs";
+import { join as join5, resolve, sep } from "node:path";
+var MISSING_CONTENT_HASH = "<missing>";
+var ORPHAN_GRACE_MS = 7 * 24 * 60 * 60 * 1000;
+function sha256(input) {
+  return createHash3("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(join5(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 = [
@@ -157991,6 +158110,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
                 );
 
@@ -158130,6 +158252,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 = (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");
+      }
+    }
+  },
+  {
+    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) {
@@ -158197,6 +158382,28 @@ function runMigrations(db) {
   log(`[migrations] schema version now: ${MIGRATIONS[MIGRATIONS.length - 1].version}`);
 }
 
+// ../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;
@@ -158231,7 +158438,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 join6 } from "node:path";
 var LEASE_DURATION_MS = 5 * 60 * 1000;
 var LEASE_RENEWAL_MS = 60 * 1000;
@@ -158271,7 +158478,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");
@@ -158482,18 +158689,18 @@ function resolveDatabasePath() {
   return { dbDir, dbPath: join7(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync3(targetDbPath))
+  if (existsSync4(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
   const legacyDbPath = join7(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 = join7(targetDbDir, `context.db${suffix}`);
-    if (existsSync3(src)) {
+    if (existsSync4(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error51) {
@@ -158503,7 +158710,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
   const legacyModelsDir = join7(legacyDir, "models");
   const targetModelsDir = join7(targetDbDir, "models");
-  if (existsSync3(legacyModelsDir) && !existsSync3(targetModelsDir)) {
+  if (existsSync4(legacyModelsDir) && !existsSync4(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error51) {
@@ -158512,9 +158719,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,
@@ -158612,6 +158819,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
@@ -158648,6 +158858,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(
@@ -158719,7 +158949,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);
@@ -158807,6 +159047,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'");
@@ -158883,7 +159125,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();
@@ -158896,10 +159146,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) {
@@ -159021,6 +159276,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;
@@ -159097,6 +159358,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);
@@ -159201,6 +159485,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();
@@ -159795,8 +160125,8 @@ function getAgentFallbackModels(agent) {
 
 // ../plugin/src/shared/models-dev-cache.ts
 init_data_path();
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync4, readFileSync } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2, platform } from "node:os";
 import { join as join8 } from "node:path";
 
@@ -159904,7 +160234,7 @@ var recentlySeenApiSizes = new Set;
 var fileCache = null;
 var fileLastAttempt = 0;
 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();
@@ -159919,10 +160249,10 @@ function getOpencodeConfigPath() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   const configDir = envDir ? envDir : platform() === "win32" ? join8(homedir2(), ".config", "opencode") : join8(process.env.XDG_CONFIG_HOME || join8(homedir2(), ".config"), "opencode");
   const jsonc = join8(configDir, "opencode.jsonc");
-  if (existsSync4(jsonc))
+  if (existsSync5(jsonc))
     return jsonc;
   const json2 = join8(configDir, "opencode.json");
-  if (existsSync4(json2))
+  if (existsSync5(json2))
     return json2;
   return null;
 }
@@ -159954,9 +160284,9 @@ function loadModelsDevMetadataFromFile() {
   const modelsJsonPath = getModelsJsonPath();
   let fileFound = false;
   try {
-    if (existsSync4(modelsJsonPath)) {
+    if (existsSync5(modelsJsonPath)) {
       fileFound = true;
-      const raw = readFileSync(modelsJsonPath, "utf-8");
+      const raw = readFileSync2(modelsJsonPath, "utf-8");
       const data = JSON.parse(raw);
       for (const [providerId, provider2] of Object.entries(data)) {
         if (!provider2?.models || typeof provider2.models !== "object")
@@ -159971,8 +160301,8 @@ function loadModelsDevMetadataFromFile() {
   }
   try {
     const configPath = getOpencodeConfigPath();
-    if (configPath && existsSync4(configPath)) {
-      const config2 = parseJsonc(readFileSync(configPath, "utf-8"));
+    if (configPath && existsSync5(configPath)) {
+      const config2 = parseJsonc(readFileSync2(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")
@@ -160267,6 +160597,84 @@ function clearNoteNudgeState(db, sessionId, options) {
   lastDeliveredAt.delete(sessionId);
 }
 
+// ../plugin/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 ?? "medium"
+    });
+  }
+  return JSON.stringify(normalized);
+}
+function buildSyntheticTodoPart(stateJson) {
+  const todos = parseTodoState(stateJson);
+  if (todos === null || todos.length === 0)
+    return null;
+  if (todos.every((t) => TERMINAL_STATUSES.has(t.status)))
+    return null;
+  const callID = computeSyntheticCallId(stateJson);
+  const activeCount = todos.filter((t) => !TITLE_DONE_STATUSES.has(t.status)).length;
+  const output = JSON.stringify(todos, null, 2);
+  const ts = 0;
+  return {
+    type: "tool",
+    callID,
+    tool: "todowrite",
+    state: {
+      status: "completed",
+      input: { todos },
+      output,
+      title: `${activeCount} todos`,
+      metadata: { todos, truncated: false },
+      time: { start: ts, end: ts }
+    },
+    syntheticTodoMarker: true
+  };
+}
+function computeSyntheticCallId(stateJson) {
+  const 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 ?? "medium"
+      });
+    }
+    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" && (todo.priority === undefined || typeof todo.priority === "string");
+}
+
 // src/index.ts
 init_data_path();
 init_logger();
@@ -160296,15 +160704,15 @@ init_logger();
 
 // src/subagent-runner.ts
 import * as childProcess from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname2, resolve as resolvePath } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
+import { dirname as dirname3, resolve as resolvePath } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 function resolveSubagentEntryPath() {
   try {
-    const here = dirname2(fileURLToPath(import.meta.url));
+    const here = dirname3(fileURLToPath(import.meta.url));
     const candidate = resolvePath(here, "subagent-entry.js");
-    if (existsSync5(candidate))
+    if (existsSync6(candidate))
       return candidate;
     return;
   } catch {
@@ -160329,13 +160737,13 @@ class PiSubagentRunner {
   async run(options) {
     const startTime = Date.now();
     const args = buildArgs(options);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let settled = false;
       const settle = (result) => {
         if (settled)
           return;
         settled = true;
-        resolve(result);
+        resolve2(result);
       };
       const emitProgress = (event) => {
         if (!options.onProgress)
@@ -160744,69 +161152,6 @@ ${sidekickText}
   });
 }
 
-// ../plugin/src/features/magic-context/dreamer/queue.ts
-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]);
-    const existing = db.prepare("SELECT id FROM dream_queue WHERE project_path = ?").get(projectIdentity);
-    if (existing) {
-      return null;
-    }
-    const result = db.prepare("INSERT INTO dream_queue (project_path, reason, enqueued_at) VALUES (?, ?, ?)").run(projectIdentity, reason, now);
-    return {
-      id: Number(result.lastInsertRowid),
-      projectIdentity,
-      reason,
-      enqueuedAt: now,
-      startedAt: null
-    };
-  })();
-}
-function peekQueue(db, projectIdentity) {
-  const row = projectIdentity ? db.prepare("SELECT id, project_path, reason, enqueued_at FROM dream_queue WHERE started_at IS NULL AND project_path = ? ORDER BY enqueued_at ASC LIMIT 1").get(projectIdentity) : db.prepare("SELECT id, project_path, reason, enqueued_at FROM dream_queue WHERE started_at IS NULL ORDER BY enqueued_at ASC LIMIT 1").get();
-  if (!row)
-    return null;
-  return {
-    id: row.id,
-    projectIdentity: row.project_path,
-    reason: row.reason,
-    enqueuedAt: row.enqueued_at,
-    startedAt: null
-  };
-}
-function dequeueNext(db, projectIdentity) {
-  const now = Date.now();
-  return db.transaction(() => {
-    const entry = peekQueue(db, projectIdentity);
-    if (!entry)
-      return null;
-    const result = db.prepare("UPDATE dream_queue SET started_at = ? WHERE id = ? AND started_at IS NULL").run(now, entry.id);
-    if (result.changes === 0)
-      return null;
-    return { ...entry, startedAt: now };
-  })();
-}
-function removeDreamEntry(db, id) {
-  db.prepare("DELETE FROM dream_queue WHERE id = ?").run(id);
-}
-function resetDreamEntry(db, id) {
-  db.prepare("UPDATE dream_queue SET started_at = NULL, retry_count = COALESCE(retry_count, 0) + 1 WHERE id = ?").run(id);
-}
-function getEntryRetryCount(db, id) {
-  const row = db.prepare("SELECT retry_count FROM dream_queue WHERE id = ?").get(id);
-  return row?.retry_count ?? 0;
-}
-function clearStaleEntries(db, maxAgeMs) {
-  const cutoff = Date.now() - maxAgeMs;
-  const result = db.prepare("DELETE FROM dream_queue WHERE started_at IS NOT NULL AND started_at < ?").run(cutoff);
-  return result.changes;
-}
-
-// src/commands/ctx-dream.ts
-init_logger();
-
 // ../plugin/src/features/magic-context/dreamer/storage-dream-state.ts
 var getDreamStateStatements = new WeakMap;
 var setDreamStateStatements = new WeakMap;
@@ -160866,6 +161211,16 @@ function isLeaseActive(db) {
 function getLeaseHolder(db) {
   return getDreamState(db, LEASE_HOLDER_KEY);
 }
+function peekLeaseHolderAndExpiry(db, expectedHolder) {
+  const holder = getDreamState(db, LEASE_HOLDER_KEY);
+  if (holder !== expectedHolder)
+    return false;
+  const expiryStr = getDreamState(db, LEASE_EXPIRY_KEY);
+  if (!expiryStr)
+    return false;
+  const expiry = Number(expiryStr);
+  return Number.isFinite(expiry) && expiry >= Date.now();
+}
 function acquireLease(db, holderId) {
   return db.transaction(() => {
     if (isLeaseActive(db)) {
@@ -160902,9 +161257,84 @@ function releaseLease(db, holderId) {
     deleteDreamState(db, LEASE_EXPIRY_KEY);
   })();
 }
+
+// ../plugin/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(() => {
+    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;
+    }
+    const result = db.prepare("INSERT INTO dream_queue (project_path, reason, enqueued_at) VALUES (?, ?, ?)").run(projectIdentity, reason, now);
+    return {
+      id: Number(result.lastInsertRowid),
+      projectIdentity,
+      reason,
+      enqueuedAt: now,
+      startedAt: null
+    };
+  })();
+}
+function peekQueue(db, projectIdentity) {
+  const row = projectIdentity ? db.prepare("SELECT id, project_path, reason, enqueued_at FROM dream_queue WHERE started_at IS NULL AND project_path = ? ORDER BY enqueued_at ASC LIMIT 1").get(projectIdentity) : db.prepare("SELECT id, project_path, reason, enqueued_at FROM dream_queue WHERE started_at IS NULL ORDER BY enqueued_at ASC LIMIT 1").get();
+  if (!row)
+    return null;
+  return {
+    id: row.id,
+    projectIdentity: row.project_path,
+    reason: row.reason,
+    enqueuedAt: row.enqueued_at,
+    startedAt: null
+  };
+}
+function dequeueNext(db, projectIdentity) {
+  const now = Date.now();
+  return db.transaction(() => {
+    const entry = peekQueue(db, projectIdentity);
+    if (!entry)
+      return null;
+    const result = db.prepare("UPDATE dream_queue SET started_at = ? WHERE id = ? AND started_at IS NULL").run(now, entry.id);
+    if (result.changes === 0)
+      return null;
+    return { ...entry, startedAt: now };
+  })();
+}
+function removeDreamEntry(db, id) {
+  db.prepare("DELETE FROM dream_queue WHERE id = ?").run(id);
+}
+function resetDreamEntry(db, id) {
+  db.prepare("UPDATE dream_queue SET started_at = NULL, retry_count = COALESCE(retry_count, 0) + 1 WHERE id = ?").run(id);
+}
+function getEntryRetryCount(db, id) {
+  const row = db.prepare("SELECT retry_count FROM dream_queue WHERE id = ?").get(id);
+  return row?.retry_count ?? 0;
+}
+function clearStaleEntries(db, maxAgeMs) {
+  const cutoff = Date.now() - maxAgeMs;
+  const result = db.prepare("DELETE FROM dream_queue WHERE started_at IS NOT NULL AND started_at < ?").run(cutoff);
+  return result.changes;
+}
+
+// src/commands/ctx-dream.ts
+init_logger();
 // ../plugin/src/features/magic-context/dreamer/runner.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join11 } from "node:path";
 
 // ../plugin/src/shared/index.ts
 init_logger();
@@ -161198,187 +161628,519 @@ init_logger();
 await init_sqlite();
 
 // ../plugin/src/features/magic-context/key-files/identify-key-files.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join10 } from "node:path";
 init_logger();
 
-// ../plugin/src/features/magic-context/key-files/read-stats.ts
-function getSessionReadStats(openCodeDb, sessionId, minReads) {
-  const fullReads = openCodeDb.prepare(`
-        WITH full_reads AS (
-            SELECT 
-                json_extract(json_extract(data, '$.state'), '$.input.filePath') as file_path,
-                LENGTH(json_extract(json_extract(data, '$.state'), '$.output')) as output_bytes,
-                p.time_created,
-                ROW_NUMBER() OVER (
-                    PARTITION BY json_extract(json_extract(data, '$.state'), '$.input.filePath') 
-                    ORDER BY p.time_created DESC
-                ) as rn
-            FROM part p
-            WHERE p.session_id = ?
-                AND json_extract(data, '$.type') = 'tool'
-                AND json_extract(data, '$.tool') = 'read'
-                AND json_extract(json_extract(data, '$.state'), '$.input.filePath') IS NOT NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.startLine') IS NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.start_line') IS NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.endLine') IS NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.end_line') IS NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.offset') IS NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.limit') IS NULL
-        ),
-        file_counts AS (
-            SELECT file_path, COUNT(*) as full_read_count
-            FROM full_reads
-            GROUP BY file_path
-            HAVING full_read_count >= ?
-        )
-        SELECT 
-            r.file_path,
-            fc.full_read_count,
-            r.output_bytes as latest_read_bytes
-        FROM full_reads r
-        JOIN file_counts fc ON r.file_path = fc.file_path
-        WHERE r.rn = 1
-        ORDER BY fc.full_read_count DESC
-    `).all(sessionId, minReads);
-  if (fullReads.length === 0)
-    return [];
-  const editCounts = new Map;
-  const editRows = openCodeDb.prepare(`
-        SELECT 
-            json_extract(json_extract(data, '$.state'), '$.input.filePath') as file_path,
-            COUNT(*) as edit_count
-        FROM part p
-        WHERE p.session_id = ?
-            AND json_extract(data, '$.type') = 'tool'
-            AND json_extract(data, '$.tool') IN ('edit', 'write', 'mcp_edit', 'mcp_write')
-            AND json_extract(json_extract(data, '$.state'), '$.input.filePath') IS NOT NULL
-        GROUP BY file_path
-    `).all(sessionId);
-  for (const row of editRows) {
-    editCounts.set(row.file_path, row.edit_count);
-  }
-  return fullReads.map((row) => ({
-    filePath: row.file_path,
-    fullReadCount: row.full_read_count,
-    spreadAcrossCompartments: 0,
-    editCount: editCounts.get(row.file_path) ?? 0,
-    latestReadBytes: row.latest_read_bytes ?? 0,
-    latestReadTokens: Math.ceil((row.latest_read_bytes ?? 0) / 3.5)
-  }));
+// ../plugin/src/features/magic-context/key-files/aft-availability.ts
+var import_comment_json = __toESM(require_src2(), 1);
+import { existsSync as existsSync7, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join9 } from "node:path";
+var overrideAvailability = null;
+function parseConfig(path5) {
+  if (!existsSync7(path5))
+    return null;
+  return import_comment_json.parse(readFileSync3(path5, "utf-8"));
+}
+function entryMatchesAft(entry) {
+  const value = Array.isArray(entry) ? entry[0] : entry;
+  return typeof value === "string" && (value.includes("@cortexkit/aft") || value.includes("aft-opencode") || value.includes("aft-pi"));
+}
+function hasAftInArray(value) {
+  return Array.isArray(value) && value.some(entryMatchesAft);
+}
+function hasAftAtKeys(value, keys) {
+  if (!value || typeof value !== "object")
+    return false;
+  const record2 = value;
+  for (const key of keys) {
+    if (hasAftInArray(record2[key]))
+      return true;
+  }
+  return false;
+}
+function getAftAvailability() {
+  const home = process.env.HOME || homedir3();
+  const opencodePaths = [
+    join9(home, ".config", "opencode", "opencode.jsonc"),
+    join9(home, ".config", "opencode", "opencode.json")
+  ];
+  const piPaths = [join9(home, ".pi", "agent", "settings.json")];
+  const checkedPaths = [...opencodePaths, ...piPaths];
+  let opencode = false;
+  for (const path5 of opencodePaths) {
+    try {
+      const config2 = parseConfig(path5);
+      if (hasAftAtKeys(config2, ["plugin", "plugins", "mcp", "mcp_servers"])) {
+        opencode = true;
+        break;
+      }
+    } catch {}
+  }
+  let pi = false;
+  for (const path5 of piPaths) {
+    try {
+      const config2 = parseConfig(path5);
+      if (hasAftAtKeys(config2, ["packages", "extensions"])) {
+        pi = true;
+        break;
+      }
+      const agent = config2?.agent;
+      if (hasAftAtKeys(agent, ["packages", "extensions"])) {
+        pi = true;
+        break;
+      }
+    } catch {}
+  }
+  const detected = opencode || pi;
+  return {
+    available: overrideAvailability ?? detected,
+    opencode,
+    pi,
+    checkedPaths
+  };
+}
+function isAftAvailable() {
+  return getAftAvailability().available;
 }
 
-// ../plugin/src/features/magic-context/key-files/storage-key-files.ts
-init_logger();
-function getKeyFiles(db, sessionId) {
-  try {
-    const row = db.prepare("SELECT key_files FROM session_meta WHERE session_id = ?").get(sessionId);
-    if (!row?.key_files)
-      return [];
-    const parsed = JSON.parse(row.key_files);
-    if (!Array.isArray(parsed))
-      return [];
-    return parsed.filter((e) => typeof e === "object" && e !== null && typeof e.filePath === "string" && typeof e.tokens === "number");
-  } catch {
+// ../plugin/src/features/magic-context/key-files/read-history.ts
+import { realpathSync as realpathSync2 } from "node:fs";
+import { relative, resolve as resolve2 } from "node:path";
+function toMs(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string") {
+    const n = Number(value);
+    if (Number.isFinite(n))
+      return n;
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return 0;
+}
+function toPositiveInt(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+function coalesceRanges(ranges) {
+  if (ranges.length === 0)
     return [];
+  const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
+  const merged = [];
+  for (const range of sorted) {
+    const last = merged.at(-1);
+    if (last && range.start <= last.end + 10) {
+      last.end = Math.max(last.end, range.end);
+      last.count += range.count;
+      last.lastReadAt = Math.max(last.lastReadAt, range.lastReadAt);
+    } else {
+      merged.push({ ...range });
+    }
   }
+  return merged.sort((a, b) => b.lastReadAt - a.lastReadAt || b.count - a.count).slice(0, 3);
 }
-function setKeyFiles(db, sessionId, files) {
+function normalizeProjectRelativePath(projectPath, filePath) {
+  const root = realpathSync2(projectPath);
+  const abs = filePath.startsWith("/") ? resolve2(filePath) : resolve2(root, filePath);
+  let real = abs;
   try {
-    db.prepare("INSERT OR IGNORE INTO session_meta (session_id) VALUES (?)").run(sessionId);
-    db.prepare("UPDATE session_meta SET key_files = ? WHERE session_id = ?").run(JSON.stringify(files), sessionId);
-  } catch (error51) {
-    sessionLog(sessionId, "failed to persist key files:", error51);
+    real = realpathSync2(abs);
+  } catch {}
+  if (!real.startsWith(`${root}/`) && real !== root)
+    return null;
+  const rel = relative(root, real).replaceAll("\\", "/");
+  if (!rel || rel.startsWith(".."))
+    return null;
+  return rel;
+}
+function primarySessionIds(db) {
+  try {
+    const rows = db.prepare("SELECT session_id AS sessionId FROM session_meta WHERE is_subagent = 0").all();
+    return new Set(rows.map((row) => row.sessionId));
+  } catch {
+    return new Set;
   }
 }
-function greedyFitFiles(rankedFiles, tokenBudget) {
-  const selected = [];
-  let remainingBudget = tokenBudget;
-  for (const file2 of rankedFiles) {
-    if (file2.tokens <= 0)
+function collectKeyFileCandidates(args) {
+  const primaryIds = primarySessionIds(args.magicDb);
+  if (primaryIds.size === 0)
+    return [];
+  const reads = args.openCodeDb.prepare(`SELECT p.session_id,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.filePath') AS file_path,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.startLine') AS start_line,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.endLine') AS end_line,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.offset') AS offset_value,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.limit') AS limit_value,
+                    LENGTH(json_extract(json_extract(p.data, '$.state'), '$.output')) AS output_bytes,
+                    p.time_created
+               FROM part p
+              WHERE json_extract(p.data, '$.type') = 'tool'
+                AND json_extract(p.data, '$.tool') = 'read'
+                AND json_extract(json_extract(p.data, '$.state'), '$.input.filePath') IS NOT NULL`).all();
+  const byPath = new Map;
+  for (const row of reads) {
+    if (!primaryIds.has(row.session_id) || !row.file_path)
       continue;
-    if (file2.tokens > remainingBudget)
+    const rel = normalizeProjectRelativePath(args.projectPath, row.file_path);
+    if (!rel)
       continue;
-    selected.push({ filePath: file2.filePath, tokens: file2.tokens });
-    remainingBudget -= file2.tokens;
-    if (remainingBudget <= 0)
-      break;
+    const timestamp = toMs(row.time_created);
+    const candidate = byPath.get(rel) ?? {
+      path: rel,
+      totalReads: 0,
+      rangedReads: 0,
+      fullReads: 0,
+      editCount: 0,
+      latestReadBytes: 0,
+      firstReadAt: timestamp || Date.now(),
+      lastReadAt: 0,
+      ranges: [],
+      rangeMap: new Map
+    };
+    candidate.totalReads++;
+    candidate.firstReadAt = Math.min(candidate.firstReadAt, timestamp || candidate.firstReadAt);
+    candidate.lastReadAt = Math.max(candidate.lastReadAt, timestamp);
+    if (timestamp >= candidate.lastReadAt)
+      candidate.latestReadBytes = Number(row.output_bytes ?? 0);
+    const start = toPositiveInt(row.start_line) ?? toPositiveInt(row.offset_value);
+    const explicitEnd = toPositiveInt(row.end_line);
+    const limit = toPositiveInt(row.limit_value);
+    const end = explicitEnd ?? (start && limit ? start + limit - 1 : null);
+    if (start && end) {
+      candidate.rangedReads++;
+      const key = `${start}:${end}`;
+      const existing = candidate.rangeMap.get(key);
+      if (existing) {
+        existing.count++;
+        existing.lastReadAt = Math.max(existing.lastReadAt, timestamp);
+      } else {
+        candidate.rangeMap.set(key, { start, end, count: 1, lastReadAt: timestamp });
+      }
+    } else {
+      candidate.fullReads++;
+    }
+    byPath.set(rel, candidate);
+  }
+  const edits = args.openCodeDb.prepare(`SELECT p.session_id,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.filePath') AS file_path,
+                    COUNT(*) AS edit_count
+               FROM part p
+              WHERE json_extract(p.data, '$.type') = 'tool'
+                AND json_extract(p.data, '$.tool') IN ('edit', 'write', 'mcp_edit', 'mcp_write')
+                AND json_extract(json_extract(p.data, '$.state'), '$.input.filePath') IS NOT NULL
+              GROUP BY p.session_id, file_path`).all();
+  for (const row of edits) {
+    if (!primaryIds.has(row.session_id) || !row.file_path)
+      continue;
+    const rel = normalizeProjectRelativePath(args.projectPath, row.file_path);
+    if (!rel)
+      continue;
+    const candidate = byPath.get(rel);
+    if (candidate)
+      candidate.editCount += Number(row.edit_count ?? 0);
   }
-  return selected;
+  return [...byPath.values()].filter((candidate) => candidate.totalReads >= args.minReads).map(({ rangeMap, ...candidate }) => ({
+    ...candidate,
+    ranges: coalesceRanges([...rangeMap.values()])
+  })).sort((a, b) => b.totalReads - a.totalReads || b.lastReadAt - a.lastReadAt).slice(0, 200);
 }
 
+// ../plugin/src/features/magic-context/key-files/storage-key-files.ts
+init_logger();
+
 // ../plugin/src/features/magic-context/key-files/identify-key-files.ts
 var KEY_FILES_SYSTEM_PROMPT = "You are a file importance evaluator. Given read statistics about files in a coding session, identify which are core orientation files worth pinning in context. Return a JSON array.";
-function buildKeyFilesPrompt(candidates, tokenBudget, minReads) {
-  const statsText = candidates.map((s) => `- **${s.filePath}** — ${s.fullReadCount} full reads, ${s.editCount} edits, ~${s.latestReadTokens} tokens`).join(`
+class KeyFilesValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KeyFilesValidationError";
+  }
+}
+function computeGenerationConfigHash(config2) {
+  return sha256(JSON.stringify({ budget: config2.token_budget, min_reads: config2.min_reads }));
+}
+function extractJsonObject(text) {
+  const fenced = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (fenced?.[1])
+    return fenced[1];
+  const object2 = text.match(/\{[\s\S]*\}/);
+  if (object2?.[0])
+    return object2[0];
+  throw new KeyFilesValidationError("missing JSON object");
+}
+function formatCandidates(candidates) {
+  return candidates.map((candidate) => {
+    const ranges = candidate.ranges.map((range) => `${range.start}-${range.end} (${range.count}x)`).join(", ");
+    return `| ${candidate.path} | ${candidate.totalReads} | ${new Date(candidate.lastReadAt).toISOString()} | ${ranges || "full reads"} |`;
+  }).join(`
+`);
+}
+function buildV6KeyFilesPrompt(args) {
+  const current = args.currentRows.map((row) => `- ${row.path}: ${row.localTokenEstimate} tokens, stale=${row.staleReason ?? "fresh"}`).join(`
 `);
-  return `## Identify Key Files for Pinning
+  return `## Task: Identify project key files
 
-The following files were fully read ${minReads}+ times during a coding session.
-Identify which ones are **core orientation files** worth keeping permanently in context.
+You are deciding which files this project's primary agent should always see as orientation context. The injection budget is **${args.config.token_budget} tokens** for all files combined.
 
-### Signals of a core orientation file:
-- Read many times across different phases of work (not clustered in one task)
-- Read without editing — consulted for understanding, not modification
-- Contains architecture, configuration, types, or key abstractions
+## Read history (primary sessions only, project-scoped)
 
-### Signals of a NON-core file (exclude):
-- Read many times but always edited — actively working on it
-- Very large (>5000 tokens) — too expensive to pin
-- Test files, scripts, or generated files
+| path | total reads | last read | common line ranges |
+| --- | ---: | --- | --- |
+${formatCandidates(args.candidates)}
 
-### Token budget: ${tokenBudget} tokens total
+## Current key files (if any)
 
-### Files:
-${statsText}
+${current || "(none)"}
+
+## Tools available
+
+- \`aft_outline(target=<path>)\` — get symbol outline for a file
+- \`aft_zoom(filePath=<path>, symbol=<name>)\` — get full source of one symbol
+
+## Output (strict JSON)
 
-### Output Format
-Return a JSON array ranked by importance (most important first):
 \`\`\`json
-[
-  {"filePath": "src/path/to/file.ts", "tokens": 2500, "reason": "brief reason"}
-]
+{
+  "no_change": false,
+  "files": [
+    {
+      "path": "src/example.ts",
+      "content": "...outline + symbol bodies stitched from src/example.ts only...",
+      "approx_token_estimate": 1200
+    }
+  ]
+}
 \`\`\`
 
-Only include files you're confident are true orientation files. Return empty array if none qualify.`;
+If current key files are still optimal, return \`{ "no_change": true, "files": [] }\`.
+
+Rules:
+- Each row's content MUST come from ONLY the one file at path. If two files matter, emit two rows.
+- Do NOT emit source_files. One row = one file = one hash.
+- Total approx_token_estimate must be < ${args.config.token_budget}.
+- path must be relative, no .., no absolute paths, no symlinks escaping project root.
+- path must be unique case-sensitively and case-insensitively.
+- content must be plain text; no XML tags inside.`;
+}
+function validateLlmOutput(raw, config2, projectPath) {
+  let obj;
+  try {
+    obj = JSON.parse(extractJsonObject(raw));
+  } catch (error51) {
+    if (error51 instanceof KeyFilesValidationError)
+      throw error51;
+    throw new KeyFilesValidationError(`invalid JSON: ${getErrorMessage(error51)}`);
+  }
+  if (!obj || typeof obj !== "object")
+    throw new KeyFilesValidationError("output must be object");
+  const record2 = obj;
+  if (typeof record2.no_change !== "boolean")
+    throw new KeyFilesValidationError("missing no_change");
+  if (!Array.isArray(record2.files))
+    throw new KeyFilesValidationError("missing files array");
+  if (record2.no_change && record2.files.length > 0)
+    throw new KeyFilesValidationError("no_change=true with files");
+  if (!record2.no_change && record2.files.length === 0)
+    throw new KeyFilesValidationError("no_change=false with empty files");
+  const seen = new Set;
+  const seenLower = new Set;
+  const files = [];
+  for (const item of record2.files) {
+    if (!item || typeof item !== "object")
+      throw new KeyFilesValidationError("bad file entry");
+    const file2 = item;
+    if ("source_files" in file2) {
+      throw new KeyFilesValidationError(`source_files field not allowed (one file per row): ${String(file2.path)}`);
+    }
+    if (typeof file2.path !== "string" || file2.path.length === 0)
+      throw new KeyFilesValidationError("bad path");
+    if (file2.path.startsWith("/") || file2.path.includes(".."))
+      throw new KeyFilesValidationError(`escape: ${file2.path}`);
+    if (seen.has(file2.path))
+      throw new KeyFilesValidationError(`dup path: ${file2.path}`);
+    if (seenLower.has(file2.path.toLowerCase()))
+      throw new KeyFilesValidationError(`case-dup: ${file2.path}`);
+    seen.add(file2.path);
+    seenLower.add(file2.path.toLowerCase());
+    if (!isRelativeProjectFile(projectPath, file2.path))
+      throw new KeyFilesValidationError(`unreadable: ${file2.path}`);
+    if (typeof file2.content !== "string")
+      throw new KeyFilesValidationError(`bad content: ${file2.path}`);
+    if (file2.content.length > 1e5)
+      throw new KeyFilesValidationError(`content >100KB: ${file2.path}`);
+    if (typeof file2.approx_token_estimate !== "number" || file2.approx_token_estimate < 0) {
+      throw new KeyFilesValidationError(`bad token estimate: ${file2.path}`);
+    }
+    const local = estimateTokens(file2.content);
+    if (file2.approx_token_estimate > 0 && (local / file2.approx_token_estimate > 1.5 || local / file2.approx_token_estimate < 0.5)) {
+      log(`key-files: token estimate divergence for ${file2.path}: claimed=${file2.approx_token_estimate}, plugin=${local}`);
+    }
+    files.push({
+      path: file2.path,
+      content: file2.content,
+      approx_token_estimate: file2.approx_token_estimate,
+      local_token_estimate: local
+    });
+  }
+  const total = files.reduce((sum, file2) => sum + file2.local_token_estimate, 0);
+  if (total > config2.token_budget)
+    throw new KeyFilesValidationError(`total ${total} > budget ${config2.token_budget}`);
+  return { no_change: record2.no_change, files };
 }
-function parseKeyFilesOutput(text) {
-  const jsonMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/) ?? text.match(/\[[\s\S]*\]/);
-  if (!jsonMatch)
-    return [];
+function commitKeyFiles(args) {
+  if (args.validated.no_change)
+    return null;
+  const projectPath = resolveProjectPath(args.projectPath) ?? args.projectPath;
+  const resolved = resolveCommitFiles(projectPath, args.validated.files.map((file2) => ({
+    path: file2.path,
+    content: file2.content,
+    localTokenEstimate: file2.local_token_estimate
+  })));
+  const generatedAt = Date.now();
+  const bump = args.bumpVersion ?? bumpKeyFilesVersion;
+  args.db.exec("BEGIN IMMEDIATE");
+  let committed = false;
   try {
-    const raw = jsonMatch[1] ?? jsonMatch[0];
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed))
-      return [];
-    return parsed.filter((item) => typeof item === "object" && item !== null && typeof item.filePath === "string" && typeof item.tokens === "number").map((item) => ({ filePath: item.filePath, tokens: item.tokens }));
-  } catch {
-    return [];
+    if (!peekLeaseHolderAndExpiry(args.db, args.leaseHolderId)) {
+      log(`key-files commit aborted: lease lost (holder ${args.leaseHolderId})`);
+      return null;
+    }
+    args.db.prepare("DELETE FROM project_key_files WHERE project_path = ?").run(projectPath);
+    insertResolvedKeyFiles(args.db, projectPath, resolved, generatedAt, args.modelId, args.configHash);
+    const version2 = bump(args.db, projectPath);
+    args.db.exec("COMMIT");
+    committed = true;
+    log(`key-files committed: ${resolved.length} files, version=${version2}, ${resolved.filter((r) => r.staleReason).length} pre-stale`);
+    return version2;
+  } finally {
+    if (!committed) {
+      try {
+        args.db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+}
+async function runKeyFilesLlm(args) {
+  const createResponse = await args.client.session.create({
+    body: {
+      ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
+      title: "magic-context-dream-key-files-v6"
+    },
+    query: { directory: args.projectPath }
+  });
+  const created = normalizeSDKResponse(createResponse, null, {
+    preferResponseOnMissingData: true
+  });
+  const agentSessionId = typeof created?.id === "string" ? created.id : null;
+  if (!agentSessionId)
+    throw new Error("Could not create key-file identification session.");
+  try {
+    await promptSyncWithModelSuggestionRetry(args.client, {
+      path: { id: agentSessionId },
+      query: { directory: args.projectPath },
+      body: {
+        agent: DREAMER_AGENT,
+        system: KEY_FILES_SYSTEM_PROMPT,
+        parts: [{ type: "text", text: args.prompt, synthetic: true }]
+      }
+    }, {
+      timeoutMs: Math.min(Math.max(0, args.deadline - Date.now()), 5 * 60 * 1000),
+      fallbackModels: args.fallbackModels,
+      callContext: "dreamer:key-files-v6"
+    });
+    const messagesResponse = await args.client.session.messages({
+      path: { id: agentSessionId },
+      query: { directory: args.projectPath }
+    });
+    const messages = normalizeSDKResponse(messagesResponse, [], {
+      preferResponseOnMissingData: true
+    });
+    const text = extractLatestAssistantText(messages);
+    if (!text)
+      throw new Error("Dreamer returned no key-files output.");
+    return text;
+  } finally {
+    await args.client.session.delete({ path: { id: agentSessionId } }).catch(() => {
+      return;
+    });
   }
 }
-function getKeyFileCandidates(openCodeDb, sessionId, minReads, tokenBudget, projectDirectory) {
-  const stats = getSessionReadStats(openCodeDb, sessionId, minReads);
-  const maxPerFileTokens = Math.min(tokenBudget / 2, 5000);
-  const projectPrefix = projectDirectory ? `${projectDirectory.replace(/\/$/, "")}/` : undefined;
-  return stats.filter((s) => s.latestReadTokens > 0 && s.latestReadTokens <= maxPerFileTokens && (!projectPrefix || s.filePath.startsWith(projectPrefix)));
-}
-function applyKeyFileResults(db, sessionId, llmRanked, tokenBudget, candidatePaths) {
-  const filtered = candidatePaths ? llmRanked.filter((f) => candidatePaths.has(f.filePath)) : llmRanked;
-  const selected = greedyFitFiles(filtered, tokenBudget);
-  setKeyFiles(db, sessionId, selected);
-  const totalTokens = selected.reduce((sum, f) => sum + f.tokens, 0);
-  log(`[key-files][${sessionId}] pinned ${selected.length} files (${totalTokens} tokens): ${selected.map((f) => f.filePath).join(", ")}`);
-  return { filesIdentified: selected.length, totalTokens };
-}
-function heuristicKeyFileSelection(db, sessionId, candidates, tokenBudget) {
-  const scored = candidates.map((c) => ({
-    filePath: c.filePath,
-    tokens: c.latestReadTokens,
-    score: c.fullReadCount * 2 - c.editCount * 3
-  })).filter((c) => c.score > 0).sort((a, b) => b.score - a.score);
-  const selected = greedyFitFiles(scored, tokenBudget);
-  setKeyFiles(db, sessionId, selected);
-  const totalTokens = selected.reduce((sum, f) => sum + f.tokens, 0);
-  log(`[key-files][${sessionId}] heuristic pinned ${selected.length} files (${totalTokens} tokens)`);
-  return { filesIdentified: selected.length, totalTokens };
+async function runKeyFilesTask(args) {
+  if (!args.config.enabled)
+    return { committedVersion: null, candidates: 0, noChange: false };
+  if (!isAftAvailable()) {
+    log("[key-files] AFT not available, skipping key-files task");
+    return { committedVersion: null, candidates: 0, noChange: false };
+  }
+  const projectPath = resolveProjectPath(args.projectPath) ?? args.projectPath;
+  const candidates = collectKeyFileCandidates({
+    openCodeDb: args.openCodeDb,
+    magicDb: args.db,
+    projectPath,
+    minReads: args.config.min_reads
+  });
+  if (candidates.length === 0)
+    return { committedVersion: null, candidates: 0, noChange: false };
+  const currentRows = readCurrentKeyFiles(args.db, projectPath);
+  const configHash = computeGenerationConfigHash(args.config);
+  const allRowsFreshAndCurrent = currentRows.length > 0 && currentRows.every((row) => {
+    if (row.staleReason !== null || row.generationConfigHash !== configHash)
+      return false;
+    try {
+      return sha256(readFileSync4(join10(projectPath, row.path))) === row.contentHash;
+    } catch {
+      return false;
+    }
+  });
+  const currentPaths = new Set(currentRows.map((row) => row.path));
+  if (allRowsFreshAndCurrent && candidates.every((candidate) => currentPaths.has(candidate.path))) {
+    log(`key-files: no_change short-circuit (${currentRows.length} rows fresh)`);
+    return { committedVersion: null, candidates: candidates.length, noChange: true };
+  }
+  const prompt = buildV6KeyFilesPrompt({ candidates, currentRows, config: args.config });
+  let validated;
+  const leaseInterval = setInterval(() => {
+    try {
+      if (!renewLease(args.db, args.holderId)) {
+        log("[key-files] lease renewal failed during LLM call");
+      }
+    } catch (error51) {
+      log(`[key-files] lease renewal threw: ${getErrorMessage(error51)}`);
+    }
+  }, 60000);
+  try {
+    try {
+      const raw = await runKeyFilesLlm({
+        client: args.client,
+        parentSessionId: args.parentSessionId,
+        projectPath,
+        prompt,
+        deadline: args.deadline,
+        fallbackModels: args.fallbackModels
+      });
+      validated = validateLlmOutput(raw, args.config, projectPath);
+    } catch (error51) {
+      log(`[key-files] LLM validation failed: ${getErrorMessage(error51)}`);
+      throw error51;
+    }
+    if (validated.no_change)
+      return { committedVersion: null, candidates: candidates.length, noChange: true };
+    const committedVersion = commitKeyFiles({
+      db: args.db,
+      projectPath,
+      validated,
+      configHash,
+      modelId: args.fallbackModels?.[0] ?? "dreamer",
+      leaseHolderId: args.holderId
+    });
+    renewLease(args.db, args.holderId);
+    return { committedVersion, candidates: candidates.length, noChange: false };
+  } finally {
+    clearInterval(leaseInterval);
+  }
 }
 
 // ../plugin/src/features/magic-context/memory/embedding-cache.ts
@@ -162442,11 +163204,11 @@ function logWithStackHead(message, stackHead) {
   log(message, stackHead ? { stackHead } : undefined);
 }
 function getOpenCodeDbPath2() {
-  return join9(getDataDir(), "opencode", "opencode.db");
+  return join11(getDataDir(), "opencode", "opencode.db");
 }
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath2();
-  if (!existsSync6(dbPath)) {
+  if (!existsSync8(dbPath)) {
     log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
     return null;
   }
@@ -162459,178 +163221,6 @@ function openOpenCodeDb() {
     return null;
   }
 }
-function isSessionIdRow(row) {
-  if (row === null || typeof row !== "object") {
-    return false;
-  }
-  return typeof row.sessionId === "string";
-}
-function hasExplicitEmptyKeyFilesOutput(text) {
-  return /```(?:json)?\s*\[\s*\]\s*```/s.test(text) || /^\s*\[\s*\]\s*$/s.test(text);
-}
-async function getActiveProjectSessionIds(args) {
-  try {
-    const { withReadOnlySessionDb: withReadOnlySessionDb2 } = await init_read_session_db().then(() => exports_read_session_db);
-    const projectSessionIds = withReadOnlySessionDb2((openCodeDb) => {
-      const bareIdentity = args.projectIdentity.replace(/^git:/, "");
-      const rows = openCodeDb.prepare("SELECT id FROM session WHERE project_id = ? AND parent_id IS NULL ORDER BY time_updated DESC").all(bareIdentity);
-      return new Set(rows.map((r) => r.id));
-    });
-    if (projectSessionIds.size === 0) {
-      return [];
-    }
-    return args.db.prepare("SELECT session_id AS sessionId FROM session_meta WHERE is_subagent = 0 ORDER BY session_id ASC").all().filter(isSessionIdRow).map((row) => row.sessionId).filter((sessionId) => projectSessionIds.has(sessionId));
-  } catch (error51) {
-    sessionLog(args.projectIdentity, `key-files: OpenCode DB lookup failed, falling back to SDK list: ${getErrorMessage(error51)}`);
-    const listResponse = await args.client.session.list({
-      query: { directory: args.sessionDirectory ?? args.projectIdentity }
-    });
-    const sessions = normalizeSDKResponse(listResponse, [], {
-      preferResponseOnMissingData: true
-    });
-    const projectSessionIds = new Set(sessions.map((session) => typeof session?.id === "string" ? session.id : null).filter((sessionId) => Boolean(sessionId)));
-    if (projectSessionIds.size === 0) {
-      return [];
-    }
-    return args.db.prepare("SELECT session_id AS sessionId FROM session_meta WHERE is_subagent = 0 ORDER BY session_id ASC").all().filter(isSessionIdRow).map((row) => row.sessionId).filter((sessionId) => projectSessionIds.has(sessionId));
-  }
-}
-async function identifyKeyFilesForSession(args) {
-  let openCodeDb = null;
-  try {
-    openCodeDb = openOpenCodeDb();
-    if (!openCodeDb) {
-      return;
-    }
-    const candidates = getKeyFileCandidates(openCodeDb, args.sessionId, args.config.min_reads, args.config.token_budget, args.sessionDirectory);
-    if (candidates.length === 0) {
-      log(`[key-files][${args.sessionId}] no candidates found — skipping`);
-      return;
-    }
-    const prompt = buildKeyFilesPrompt(candidates, args.config.token_budget, args.config.min_reads);
-    const applyHeuristicFallback = () => {
-      heuristicKeyFileSelection(args.db, args.sessionId, candidates, args.config.token_budget);
-    };
-    let agentSessionId = null;
-    const abortController = new AbortController;
-    const leaseInterval = setInterval(() => {
-      try {
-        if (!renewLease(args.db, args.holderId)) {
-          log(`[key-files][${args.sessionId}] lease renewal failed — aborting`);
-          abortController.abort();
-        }
-      } catch {
-        abortController.abort();
-      }
-    }, 60000);
-    try {
-      const createResponse = await args.client.session.create({
-        body: {
-          ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
-          title: `magic-context-dream-key-files-${args.sessionId.slice(0, 12)}`
-        },
-        query: { directory: args.sessionDirectory }
-      });
-      const created = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
-      agentSessionId = typeof created?.id === "string" ? created.id : null;
-      if (!agentSessionId) {
-        throw new Error("Could not create key-file identification session.");
-      }
-      log(`[key-files][${args.sessionId}] child session created ${agentSessionId}`);
-      const remainingMs = Math.max(0, args.deadline - Date.now());
-      await promptSyncWithModelSuggestionRetry(args.client, {
-        path: { id: agentSessionId },
-        query: { directory: args.sessionDirectory },
-        body: {
-          agent: DREAMER_AGENT,
-          system: KEY_FILES_SYSTEM_PROMPT,
-          parts: [{ type: "text", text: prompt, synthetic: true }]
-        }
-      }, {
-        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 }
-      });
-      const messages = normalizeSDKResponse(messagesResponse, [], {
-        preferResponseOnMissingData: true
-      });
-      const responseText = extractLatestAssistantText(messages);
-      if (!responseText) {
-        log(`[key-files][${args.sessionId}] no response from agent — using heuristic fallback`);
-        applyHeuristicFallback();
-        return;
-      }
-      const parsed = parseKeyFilesOutput(responseText);
-      if (parsed.length > 0 || hasExplicitEmptyKeyFilesOutput(responseText)) {
-        const candidatePaths = new Set(candidates.map((c) => c.filePath));
-        applyKeyFileResults(args.db, args.sessionId, parsed, args.config.token_budget, candidatePaths);
-        return;
-      }
-      log(`[key-files][${args.sessionId}] could not parse agent output — using heuristic fallback`);
-      applyHeuristicFallback();
-    } catch (error51) {
-      log(`[key-files][${args.sessionId}] identification failed: ${getErrorMessage(error51)} — using heuristic fallback`);
-      try {
-        applyHeuristicFallback();
-      } catch (fallbackError) {
-        log(`[key-files][${args.sessionId}] heuristic fallback failed: ${getErrorMessage(fallbackError)}`);
-      }
-    } finally {
-      clearInterval(leaseInterval);
-      if (agentSessionId) {
-        await args.client.session.delete({
-          path: { id: agentSessionId },
-          query: { directory: args.sessionDirectory }
-        }).catch((error51) => {
-          log(`[key-files][${args.sessionId}] session cleanup failed: ${getErrorMessage(error51)}`);
-        });
-      }
-    }
-  } finally {
-    if (openCodeDb) {
-      try {
-        closeQuietly(openCodeDb);
-      } catch (error51) {
-        log(`[key-files][${args.sessionId}] failed to close OpenCode DB: ${getErrorMessage(error51)}`);
-      }
-    }
-  }
-}
-async function identifyKeyFiles(args) {
-  const sessionIds = await getActiveProjectSessionIds({
-    db: args.db,
-    client: args.client,
-    projectIdentity: args.projectIdentity,
-    sessionDirectory: args.sessionDirectory
-  });
-  if (sessionIds.length === 0) {
-    log(`[key-files] no active sessions found for ${args.projectIdentity}`);
-    return;
-  }
-  log(`[key-files] evaluating ${sessionIds.length} active session(s) for ${args.projectIdentity}`);
-  for (const sessionId of sessionIds) {
-    if (Date.now() > args.deadline) {
-      log("[key-files] deadline reached — stopping key-file identification");
-      break;
-    }
-    await identifyKeyFilesForSession({
-      db: args.db,
-      client: args.client,
-      parentSessionId: args.parentSessionId,
-      sessionDirectory: args.sessionDirectory,
-      holderId: args.holderId,
-      fallbackModels: args.fallbackModels,
-      deadline: args.deadline,
-      sessionId,
-      config: args.config
-    });
-  }
-}
 async function runDream(args) {
   const holderId = crypto.randomUUID();
   const startedAt = Date.now();
@@ -162681,8 +163271,50 @@ async function runDream(args) {
   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;
@@ -162695,18 +163327,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: existsSync6(join9(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync6(join9(docsDir, "STRUCTURE.md"))
+          architecture: existsSync8(join11(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync8(join11(docsDir, "STRUCTURE.md"))
         } : undefined;
         const userMemories = taskName === "archive-stale" ? getActiveUserMemories(args.db).map((um) => ({
           id: um.id,
@@ -162745,6 +163379,9 @@ async function runDream(args) {
           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 }
@@ -162775,7 +163412,10 @@ async function runDream(args) {
           result: null,
           error: errorDescription.brief
         });
-        if (shouldSkipCircuitBreaker(error51, errorDescription.brief)) {
+        if (lostLease) {
+          lastErrorSignature = null;
+          consecutiveSameErrorFailures = 0;
+        } else if (shouldSkipCircuitBreaker(error51, errorDescription.brief)) {
           lastErrorSignature = null;
           consecutiveSameErrorFailures = 0;
         } else {
@@ -162801,18 +163441,24 @@ async function runDream(args) {
         clearInterval(leaseRenewalInterval);
         if (agentSessionId) {
           await args.client.session.delete({
-            path: { id: agentSessionId },
-            query: { directory: args.sessionDirectory ?? args.projectIdentity }
+            path: { id: agentSessionId }
           }).catch((error51) => {
             log("[dreamer] failed to delete child session:", error51);
           });
         }
       }
+      if (lostLease) {
+        recordLeaseLostTask(`task ${taskName}`);
+        break;
+      }
       if (circuitBreakerTripped) {
         break;
       }
     }
-    if (circuitBreakerTripped) {
+    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",
@@ -162821,9 +163467,12 @@ async function runDream(args) {
         error: "Skipped post-task phases after circuit breaker tripped; configure dreamer model/fallback_models in magic-context.jsonc."
       });
     }
-    if (!circuitBreakerTripped && 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,
@@ -162834,6 +163483,9 @@ async function runDream(args) {
           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}`);
@@ -162853,9 +163505,14 @@ async function runDream(args) {
           error: errorDescription.brief
         });
       }
+      if (lostLease)
+        recordLeaseLostTask("user-memory review");
     }
-    if (!circuitBreakerTripped && 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,
@@ -162865,27 +163522,47 @@ async function runDream(args) {
           holderId,
           deadline,
           result,
-          fallbackModels: args.fallbackModels
+          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) {
         const errorDescription = describeError(error51);
         logWithStackHead(`[dreamer] smart note evaluation failed: ${errorDescription.brief}`, errorDescription.stackHead);
       }
+      if (lostLease)
+        recordLeaseLostTask("smart-note evaluation");
     }
-    if (!circuitBreakerTripped && args.experimentalPinKeyFiles?.enabled && Date.now() <= deadline) {
+    if (!circuitBreakerTripped && !lostLease && args.experimentalPinKeyFiles?.enabled && Date.now() <= deadline) {
       const kfStart = Date.now();
       try {
-        await identifyKeyFiles({
-          db: args.db,
-          client: args.client,
-          projectIdentity: args.projectIdentity,
-          parentSessionId,
-          sessionDirectory: args.sessionDirectory ?? args.projectIdentity,
-          holderId,
-          deadline,
-          config: args.experimentalPinKeyFiles,
-          fallbackModels: args.fallbackModels
-        });
+        if (!verifyLeaseStillHeld("before key-file identification")) {
+          throw new Error(lostLeaseReason ?? "Dream lease lost before key-file identification");
+        }
+        const openCodeDb = openOpenCodeDb();
+        if (openCodeDb) {
+          try {
+            await runKeyFilesTask({
+              db: args.db,
+              openCodeDb,
+              client: args.client,
+              projectPath: args.sessionDirectory ?? args.projectIdentity,
+              holderId,
+              deadline,
+              parentSessionId,
+              config: args.experimentalPinKeyFiles,
+              fallbackModels: args.fallbackModels
+            });
+          } finally {
+            closeQuietly(openCodeDb);
+          }
+        }
+        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,
@@ -162901,6 +163578,8 @@ async function runDream(args) {
           error: errorDescription.brief
         });
       }
+      if (lostLease)
+        recordLeaseLostTask("key-file identification");
     }
   } finally {
     releaseLease(args.db, holderId);
@@ -162941,7 +163620,7 @@ async function runDream(args) {
     "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));
   }
@@ -162990,9 +163669,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);
@@ -163096,8 +163777,7 @@ Only include notes whose conditions you could definitively evaluate. Skip notes
     clearInterval(leaseInterval);
     if (agentSessionId) {
       await args.client.session.delete({
-        path: { id: agentSessionId },
-        query: { directory: args.sessionDirectory ?? args.projectIdentity }
+        path: { id: agentSessionId }
       }).catch(() => {});
     }
   }
@@ -164215,6 +164895,9 @@ function executeFlush(db, sessionId) {
   }
 }
 
+// src/context-handler.ts
+import * as crypto2 from "node:crypto";
+
 // ../plugin/src/features/magic-context/scheduler.ts
 init_logger();
 var TTL_PATTERN = /^(\d+)([smh])$/;
@@ -164271,7 +164954,6 @@ function createScheduler(config2) {
     }
   };
 }
-
 // ../plugin/src/features/magic-context/tagger.ts
 var TOOL_COMPOSITE_KEY_SEP = "\x00";
 function makeToolCompositeKey(ownerMsgId, callId) {
@@ -164613,6 +165295,30 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
   return didMutateMessage;
 }
 
+// ../plugin/src/hooks/magic-context/boundary-execution.ts
+var FORCE_MATERIALIZE_PERCENTAGE = 85;
+function detectMidTurnBypassReason(input) {
+  if (input.contextUsage.percentage >= FORCE_MATERIALIZE_PERCENTAGE)
+    return "force-materialize";
+  if (input.historyRefreshSessions.has(input.sessionId))
+    return "explicit-bust";
+  if (input.sessionMeta.isSubagent)
+    return "subagent";
+  return "none";
+}
+function applyMidTurnDeferral(input) {
+  if (input.base === "defer") {
+    return { midTurnAdjustedSchedulerDecision: "defer", sideEffect: "none" };
+  }
+  if (input.bypassReason !== "none") {
+    return { midTurnAdjustedSchedulerDecision: "execute", sideEffect: "none" };
+  }
+  if (input.midTurn) {
+    return { midTurnAdjustedSchedulerDecision: "defer", sideEffect: "set-flag" };
+  }
+  return { midTurnAdjustedSchedulerDecision: "execute", sideEffect: "none" };
+}
+
 // ../plugin/src/hooks/magic-context/caveman.ts
 var PRESERVATION_PATTERNS = [
   /```[\s\S]*?```/g,
@@ -165310,16 +166016,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);
@@ -165351,7 +166065,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;
@@ -165384,9 +166102,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];
@@ -165404,9 +166123,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;
@@ -165415,17 +166135,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;
 }
 
@@ -166367,10 +167090,10 @@ var DEFAULT_MIN_PROMPT_CHARS = 20;
 async function unifiedSearchWithTimeout(db, sessionId, projectPath, prompt, options, timeoutMs) {
   const controller = new AbortController;
   let timer;
-  const timeoutPromise = new Promise((resolve) => {
+  const timeoutPromise = new Promise((resolve3) => {
     timer = setTimeout(() => {
       controller.abort();
-      resolve(null);
+      resolve3(null);
     }, timeoutMs);
   });
   try {
@@ -166968,7 +167691,7 @@ function injectSessionHistoryIntoPi(db, sessionId, piMessages, isCacheBusting, p
     };
   }
   const boundaryId = prepared.compartmentEndMessageId;
-  const skippedVisible = boundaryId.length > 0 ? trimPiMessagesToBoundary(piMessages, entryIds, boundaryId) : prepared.skippedVisibleMessages;
+  const skippedVisible = boundaryId != null && boundaryId.length > 0 ? trimPiMessagesToBoundary(piMessages, entryIds, boundaryId) : prepared.skippedVisibleMessages;
   const historyBlock = `<session-history>
 ${prepared.block}
 </session-history>`;
@@ -168018,17 +168741,17 @@ function getReducedRecompTokenBudget(currentBudget) {
 }
 
 // ../plugin/src/hooks/magic-context/historian-state-file.ts
-import { mkdirSync as mkdirSync4, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join10 } from "node:path";
+init_data_path();
+import { mkdirSync as mkdirSync5, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join12 } from "node:path";
 var HISTORIAN_STATE_INLINE_THRESHOLD = 30000;
-var HISTORIAN_STATE_DIR = join10(tmpdir2(), "magic-context-historian");
-function maybeWriteHistorianStateFile(sessionId, existingState) {
+function maybeWriteHistorianStateFile(sessionId, existingState, directory) {
   if (existingState.length <= HISTORIAN_STATE_INLINE_THRESHOLD)
     return;
   try {
-    mkdirSync4(HISTORIAN_STATE_DIR, { recursive: true });
-    const path5 = join10(HISTORIAN_STATE_DIR, `state-${sessionId}-${Date.now()}.xml`);
+    const dir = getProjectMagicContextHistorianDir(directory);
+    mkdirSync5(dir, { recursive: true });
+    const path5 = join12(dir, `state-${sessionId}-${Date.now()}.xml`);
     writeFileSync2(path5, existingState, "utf8");
     return path5;
   } catch {
@@ -168045,6 +168768,238 @@ function cleanupHistorianStateFile(path5) {
 
 // src/pi-historian-runner.ts
 init_logger();
+
+// 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 record2 = msg;
+      if (record2.role === "assistant") {
+        latestAssistantIndex = i;
+        latestAssistant = record2;
+        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 record2 = msg;
+    if (record2.role !== "toolResult")
+      continue;
+    if (typeof record2.toolCallId === "string") {
+      pairedToolResultIds.add(record2.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 record2 = item;
+    if (record2.type === "toolCall" && typeof record2.id === "string") {
+      ids.add(record2.id);
+    }
+  }
+  return ids;
+}
+function readPiSessionMessages(ctx) {
+  const sm = ctx.sessionManager;
+  if (sm === undefined)
+    return [];
+  const getBranch = sm.getBranch;
+  if (typeof getBranch !== "function")
+    return [];
+  let entries;
+  try {
+    entries = getBranch.call(sm);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(entries))
+    return [];
+  return convertEntriesToRawMessages(entries);
+}
+function convertEntriesToRawMessages(entries) {
+  const result = [];
+  let nextOrdinal = 1;
+  let pendingToolParts = [];
+  let pendingFirstRealId = "";
+  for (const entry of entries) {
+    if (!isMessageEntry(entry)) {
+      continue;
+    }
+    const msg = entry.message;
+    const role = msg.role;
+    if (role === "toolResult") {
+      pendingToolParts.push(...synthesizeToolResultParts(msg));
+      if (pendingFirstRealId === "") {
+        pendingFirstRealId = entry.id;
+      }
+      continue;
+    }
+    if (role === "user") {
+      const parts = [
+        ...pendingToolParts,
+        ...synthesizeUserParts(msg)
+      ];
+      pendingToolParts = [];
+      pendingFirstRealId = "";
+      result.push({
+        ordinal: nextOrdinal++,
+        id: entry.id,
+        role: "user",
+        parts
+      });
+      continue;
+    }
+    if (role === "assistant") {
+      if (pendingToolParts.length > 0) {
+        result.push({
+          ordinal: nextOrdinal++,
+          id: pendingFirstRealId,
+          role: "user",
+          parts: pendingToolParts
+        });
+        pendingToolParts = [];
+        pendingFirstRealId = "";
+      }
+      result.push({
+        ordinal: nextOrdinal++,
+        id: entry.id,
+        role: "assistant",
+        parts: synthesizeAssistantParts(msg)
+      });
+      continue;
+    }
+    result.push({
+      ordinal: nextOrdinal++,
+      id: entry.id,
+      role: typeof role === "string" ? role : "unknown",
+      parts: []
+    });
+  }
+  if (pendingToolParts.length > 0) {
+    result.push({
+      ordinal: nextOrdinal,
+      id: pendingFirstRealId,
+      role: "user",
+      parts: pendingToolParts
+    });
+  }
+  return result;
+}
+function isMessageEntry(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const v = value;
+  if (v.type !== "message")
+    return false;
+  if (typeof v.id !== "string")
+    return false;
+  if (v.message === null || typeof v.message !== "object")
+    return false;
+  return true;
+}
+function synthesizeUserParts(msg) {
+  const m = msg;
+  if (typeof m.content === "string") {
+    if (m.content.trim().length === 0)
+      return [];
+    return [{ type: "text", text: m.content }];
+  }
+  if (!Array.isArray(m.content))
+    return [];
+  const parts = [];
+  for (const c of m.content) {
+    if (c === null || typeof c !== "object")
+      continue;
+    const cc = c;
+    if (cc.type === "text" && typeof cc.text === "string") {
+      parts.push({ type: "text", text: cc.text });
+    }
+  }
+  return parts;
+}
+function synthesizeAssistantParts(msg) {
+  const m = msg;
+  if (!Array.isArray(m.content))
+    return [];
+  const parts = [];
+  for (const c of m.content) {
+    if (c === null || typeof c !== "object")
+      continue;
+    const cc = c;
+    if (cc.type === "text" && typeof cc.text === "string") {
+      parts.push({ type: "text", text: cc.text });
+    } else if (cc.type === "toolCall" && typeof cc.id === "string") {
+      parts.push({
+        type: "tool",
+        tool: typeof cc.name === "string" ? cc.name : "unknown",
+        callID: cc.id,
+        state: {
+          input: cc.arguments ?? {}
+        }
+      });
+    }
+  }
+  return parts;
+}
+function synthesizeToolResultParts(msg) {
+  const m = msg;
+  const callID = typeof m.toolCallId === "string" ? m.toolCallId : "";
+  const tool = typeof m.toolName === "string" ? m.toolName : "unknown";
+  if (!callID)
+    return [];
+  let output = "";
+  if (Array.isArray(m.content)) {
+    const fragments = [];
+    for (const c of m.content) {
+      if (c === null || typeof c !== "object")
+        continue;
+      const cc = c;
+      if (cc.type === "text" && typeof cc.text === "string") {
+        fragments.push(cc.text);
+      }
+    }
+    output = fragments.join(`
+`);
+  }
+  return [
+    {
+      type: "tool",
+      tool,
+      callID,
+      state: {
+        output
+      }
+    }
+  ];
+}
+
+// src/pi-historian-runner.ts
 var HISTORIAN_AGENT_NAME = "magic-context-historian";
 var DEFAULT_HISTORIAN_TIMEOUT_MS2 = 120000;
 var HISTORIAN_ALERT_COOLDOWN_MS = 60 * 1000;
@@ -168128,7 +169083,7 @@ async function runPiHistorian(deps) {
       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, `pi-historian: existing state offloaded to file (${existingState.length} chars) → ${stateFilePath}`);
       }
@@ -168339,191 +169294,160 @@ function appendPiNativeCompaction(args) {
   }
 }
 function findFirstKeptEntryId(entries, lastCompactedOrdinal) {
-  let ordinal = 0;
-  for (const entry of entries) {
-    if (!entry || typeof entry !== "object")
-      continue;
-    const e = entry;
-    if (e.type !== "message")
-      continue;
-    const role = e.message?.role;
-    if (role !== "user" && role !== "assistant")
-      continue;
-    ordinal++;
-    if (ordinal === lastCompactedOrdinal + 1) {
-      return typeof e.id === "string" && e.id.length > 0 ? e.id : null;
-    }
-  }
-  return null;
+  const rawMessages = convertEntriesToRawMessages(entries);
+  const target = lastCompactedOrdinal + 1;
+  const match = rawMessages.find((m) => m.ordinal === target);
+  if (!match)
+    return null;
+  return match.id.length > 0 ? match.id : null;
 }
 
-// src/read-session-pi.ts
-function readPiSessionMessages(ctx) {
-  const sm = ctx.sessionManager;
-  if (sm === undefined)
-    return [];
-  const getBranch = sm.getBranch;
-  if (typeof getBranch !== "function")
-    return [];
-  let entries;
-  try {
-    entries = getBranch.call(sm);
-  } catch {
-    return [];
+// src/pi-todo-inject.ts
+function getMessageId(message) {
+  if (typeof message.responseId === "string" && message.responseId.length > 0) {
+    return message.responseId;
   }
-  if (!Array.isArray(entries))
-    return [];
-  return convertEntriesToRawMessages(entries);
+  if (typeof message.timestamp === "number") {
+    return `pi-ts-${message.timestamp}`;
+  }
+  return "";
 }
-function convertEntriesToRawMessages(entries) {
-  const result = [];
-  let nextOrdinal = 1;
-  let pendingToolParts = [];
-  for (const entry of entries) {
-    if (!isMessageEntry(entry)) {
-      continue;
-    }
-    const msg = entry.message;
-    const role = msg.role;
-    if (role === "toolResult") {
-      pendingToolParts.push(...synthesizeToolResultParts(msg));
-      continue;
-    }
-    if (role === "user") {
-      const parts = [
-        ...pendingToolParts,
-        ...synthesizeUserParts(msg)
-      ];
-      pendingToolParts = [];
-      result.push({
-        ordinal: nextOrdinal++,
-        id: entry.id,
-        role: "user",
-        parts
-      });
-      continue;
-    }
-    if (role === "assistant") {
-      if (pendingToolParts.length > 0) {
-        result.push({
-          ordinal: nextOrdinal++,
-          id: "",
-          role: "user",
-          parts: pendingToolParts
-        });
-        pendingToolParts = [];
-      }
-      result.push({
-        ordinal: nextOrdinal++,
-        id: entry.id,
-        role: "assistant",
-        parts: synthesizeAssistantParts(msg)
-      });
+function hasToolCallWithId(message, callId) {
+  if (!Array.isArray(message.content))
+    return false;
+  for (const block of message.content) {
+    if (!block || typeof block !== "object")
       continue;
-    }
-    result.push({
-      ordinal: nextOrdinal++,
-      id: entry.id,
-      role: typeof role === "string" ? role : "unknown",
-      parts: []
-    });
+    const t = block.type;
+    const id = block.id;
+    if (t === "toolCall" && id === callId)
+      return true;
   }
-  if (pendingToolParts.length > 0) {
-    result.push({
-      ordinal: nextOrdinal,
-      id: "",
-      role: "user",
-      parts: pendingToolParts
-    });
+  return false;
+}
+function findToolResultAfter(messages, assistantIndex, callId) {
+  for (let i = assistantIndex + 1;i < messages.length; i += 1) {
+    const m = messages[i];
+    if (!m || typeof m !== "object")
+      continue;
+    const role = m.role;
+    const tcId = m.toolCallId;
+    if (role === "toolResult" && tcId === callId)
+      return i;
+    if (role === "assistant")
+      return -1;
   }
-  return result;
+  return -1;
 }
-function isMessageEntry(value) {
-  if (value === null || typeof value !== "object")
-    return false;
-  const v = value;
-  if (v.type !== "message")
-    return false;
-  if (typeof v.id !== "string")
-    return false;
-  if (v.message === null || typeof v.message !== "object")
-    return false;
-  return true;
+function piBlocksFromSynthetic(part) {
+  return {
+    call: {
+      type: "toolCall",
+      id: part.callID,
+      name: part.tool,
+      arguments: { todos: part.state.input.todos },
+      syntheticTodoMarker: true
+    },
+    result: {
+      role: "toolResult",
+      toolCallId: part.callID,
+      toolName: part.tool,
+      content: [{ type: "text", text: part.state.output }],
+      timestamp: 0,
+      syntheticTodoMarker: true
+    }
+  };
 }
-function synthesizeUserParts(msg) {
-  const m = msg;
-  if (typeof m.content === "string") {
-    if (m.content.trim().length === 0)
-      return [];
-    return [{ type: "text", text: m.content }];
-  }
-  if (!Array.isArray(m.content))
-    return [];
-  const parts = [];
-  for (const c of m.content) {
-    if (c === null || typeof c !== "object")
+function injectByAssistantId(messages, messageId, part) {
+  for (let i = 0;i < messages.length; i += 1) {
+    const m = messages[i];
+    if (!m || typeof m !== "object")
       continue;
-    const cc = c;
-    if (cc.type === "text" && typeof cc.text === "string") {
-      parts.push({ type: "text", text: cc.text });
+    if (m.role !== "assistant")
+      continue;
+    const assistant = m;
+    if (getMessageId(assistant) !== messageId)
+      continue;
+    if (hasToolCallWithId(assistant, part.callID)) {
+      if (findToolResultAfter(messages, i, part.callID) >= 0)
+        return true;
     }
+    const { call, result } = piBlocksFromSynthetic(part);
+    if (!Array.isArray(assistant.content))
+      assistant.content = [];
+    if (!hasToolCallWithId(assistant, part.callID)) {
+      assistant.content.push(call);
+    }
+    if (findToolResultAfter(messages, i, part.callID) < 0) {
+      messages.splice(i + 1, 0, result);
+    }
+    return true;
   }
-  return parts;
+  return false;
 }
-function synthesizeAssistantParts(msg) {
-  const m = msg;
-  if (!Array.isArray(m.content))
-    return [];
-  const parts = [];
-  for (const c of m.content) {
-    if (c === null || typeof c !== "object")
+function injectIntoLatestAssistant(messages, part) {
+  for (let i = messages.length - 1;i >= 0; i -= 1) {
+    const m = messages[i];
+    if (!m || typeof m !== "object")
       continue;
-    const cc = c;
-    if (cc.type === "text" && typeof cc.text === "string") {
-      parts.push({ type: "text", text: cc.text });
-    } else if (cc.type === "toolCall" && typeof cc.id === "string") {
-      parts.push({
-        type: "tool",
-        tool: typeof cc.name === "string" ? cc.name : "unknown",
-        callID: cc.id,
-        state: {
-          input: cc.arguments ?? {}
-        }
-      });
+    if (m.role !== "assistant")
+      continue;
+    const assistant = m;
+    const id = getMessageId(assistant);
+    if (id.length === 0)
+      continue;
+    if (hasToolCallWithId(assistant, part.callID)) {
+      if (findToolResultAfter(messages, i, part.callID) >= 0)
+        return id;
+    }
+    const { call, result } = piBlocksFromSynthetic(part);
+    if (!Array.isArray(assistant.content))
+      assistant.content = [];
+    if (!hasToolCallWithId(assistant, part.callID)) {
+      assistant.content.push(call);
+    }
+    if (findToolResultAfter(messages, i, part.callID) < 0) {
+      messages.splice(i + 1, 0, result);
     }
+    return id;
   }
-  return parts;
+  return null;
 }
-function synthesizeToolResultParts(msg) {
-  const m = msg;
-  const callID = typeof m.toolCallId === "string" ? m.toolCallId : "";
-  const tool = typeof m.toolName === "string" ? m.toolName : "unknown";
-  if (!callID)
-    return [];
-  let output = "";
-  if (Array.isArray(m.content)) {
-    const fragments = [];
-    for (const c of m.content) {
-      if (c === null || typeof c !== "object")
-        continue;
-      const cc = c;
-      if (cc.type === "text" && typeof cc.text === "string") {
-        fragments.push(cc.text);
+function injectSyntheticTodowriteForPi(args) {
+  if (args.isSubagent)
+    return args.messages;
+  const persistedAnchor = getPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+  if (args.isCacheBusting) {
+    const part2 = buildSyntheticTodoPart(args.lastTodoState);
+    if (part2 === null) {
+      if (persistedAnchor) {
+        clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
       }
+      return args.messages;
     }
-    output = fragments.join(`
-`);
-  }
-  return [
-    {
-      type: "tool",
-      tool,
-      callID,
-      state: {
-        output
+    if (persistedAnchor && persistedAnchor.callId === part2.callID && injectByAssistantId(args.messages, persistedAnchor.messageId, part2)) {
+      if (persistedAnchor.stateJson.length === 0) {
+        setPersistedTodoSyntheticAnchor(args.db, args.sessionId, persistedAnchor.callId, persistedAnchor.messageId, args.lastTodoState);
       }
+      return args.messages;
     }
-  ];
+    const anchoredMessageId = injectIntoLatestAssistant(args.messages, part2);
+    if (anchoredMessageId) {
+      setPersistedTodoSyntheticAnchor(args.db, args.sessionId, part2.callID, anchoredMessageId, args.lastTodoState);
+    } else if (persistedAnchor) {
+      clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+    }
+    return args.messages;
+  }
+  if (!persistedAnchor || persistedAnchor.stateJson.length === 0) {
+    return args.messages;
+  }
+  const part = buildSyntheticTodoPart(persistedAnchor.stateJson);
+  if (part === null || part.callID !== persistedAnchor.callId) {
+    return args.messages;
+  }
+  injectByAssistantId(args.messages, persistedAnchor.messageId, part);
+  return args.messages;
 }
 
 // src/reasoning-replay-pi.ts
@@ -169294,6 +170218,17 @@ var recentReduceBySession = new Map;
 var liveModelBySession = new Map;
 var toolUsageSinceUserTurn = new Map;
 var latestUserMessageBySession = new Map;
+function resolvePiContextModelKey(ctx) {
+  const model = ctx.model;
+  if (!model)
+    return;
+  if (typeof model.provider !== "string" || model.provider.length === 0) {
+    return;
+  }
+  if (typeof model.id !== "string" || model.id.length === 0)
+    return;
+  return `${model.provider}/${model.id}`;
+}
 function readPiSessionMessageById(ctx, messageId) {
   return readPiSessionMessages(ctx).find((message) => message.id === messageId) ?? null;
 }
@@ -169516,8 +170451,32 @@ function registerPiContextHandler(pi, options) {
       const isFirstContextPassForSession = !firstContextPassSeenBySession.has(sessionId);
       firstContextPassSeenBySession.add(sessionId);
       const piUsage = ctx.getContextUsage?.();
-      let usagePercentage = typeof piUsage?.percent === "number" ? piUsage.percent : 0;
-      const usageInputTokens = typeof piUsage?.tokens === "number" ? piUsage.tokens : 0;
+      const previousModelKey = liveModelBySession.get(sessionId);
+      const currentModelKey = resolvePiContextModelKey(ctx);
+      const modelChanged = previousModelKey !== undefined && currentModelKey !== undefined && previousModelKey !== currentModelKey;
+      if (currentModelKey !== undefined) {
+        liveModelBySession.set(sessionId, currentModelKey);
+      }
+      const sessionMetaForUsage = getOrCreateSessionMeta(options.db, sessionId);
+      if ((isFirstContextPassForSession || modelChanged) && (sessionMetaForUsage.lastContextPercentage > 0 || sessionMetaForUsage.lastInputTokens > 0)) {
+        const reason = isFirstContextPassForSession ? "first pass" : `model switch ${previousModelKey} -> ${currentModelKey}`;
+        sessionLog(sessionId, `pi transform: ${reason} reset — percentage=${sessionMetaForUsage.lastContextPercentage.toFixed(1)}% tokens=${sessionMetaForUsage.lastInputTokens} — clearing stale usage state`);
+        updateSessionMeta(options.db, sessionId, {
+          lastContextPercentage: 0,
+          lastInputTokens: 0
+        });
+        sessionMetaForUsage.lastContextPercentage = 0;
+        sessionMetaForUsage.lastInputTokens = 0;
+      }
+      let usagePercentage = 0;
+      let usageInputTokens = 0;
+      if (sessionMetaForUsage.lastContextPercentage > 0 && sessionMetaForUsage.lastInputTokens > 0) {
+        usagePercentage = sessionMetaForUsage.lastContextPercentage;
+        usageInputTokens = sessionMetaForUsage.lastInputTokens;
+      } else {
+        usagePercentage = typeof piUsage?.percent === "number" ? piUsage.percent : 0;
+        usageInputTokens = typeof piUsage?.tokens === "number" ? piUsage.tokens : 0;
+      }
       let usageContextLimit = typeof piUsage?.contextWindow === "number" && piUsage.contextWindow > 0 ? piUsage.contextWindow : undefined;
       try {
         const overflowState = getOverflowState(options.db, sessionId);
@@ -169531,7 +170490,7 @@ function registerPiContextHandler(pi, options) {
       } catch (err) {
         sessionLog(sessionId, `pi transform: overflow state read failed: ${err instanceof Error ? err.message : String(err)}`);
       }
-      const sessionMeta = getOrCreateSessionMeta(options.db, sessionId);
+      const sessionMeta = sessionMetaForUsage;
       const modelKey = liveModelBySession.get(sessionId);
       let schedulerDecision;
       try {
@@ -169546,6 +170505,29 @@ function registerPiContextHandler(pi, options) {
         schedulerDecision = "execute";
         sessionLog(sessionId, `pi transform: large imported session detected (${piMessageCount} messages, no usage baseline) — forcing execute on first pass`);
       }
+      const schedulerDecisionEarly = schedulerDecision;
+      const midTurn = isMidTurnPi(event, sessionId);
+      const bypassReason = detectMidTurnBypassReason({
+        contextUsage: { percentage: usagePercentage },
+        sessionMeta,
+        historyRefreshSessions,
+        sessionId
+      });
+      const { midTurnAdjustedSchedulerDecision, sideEffect } = applyMidTurnDeferral({
+        base: schedulerDecisionEarly,
+        bypassReason,
+        midTurn
+      });
+      if (sideEffect === "set-flag") {
+        const flagPayload = {
+          id: crypto2.randomUUID(),
+          reason: `${schedulerDecisionEarly}-${bypassReason}`,
+          recordedAt: Date.now()
+        };
+        setDeferredExecutePendingIfAbsent(options.db, sessionId, flagPayload);
+      }
+      schedulerDecision = midTurnAdjustedSchedulerDecision;
+      sessionLog(sessionId, `pi [boundary-exec] base=${schedulerDecisionEarly} bypass=${bypassReason} midTurn=${midTurn} effective=${midTurnAdjustedSchedulerDecision} sideEffect=${sideEffect}`);
       const forceMaterialization = usagePercentage >= FORCE_MATERIALIZATION_PERCENTAGE;
       const isEmergency = usagePercentage >= EMERGENCY_BLOCK_PERCENTAGE;
       if (isEmergency) {
@@ -169560,7 +170542,7 @@ function registerPiContextHandler(pi, options) {
           try {
             await Promise.race([
               histPromise,
-              new Promise((resolve) => setTimeout(resolve, 30000))
+              new Promise((resolve3) => setTimeout(resolve3, 30000))
             ]);
             sessionLog(sessionId, "pi EMERGENCY: historian wait completed (or timed out)");
           } catch {}
@@ -169652,6 +170634,22 @@ function registerPiContextHandler(pi, options) {
           sessionLog(sessionId, `pi auto-search failed: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
+      try {
+        const sessionMetaForTodo = getOrCreateSessionMeta(options.db, sessionId);
+        if (!sessionMetaForTodo.isSubagent && sessionMetaForTodo.lastTodoState !== "") {
+          const isCacheBustingForTodo = isCacheBusting || result.executedWorkThisPass;
+          outputMessages = injectSyntheticTodowriteForPi({
+            db: options.db,
+            sessionId,
+            isSubagent: sessionMetaForTodo.isSubagent,
+            isCacheBusting: isCacheBustingForTodo,
+            lastTodoState: sessionMetaForTodo.lastTodoState,
+            messages: outputMessages
+          });
+        }
+      } catch (err) {
+        sessionLog(sessionId, `pi synthetic todowrite injection failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
       clearLastTransformErrorIfSet(options.db, sessionId);
       return { messages: outputMessages };
     } catch (err) {
@@ -169833,16 +170831,25 @@ function maybeFireHistorian(args) {
   }
   let usage;
   try {
-    const piUsage = ctx.getContextUsage?.();
-    if (!piUsage || piUsage.tokens === null || piUsage.percent === null || piUsage.contextWindow === 0) {
-      sessionLog(sessionId, `pi-historian trigger eval: no usage info yet (tokens=${piUsage?.tokens ?? "<no piUsage>"}, percent=${piUsage?.percent ?? "<no piUsage>"}, contextWindow=${piUsage?.contextWindow ?? "<no piUsage>"})`);
-      return;
+    const sessionMetaForUsage = getOrCreateSessionMeta(db, sessionId);
+    if (sessionMetaForUsage.lastContextPercentage > 0 && sessionMetaForUsage.lastInputTokens > 0) {
+      usage = {
+        percentage: sessionMetaForUsage.lastContextPercentage,
+        inputTokens: sessionMetaForUsage.lastInputTokens
+      };
+      sessionLog(sessionId, `pi-historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens) [from session_meta], checking trigger...`);
+    } else {
+      const piUsage = ctx.getContextUsage?.();
+      if (!piUsage || piUsage.tokens === null || piUsage.percent === null || piUsage.contextWindow === 0) {
+        sessionLog(sessionId, `pi-historian trigger eval: no usage info yet (tokens=${piUsage?.tokens ?? "<no piUsage>"}, percent=${piUsage?.percent ?? "<no piUsage>"}, contextWindow=${piUsage?.contextWindow ?? "<no piUsage>"})`);
+        return;
+      }
+      usage = {
+        percentage: piUsage.percent,
+        inputTokens: piUsage.tokens
+      };
+      sessionLog(sessionId, `pi-historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens) [piUsage fallback], checking trigger...`);
     }
-    usage = {
-      percentage: piUsage.percent,
-      inputTokens: piUsage.tokens
-    };
-    sessionLog(sessionId, `pi-historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens), checking trigger...`);
   } catch (err) {
     sessionLog(sessionId, `pi-historian trigger eval: getContextUsage threw: ${err instanceof Error ? err.message : String(err)}`);
     return;
@@ -169854,6 +170861,11 @@ function maybeFireHistorian(args) {
   let triggered = false;
   try {
     if (isFirstContextPassForSession) {
+      const sessionMeta2 = getOrCreateSessionMeta(db, sessionId);
+      if (sessionMeta2.compartmentInProgress && !inFlightHistorian.has(sessionId)) {
+        updateSessionMeta(db, sessionId, { compartmentInProgress: false });
+        sessionLog(sessionId, "pi-historian: cleared stale compartmentInProgress flag on first context pass after restart");
+      }
       const failureState = getHistorianFailureState(db, sessionId);
       const shouldRecoverOnFirstPass = failureState.failureCount > 0 && hasEligiblePiCompartmentHistory(db, sessionId);
       if (shouldRecoverOnFirstPass) {
@@ -169897,6 +170909,7 @@ Historian previously failed ${failureState.failureCount} time(s), so magic-conte
   }
 }
 async function runPipeline(args) {
+  let executedWorkThisPass = false;
   if (args.temporalAwareness) {
     try {
       const injected = injectPiTemporalMarkers(args.messages);
@@ -169927,9 +170940,15 @@ async function runPipeline(args) {
   }
   const hasPendingMaterializeSignal = hasPendingMaterialization(args.sessionId);
   if (args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal) {
-    applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags);
-    if (hasPendingMaterializeSignal) {
-      consumePendingMaterialization(args.sessionId);
+    try {
+      applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags);
+      executedWorkThisPass = true;
+      if (hasPendingMaterializeSignal) {
+        consumePendingMaterialization(args.sessionId);
+      }
+    } catch (err) {
+      sessionLog(args.sessionId, `pi pending operations failed: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
     }
   }
   const flushedSliceTags = getTagsByNumbers(args.db, args.sessionId, [
@@ -169983,6 +171002,7 @@ async function runPipeline(args) {
         caveman: args.heuristics.caveman
       });
       heuristicsExecuted = true;
+      executedWorkThisPass = true;
     } catch (err) {
       sessionLog(args.sessionId, `pi heuristic cleanup failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -170005,6 +171025,7 @@ async function runPipeline(args) {
           sessionLog(args.sessionId, `pi reasoning cleared on execute: cleared=${clearOutcome.cleared} watermark=${prevWatermark}->${clearOutcome.newWatermark}`);
         }
       }
+      executedWorkThisPass = true;
     } catch (err) {
       sessionLog(args.sessionId, `pi reasoning clearing failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -170027,6 +171048,16 @@ async function runPipeline(args) {
     messages: args.messages,
     isCacheBusting: args.isCacheBusting
   });
+  if (executedWorkThisPass) {
+    try {
+      const currentFlag = peekDeferredExecutePending(args.db, args.sessionId);
+      if (currentFlag !== null) {
+        clearDeferredExecutePendingIfMatches(args.db, args.sessionId, currentFlag);
+      }
+    } catch (err) {
+      sessionLog(args.sessionId, `pi [boundary-exec] drain failed (continuing): ${err}`);
+    }
+  }
   const outputMessages = transcript.getOutputMessages();
   try {
     const counts = tokenizePiMessages(outputMessages);
@@ -170040,6 +171071,7 @@ async function runPipeline(args) {
   return {
     messages: outputMessages,
     heuristicsExecuted,
+    executedWorkThisPass,
     historyInjected: injectionResult?.injected ?? false,
     heuristicsResult,
     injectionResult
@@ -170236,7 +171268,7 @@ init_logger();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { join as join11 } from "node:path";
+import { join as join13 } from "node:path";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 function randomBase62(length) {
   const chars = [];
@@ -170257,7 +171289,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join11(getDataDir(), "opencode", "opencode.db");
+  return join13(getDataDir(), "opencode", "opencode.db");
 }
 var cachedWriteDb = null;
 var REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
@@ -170807,7 +171839,7 @@ async function runCompressorPass2(args) {
     return null;
   } finally {
     if (agentSessionId) {
-      await client.session.delete({ path: { id: agentSessionId }, query: { directory } }).catch((e) => {
+      await client.session.delete({ path: { id: agentSessionId } }).catch((e) => {
         sessionLog(sessionId, "compressor: session cleanup failed:", getErrorMessage(e));
       });
     }
@@ -170815,11 +171847,13 @@ async function runCompressorPass2(args) {
 }
 
 // ../plugin/src/hooks/magic-context/compartment-runner-historian.ts
-import { mkdirSync as mkdirSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join12 } from "node:path";
+import { mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join14 } from "node:path";
 init_magic_context();
-var HISTORIAN_RESPONSE_DUMP_DIR = join12(tmpdir3(), "magic-context-historian");
+init_data_path();
+function historianResponseDumpDir(directory) {
+  return getProjectMagicContextHistorianDir(directory);
+}
 var MAX_HISTORIAN_RETRIES = 2;
 async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
@@ -170971,7 +172005,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);
@@ -170982,7 +172016,7 @@ async function runHistorianPrompt(args) {
     };
   } finally {
     if (agentSessionId) {
-      await client.session.delete({ path: { id: agentSessionId }, query: { directory: sessionDirectory } }).catch((e) => {
+      await client.session.delete({ path: { id: agentSessionId } }).catch((e) => {
         sessionLog(parentSessionId, "compartment agent: session cleanup failed", getErrorMessage(e));
       });
     }
@@ -171047,8 +172081,8 @@ function isTransientHistorianPromptError(message) {
   ].some((token) => normalized.includes(token));
 }
 function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
   });
 }
 function cleanupHistorianDump(sessionId, dumpPath) {
@@ -171063,12 +172097,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 = join12(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    const dumpPath = join14(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
     writeFileSync3(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
@@ -171293,9 +172328,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);
@@ -171510,8 +172554,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);
       }
@@ -171521,6 +172567,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"}.`,
@@ -171586,7 +172636,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 });
@@ -171682,8 +172732,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) {
@@ -171732,21 +172784,39 @@ Staging data preserved for resume on next attempt.`;
 
 // ../plugin/src/hooks/magic-context/compartment-runner.ts
 var activeRuns = new Map;
+function markActiveCompartmentRunPublished(sessionId) {
+  const activeRun = activeRuns.get(sessionId);
+  if (activeRun)
+    activeRun.published = true;
+}
+function withPublishedCallback(deps) {
+  return {
+    ...deps,
+    onCompartmentStatePublished: (sid) => {
+      markActiveCompartmentRunPublished(sid);
+      deps.onCompartmentStatePublished?.(sid);
+    }
+  };
+}
 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);
+    }
   }
 }
 
@@ -172235,11 +173305,11 @@ import {
   matchesKey,
   truncateToWidth,
   visibleWidth
-} from "@mariozechner/pi-tui";
+} from "@earendil-works/pi-tui";
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.18.0",
+  version: "0.20.0",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -172265,7 +173335,7 @@ var package_default = {
     "README.md"
   ],
   scripts: {
-    build: "bun build src/index.ts src/subagent-entry.ts --outdir dist --target node --format esm --external @mariozechner/pi-coding-agent --external @mariozechner/pi-tui --external @huggingface/transformers --external better-sqlite3",
+    build: "bun build src/index.ts src/subagent-entry.ts --outdir dist --target node --format esm --external @earendil-works/pi-coding-agent --external @earendil-works/pi-tui --external @huggingface/transformers --external better-sqlite3",
     typecheck: "tsc --noEmit",
     test: "bun test",
     lint: "biome check src",
@@ -172285,15 +173355,15 @@ var package_default = {
   },
   devDependencies: {
     "@biomejs/biome": "^2.4.7",
-    "@mariozechner/pi-coding-agent": "^0.71.0",
-    "@mariozechner/pi-tui": "^0.71.0",
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@earendil-works/pi-tui": "^0.74.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
     typescript: "^5.8.0"
   },
   peerDependencies: {
-    "@mariozechner/pi-coding-agent": "^0.71.0",
-    "@mariozechner/pi-tui": "^0.71.0"
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@earendil-works/pi-tui": "^0.74.0"
   },
   exports: {
     ".": {
@@ -172776,14 +173846,14 @@ function readHistorianState(db, sessionId, meta3) {
 
 // src/config/index.ts
 init_magic_context();
-import { existsSync as existsSync8, readFileSync as readFileSync3 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join15 } from "node:path";
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync7, readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname3, isAbsolute, resolve } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, isAbsolute, resolve as resolve3 } from "node:path";
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
 var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function substituteConfigVariables(input) {
@@ -172802,7 +173872,7 @@ function substituteConfigVariables(input) {
   if (fileMatches.length === 0) {
     return { text, warnings };
   }
-  const configDir = input.configPath ? dirname3(input.configPath) : process.cwd();
+  const configDir = input.configPath ? dirname4(input.configPath) : process.cwd();
   let output = "";
   let cursor = 0;
   for (const match of fileMatches) {
@@ -172820,17 +173890,17 @@ function substituteConfigVariables(input) {
     }
     let filePath = rawPath.trim();
     if (filePath.startsWith("~/")) {
-      filePath = resolve(homedir3(), filePath.slice(2));
+      filePath = resolve3(homedir4(), filePath.slice(2));
     } else if (!isAbsolute(filePath)) {
-      filePath = resolve(configDir, filePath);
+      filePath = resolve3(configDir, filePath);
     }
-    if (!existsSync7(filePath)) {
+    if (!existsSync9(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
     let contents;
     try {
-      contents = readFileSync2(filePath, "utf-8").trim();
+      contents = readFileSync5(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`);
@@ -172843,23 +173913,23 @@ function substituteConfigVariables(input) {
 }
 
 // src/config/index.ts
-var import_comment_json = __toESM(require_src2(), 1);
+var import_comment_json2 = __toESM(require_src2(), 1);
 var CONFIG_FILE_NAME = "magic-context";
 function getProjectConfigPaths(cwd) {
-  const basePath = join13(cwd, ".pi", CONFIG_FILE_NAME);
+  const basePath = join15(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
-  const home = process.env.HOME ?? homedir4();
-  const basePath = join13(home, ".pi", "agent", CONFIG_FILE_NAME);
+  const home = process.env.HOME ?? homedir5();
+  const basePath = join15(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path5) => existsSync8(path5));
+  return paths.find((path5) => existsSync10(path5));
 }
 function loadConfigFile(path5, scope) {
   try {
-    const rawText = readFileSync3(path5, "utf-8");
+    const rawText = readFileSync6(path5, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
       configPath: path5
@@ -172867,7 +173937,7 @@ function loadConfigFile(path5, scope) {
     return {
       path: path5,
       scope,
-      config: import_comment_json.parse(substituted.text),
+      config: import_comment_json2.parse(substituted.text),
       warnings: substituted.warnings.map((warning) => `${path5}: ${warning}`)
     };
   } catch (error51) {
@@ -172981,6 +174051,42 @@ function loadPiConfig(opts = {}) {
   };
 }
 
+// src/pi-pressure.ts
+function extractAssistantUsage(message) {
+  if (!message || typeof message !== "object")
+    return null;
+  const m = message;
+  if (m.role !== "assistant")
+    return null;
+  if (!m.usage || typeof m.usage !== "object")
+    return null;
+  const u = m.usage;
+  const result = {};
+  if (typeof u.input === "number")
+    result.input = u.input;
+  if (typeof u.output === "number")
+    result.output = u.output;
+  if (typeof u.cacheRead === "number")
+    result.cacheRead = u.cacheRead;
+  if (typeof u.cacheWrite === "number")
+    result.cacheWrite = u.cacheWrite;
+  if (typeof u.totalTokens === "number")
+    result.totalTokens = u.totalTokens;
+  return result;
+}
+function computePiPressure(usage, contextLimit) {
+  if (!usage)
+    return null;
+  const input = usage.input ?? 0;
+  const cacheRead = usage.cacheRead ?? 0;
+  const cacheWrite = usage.cacheWrite ?? 0;
+  const inputTokens = input + cacheRead + cacheWrite;
+  if (inputTokens === 0)
+    return null;
+  const percentage = contextLimit > 0 ? inputTokens / contextLimit * 100 : 0;
+  return { inputTokens, percentage };
+}
+
 // src/strip-tag-prefix.ts
 var TAG_PREFIX_REGEX2 = /^(\u00a7\d+\u00a7\s*)+/;
 function stripTagPrefixFromAssistantMessage(message) {
@@ -173006,9 +174112,9 @@ function stripTagPrefixFromAssistantMessage(message) {
 }
 
 // src/system-prompt.ts
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync4, realpathSync } from "node:fs";
-import { join as join14, resolve as resolve2, sep } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
+import { join as join17 } from "node:path";
 
 // ../plugin/src/agents/magic-context-prompt.ts
 function getToolHistoryGuidance(dropToolStructure) {
@@ -173097,23 +174203,146 @@ ${GENERIC_SECTION}
 Prefer many small targeted operations over one large blanket operation. Compress early and often — don't wait for warnings.`;
 }
 
+// ../plugin/src/hooks/magic-context/key-files-block.ts
+import { readFileSync as readFileSync7, realpathSync as realpathSync3 } from "node:fs";
+import { join as join16, sep as sep2 } from "node:path";
+init_logger();
+var cachedKeyFilesBySession = new Map;
+var staleUpdates = new Map;
+function staleKey(update) {
+  return `${update.projectPath}\x00${update.path}\x00${update.generatedAtWitness}\x00${update.staleReason}`;
+}
+function queueStaleUpdate(projectPath, path5, generatedAtWitness, staleReason) {
+  const update = { projectPath, path: path5, generatedAtWitness, staleReason };
+  staleUpdates.set(staleKey(update), update);
+}
+function flushStaleUpdates(db) {
+  if (staleUpdates.size === 0)
+    return 0;
+  const updates = [...staleUpdates.values()];
+  staleUpdates.clear();
+  const stmt = db.prepare(`UPDATE project_key_files
+            SET stale_reason = ?1
+          WHERE project_path = ?2
+            AND path = ?3
+            AND generated_at = ?4
+            AND (stale_reason IS NULL OR stale_reason != ?1)`);
+  let changed = 0;
+  for (const update of updates) {
+    try {
+      changed += stmt.run(update.staleReason, update.projectPath, update.path, update.generatedAtWitness).changes;
+    } catch (error51) {
+      log("[key-files] flushStaleUpdates failed:", error51);
+    }
+  }
+  return changed;
+}
+function clearKeyFilesCacheForSession(sessionId) {
+  cachedKeyFilesBySession.delete(sessionId);
+}
+function isUnderProject(projectPath, absPath) {
+  const root = realpathSync3(projectPath);
+  return absPath.startsWith(root + sep2) || absPath === root;
+}
+function buildKeyFilesBlock(db, projectPath, config2 = { enabled: true, tokenBudget: 1e4 }) {
+  if (!config2.enabled)
+    return null;
+  if (!isAftAvailable())
+    return null;
+  const rows = readCurrentKeyFiles(db, projectPath);
+  if (rows.length === 0)
+    return null;
+  for (const row of rows) {
+    if (row.staleReason !== null)
+      continue;
+    let nextStale = null;
+    let observed = false;
+    try {
+      const absPath = join16(projectPath, row.path);
+      const real = realpathSync3(absPath);
+      if (!isUnderProject(projectPath, real)) {
+        nextStale = "missing";
+        observed = true;
+      } else {
+        const diskHash = sha256(readFileSync7(real));
+        if (diskHash !== row.contentHash)
+          nextStale = "content_drift";
+        observed = true;
+      }
+    } catch (error51) {
+      const code = error51?.code;
+      if (code === "ENOENT" || code === "ELOOP") {
+        nextStale = "missing";
+        observed = true;
+      } else {
+        log(`[key-files] freshness check transient failure: ${row.path}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+      }
+    }
+    if (observed && nextStale !== null) {
+      queueStaleUpdate(row.projectPath, row.path, row.generatedAt, nextStale);
+    }
+  }
+  const blocks = [];
+  let used = 0;
+  for (const row of rows) {
+    if (used + row.localTokenEstimate > config2.tokenBudget)
+      break;
+    blocks.push(`  <key-file path="${escapeXmlAttr(row.path)}">
+${escapeXmlContent(row.content)}
+  </key-file>`);
+    used += row.localTokenEstimate;
+  }
+  if (blocks.length === 0)
+    return null;
+  const rendered = `<key-files>
+${blocks.join(`
+`)}
+</key-files>`;
+  flushStaleUpdates(db);
+  return rendered;
+}
+function readVersionedKeyFiles(args) {
+  const config2 = args.config ?? { enabled: true, tokenBudget: 1e4 };
+  if (args.sessionMeta.isSubagent)
+    return null;
+  if (!config2.enabled)
+    return null;
+  if (!isAftAvailable())
+    return null;
+  const projectPath = resolveProjectPath(args.directory ?? args.sessionMeta.sessionId);
+  if (!projectPath)
+    return null;
+  const currentVersion = getKeyFilesVersion(args.db, projectPath);
+  if (args.sessionId) {
+    const cached2 = cachedKeyFilesBySession.get(args.sessionId);
+    if (cached2 && !args.isCacheBusting && cached2.version === currentVersion) {
+      return cached2.value;
+    }
+  }
+  const value = buildKeyFilesBlock(args.db, projectPath, config2);
+  if (args.sessionId) {
+    cachedKeyFilesBySession.set(args.sessionId, { value, version: currentVersion });
+    if (value)
+      sessionLog(args.sessionId, `loaded key-files block (v${currentVersion}, ${value.length} chars)`);
+  }
+  return value;
+}
+
 // src/system-prompt.ts
 init_logger();
 var PROJECT_DOCS_MARKER = "<project-docs>";
 var USER_PROFILE_MARKER = "<user-profile>";
-var KEY_FILES_MARKER = "<key-files>";
 var stickyDateBySession = new Map;
 var cachedDocsBySession = new Map;
 var cachedUserProfileBySession = new Map;
-var cachedKeyFilesBySession = new Map;
 var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join14(directory, filename);
+    const filePath = join17(directory, filename);
     try {
-      if (existsSync9(filePath)) {
-        const content = readFileSync4(filePath, "utf-8").trim();
+      if (existsSync11(filePath)) {
+        const content = readFileSync8(filePath, "utf-8").trim();
         if (content.length > 0) {
           sections.push(`<${filename}>
 ${content}
@@ -173142,56 +174371,6 @@ function buildUserProfileBlock(db) {
 ${items}
 </user-profile>`;
 }
-function buildKeyFilesBlock(db, sessionId, directory, tokenBudget) {
-  const entries = getKeyFiles(db, sessionId);
-  if (entries.length === 0)
-    return null;
-  const sections = [];
-  const projectRoot = resolve2(directory);
-  let remainingBudgetTokens = tokenBudget;
-  for (const entry of entries) {
-    try {
-      const absPath = resolve2(directory, entry.filePath);
-      if (!absPath.startsWith(projectRoot + sep) && absPath !== projectRoot) {
-        log(`[magic-context-pi] key file path escapes project root, skipping: ${entry.filePath}`);
-        continue;
-      }
-      if (!existsSync9(absPath))
-        continue;
-      let realPath;
-      try {
-        realPath = realpathSync(absPath);
-      } catch {
-        continue;
-      }
-      if (!realPath.startsWith(projectRoot + sep) && realPath !== projectRoot) {
-        log(`[magic-context-pi] key file symlink escapes project root, skipping: ${entry.filePath} → ${realPath}`);
-        continue;
-      }
-      const content = readFileSync4(realPath, "utf-8").trim();
-      if (content.length === 0)
-        continue;
-      const fileTokens = estimateTokens(content);
-      if (fileTokens > remainingBudgetTokens) {
-        log(`[magic-context-pi] key file ${entry.filePath} exceeds remaining budget (${fileTokens} > ${remainingBudgetTokens}), skipping`);
-        continue;
-      }
-      remainingBudgetTokens -= fileTokens;
-      sections.push(`<file path="${escapeXmlAttr(entry.filePath)}">
-${escapeXmlContent(content)}
-</file>`);
-    } catch (error51) {
-      log(`[magic-context-pi] failed to read key file ${entry.filePath}:`, error51);
-    }
-  }
-  if (sections.length === 0)
-    return null;
-  return `${KEY_FILES_MARKER}
-${sections.join(`
-
-`)}
-</key-files>`;
-}
 function buildMagicContextBlock(opts) {
   const sections = [];
   const sessionId = opts.sessionId;
@@ -173219,13 +174398,23 @@ function buildMagicContextBlock(opts) {
       sections.push(profileBlock);
   }
   if (opts.pinKeyFilesEnabled && sessionId) {
-    const keyFilesBlock = readCachedAdjunct({
-      cache: cachedKeyFilesBySession,
+    let sessionMeta = null;
+    try {
+      sessionMeta = getOrCreateSessionMeta(opts.db, sessionId);
+    } catch (error51) {
+      sessionLog(sessionId, "Pi key-files session meta load failed:", error51);
+    }
+    const keyFilesBlock = sessionMeta ? readVersionedKeyFiles({
+      db: opts.db,
       sessionId,
+      sessionMeta,
+      directory: opts.cwd,
       isCacheBusting,
-      compute: () => buildKeyFilesBlock(opts.db, sessionId, opts.cwd, opts.pinKeyFilesTokenBudget ?? 1e4),
-      describe: "key files"
-    });
+      config: {
+        enabled: opts.pinKeyFilesEnabled,
+        tokenBudget: opts.pinKeyFilesTokenBudget ?? 1e4
+      }
+    }) : null;
     if (keyFilesBlock)
       sections.push(keyFilesBlock);
   }
@@ -173290,7 +174479,7 @@ function processSystemPromptForCache(args) {
       sessionLog(sessionId, `system prompt date frozen: real=${liveDate}, using=${stickyDate} (cache-stable pass)`);
     }
   }
-  const currentHash = createHash4("md5").update(frozenPrompt).digest("hex");
+  const currentHash = createHash6("md5").update(frozenPrompt).digest("hex");
   const hashChanged = !isFirstHash && currentHash !== previousHash;
   if (hashChanged) {
     sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${frozenPrompt.length})`);
@@ -173318,7 +174507,7 @@ function clearPiSystemPromptSession(sessionId) {
   stickyDateBySession.delete(sessionId);
   cachedDocsBySession.delete(sessionId);
   cachedUserProfileBySession.delete(sessionId);
-  cachedKeyFilesBySession.delete(sessionId);
+  clearKeyFilesCacheForSession(sessionId);
 }
 
 // ../plugin/src/tools/ctx-expand/constants.ts
@@ -178208,6 +179397,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({
@@ -178227,6 +179480,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,
@@ -178341,7 +179595,7 @@ function resolveDreamerFromConfig(config2) {
 }
 async function src_default2(pi) {
   const storageDir = getMagicContextStorageDir();
-  const dbPath = join15(storageDir, "context.db");
+  const dbPath = join18(storageDir, "context.db");
   let db;
   try {
     db = openDatabase();
@@ -178551,9 +179805,17 @@ ${block}` : event.systemPrompt;
       if (event.toolName === "todowrite") {
         const todoArgs = event.args;
         const todos = todoArgs?.todos;
+        const sessionMeta = Array.isArray(todos) ? getOrCreateSessionMeta(db, sessionId) : null;
+        if (sessionMeta && !sessionMeta.isSubagent) {
+          const normalizedTodos = normalizeTodoStateJson(todos);
+          if (normalizedTodos !== null) {
+            updateSessionMeta(db, sessionId, {
+              lastTodoState: normalizedTodos
+            });
+          }
+        }
         if (Array.isArray(todos) && todos.length > 0 && todos.every((t) => t.status === "completed" || t.status === "cancelled")) {
-          const sessionMeta = getOrCreateSessionMeta(db, sessionId);
-          if (!sessionMeta.isSubagent) {
+          if (sessionMeta && !sessionMeta.isSubagent) {
             onNoteTrigger(db, sessionId, "todos_complete");
           }
         }
@@ -178607,14 +179869,62 @@ ${block}` : event.systemPrompt;
         cacheTtlConfig: config2.cache_ttl
       });
       const piUsage = ctx.getContextUsage?.();
-      const updates = { lastResponseTime: Date.now() };
-      if (piUsage && typeof piUsage.percent === "number") {
-        updates.lastContextPercentage = piUsage.percent;
+      const piContextWindow = piUsage && typeof piUsage.contextWindow === "number" ? piUsage.contextWindow : 0;
+      let effectiveContextLimit = piContextWindow;
+      try {
+        const overflowState = getOverflowState(db, sessionId);
+        if (overflowState.detectedContextLimit > 0) {
+          effectiveContextLimit = effectiveContextLimit > 0 ? Math.min(effectiveContextLimit, overflowState.detectedContextLimit) : overflowState.detectedContextLimit;
+        }
+      } catch (err5) {
+        warn("message_end: getOverflowState failed:", err5);
       }
-      if (piUsage && typeof piUsage.tokens === "number") {
+      const usage = extractAssistantUsage(event.message);
+      const pressure = computePiPressure(usage, effectiveContextLimit);
+      const updates = { lastResponseTime: Date.now() };
+      if (pressure) {
+        updates.lastContextPercentage = pressure.percentage;
+        updates.lastInputTokens = pressure.inputTokens;
+      } else if (piUsage && typeof piUsage.tokens === "number") {
         updates.lastInputTokens = piUsage.tokens;
+        if (piUsage.contextWindow > 0) {
+          updates.lastContextPercentage = piUsage.tokens / piUsage.contextWindow * 100;
+        }
       }
       updateSessionMeta(db, sessionId, updates);
+      try {
+        const sessionMetaForTodo = getOrCreateSessionMeta(db, sessionId);
+        if (!sessionMetaForTodo.isSubagent) {
+          const msg = event.message;
+          if (msg && msg.role === "assistant" && Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+              if (!block || typeof block !== "object")
+                continue;
+              const b = block;
+              if (b.type !== "toolCall")
+                continue;
+              if (typeof b.name !== "string")
+                continue;
+              if (!/^todo.*write$|^write.*todo$|^todowrite$/i.test(b.name)) {
+                continue;
+              }
+              const args = b.arguments;
+              const todos = args?.todos;
+              if (!Array.isArray(todos))
+                continue;
+              const normalized = normalizeTodoStateJson(todos);
+              if (normalized === null)
+                continue;
+              updateSessionMeta(db, sessionId, {
+                lastTodoState: normalized
+              });
+              break;
+            }
+          }
+        }
+      } catch (err5) {
+        warn("message_end: synthetic todowrite capture failed:", err5);
+      }
     } catch (err5) {
       warn("message_end: persist session_meta usage failed:", err5);
     }
@@ -178646,7 +179956,7 @@ ${block}` : event.systemPrompt;
     try {
       await Promise.race([
         awaitInFlightHistorians(),
-        new Promise((resolve3) => setTimeout(resolve3, SHUTDOWN_DRAIN_MS))
+        new Promise((resolve4) => setTimeout(resolve4, SHUTDOWN_DRAIN_MS))
       ]);
     } catch (err5) {
       warn("shutdown: historian drain threw:", err5);
@@ -178654,7 +179964,7 @@ ${block}` : event.systemPrompt;
     try {
       await Promise.race([
         awaitInFlightDreamers(),
-        new Promise((resolve3) => setTimeout(resolve3, SHUTDOWN_DRAIN_MS))
+        new Promise((resolve4) => setTimeout(resolve4, SHUTDOWN_DRAIN_MS))
       ]);
     } catch (err5) {
       warn("shutdown: dreamer drain threw:", err5);