@cortexkit/opencode-magic-context 0.19.0 → 0.20.0

package/dist/index.js

@@ -157573,6 +157573,121 @@ function closeQuietly(db) {
   } catch {}
 }
 
+// src/features/magic-context/key-files/project-key-files.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync10, readFileSync as readFileSync9, realpathSync } from "node:fs";
+import { join as join12, resolve as resolve4, sep } from "node:path";
+function sha256(input) {
+  return createHash2("sha256").update(input).digest("hex");
+}
+function resolveProjectPath(directory) {
+  if (!directory?.trim())
+    return null;
+  try {
+    return realpathSync(directory);
+  } catch {
+    return resolve4(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 = readFileSync9(join12(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 (existsSync10(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 = resolve4(projectPath, relativePath);
+    const real = realpathSync(absPath);
+    return real.startsWith(root + sep) || real === root;
+  } catch {
+    return false;
+  }
+}
+var MISSING_CONTENT_HASH = "<missing>", ORPHAN_GRACE_MS;
+var init_project_key_files = __esm(() => {
+  init_logger();
+  ORPHAN_GRACE_MS = 7 * 24 * 60 * 60 * 1000;
+});
+
 // src/features/magic-context/memory/storage-memory-embeddings.ts
 function isEmbeddingBlob(value) {
   return value instanceof Uint8Array || value instanceof ArrayBuffer;
@@ -157692,13 +157807,13 @@ var init_embedding_cache = __esm(() => {
 });
 
 // src/features/magic-context/memory/normalize-hash.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function normalizeMemoryContent(content) {
   return content.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function computeNormalizedHash(content) {
   const normalized = normalizeMemoryContent(content);
-  return createHash2("md5").update(normalized).digest("hex");
+  return createHash3("md5").update(normalized).digest("hex");
 }
 var init_normalize_hash = () => {};
 
@@ -158283,107 +158398,6 @@ function parseUserMemoryRow(row) {
   };
 }
 
-// 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 join11 } from "node:path";
-function getOpenCodeDbPath() {
-  return join11(getDataDir(), "opencode", "opencode.db");
-}
-function closeCachedReadOnlyDb() {
-  if (!cachedReadOnlyDb) {
-    return;
-  }
-  try {
-    closeQuietly(cachedReadOnlyDb.db);
-  } catch (error51) {
-    log("[magic-context] failed to close cached OpenCode read-only DB:", error51);
-  } finally {
-    cachedReadOnlyDb = null;
-  }
-}
-function getReadOnlySessionDb() {
-  const dbPath = getOpenCodeDbPath();
-  if (cachedReadOnlyDb?.path === dbPath) {
-    return cachedReadOnlyDb.db;
-  }
-  closeCachedReadOnlyDb();
-  const db = new Database(dbPath, { readonly: true });
-  cachedReadOnlyDb = { path: dbPath, db };
-  return db;
-}
-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
-                      AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')`).get(sessionId);
-  return typeof row?.count === "number" ? row.count : 0;
-}
-function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
-  const result = new Map;
-  if (messageIds.length === 0)
-    return result;
-  try {
-    withReadOnlySessionDb((db) => {
-      const placeholders = messageIds.map(() => "?").join(",");
-      const rows = db.prepare(`SELECT id, time_created FROM message WHERE session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds);
-      for (const row of rows) {
-        if (typeof row.id === "string" && typeof row.time_created === "number") {
-          result.set(row.id, row.time_created);
-        }
-      }
-    });
-  } catch (error51) {
-    log("[magic-context] failed to resolve message times from OpenCode DB:", error51);
-  }
-  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();
-  init_logger();
-  await init_sqlite();
-});
-
 // src/features/magic-context/memory/cosine-similarity.ts
 function cosineSimilarity(a, b) {
   if (a.length !== b.length) {
@@ -158430,7 +158444,7 @@ var init_embedding_identity = __esm(() => {
 // src/features/magic-context/memory/embedding-local.ts
 import { mkdirSync as mkdirSync4 } from "node:fs";
 import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { join as join15 } from "node:path";
 async function acquireModelLoadLock(lockPath) {
   const waitStart = Date.now();
   while (true) {
@@ -158467,7 +158481,7 @@ async function acquireModelLoadLock(lockPath) {
         log("[magic-context] embedding-load lock wait exceeded, proceeding without lock");
         return async () => {};
       }
-      await new Promise((resolve4) => setTimeout(resolve4, LOCK_POLL_MS));
+      await new Promise((resolve6) => setTimeout(resolve6, LOCK_POLL_MS));
     }
   }
 }
@@ -158564,7 +158578,7 @@ class LocalEmbeddingProvider {
         if (LogLevel && "ERROR" in LogLevel) {
           env.logLevel = LogLevel.ERROR;
         }
-        const modelCacheDir = join13(getMagicContextStorageDir(), "models");
+        const modelCacheDir = join15(getMagicContextStorageDir(), "models");
         try {
           mkdirSync4(modelCacheDir, { recursive: true });
           env.cacheDir = modelCacheDir;
@@ -158572,7 +158586,7 @@ class LocalEmbeddingProvider {
           log("[magic-context] could not create model cache dir, using library default");
         }
         const createPipeline = transformersModule.pipeline;
-        const lockPath = join13(modelCacheDir, ".load.lock");
+        const lockPath = join15(modelCacheDir, ".load.lock");
         const releaseLock = await acquireModelLoadLock(lockPath);
         const stopHeartbeat = startLockHeartbeat(lockPath);
         try {
@@ -158592,7 +158606,7 @@ class LocalEmbeddingProvider {
               }
               const delayMs = 300 * attempt + Math.floor(Math.random() * 200);
               log(`[magic-context] embedding model load attempt ${attempt}/${MAX_ATTEMPTS} failed transiently, retrying in ${delayMs}ms`);
-              await new Promise((resolve4) => setTimeout(resolve4, delayMs));
+              await new Promise((resolve6) => setTimeout(resolve6, delayMs));
             }
           }
           if (this.pipeline) {
@@ -159140,7 +159154,7 @@ var init_storage_memory_fts = __esm(() => {
 
 // src/features/magic-context/memory/project-identity.ts
 import { execSync } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import path4 from "node:path";
 function getRootCommitHash(directory) {
   try {
@@ -159159,7 +159173,7 @@ function getRootCommitHash(directory) {
 }
 function directoryFallback(directory) {
   const canonical = path4.resolve(directory);
-  const hash2 = createHash3("md5").update(canonical).digest("hex").slice(0, 12);
+  const hash2 = createHash4("md5").update(canonical).digest("hex").slice(0, 12);
   return `dir:${hash2}`;
 }
 function resolveProjectIdentity(directory) {
@@ -159240,6 +159254,128 @@ var init_compression_depth_storage = __esm(() => {
   clearDepthStatements = new WeakMap;
 });
 
+// src/hooks/magic-context/read-session-db.ts
+import { join as join16 } from "node:path";
+function getOpenCodeDbPath2() {
+  return join16(getDataDir(), "opencode", "opencode.db");
+}
+function closeCachedReadOnlyDb() {
+  if (!cachedReadOnlyDb) {
+    return;
+  }
+  try {
+    closeQuietly(cachedReadOnlyDb.db);
+  } catch (error51) {
+    log("[magic-context] failed to close cached OpenCode read-only DB:", error51);
+  } finally {
+    cachedReadOnlyDb = null;
+  }
+}
+function getReadOnlySessionDb() {
+  const dbPath = getOpenCodeDbPath2();
+  if (cachedReadOnlyDb?.path === dbPath) {
+    return cachedReadOnlyDb.db;
+  }
+  closeCachedReadOnlyDb();
+  const db = new Database(dbPath, { readonly: true });
+  cachedReadOnlyDb = { path: dbPath, db };
+  return db;
+}
+function withReadOnlySessionDb(fn) {
+  return fn(getReadOnlySessionDb());
+}
+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
+                      AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+function isMidTurn(_deps, sessionId) {
+  try {
+    return withReadOnlySessionDb((db) => isMidTurnFromOpenCodeDb(db, sessionId));
+  } catch (error51) {
+    log("[magic-context] failed to inspect OpenCode mid-turn state:", error51);
+    return false;
+  }
+}
+function isMidTurnFromOpenCodeDb(db, sessionId) {
+  const latestAssistant = db.prepare(`SELECT id,
+                    json_extract(data, '$.finish') as finish
+             FROM message
+             WHERE session_id = ?
+               AND json_extract(data, '$.role') = 'assistant'
+             ORDER BY time_created DESC
+             LIMIT 1`).get(sessionId);
+  if (typeof latestAssistant?.id !== "string")
+    return false;
+  if (latestAssistant.finish === "tool-calls")
+    return true;
+  const partRows = db.prepare("SELECT data FROM part WHERE session_id = ? AND message_id = ?").all(sessionId, latestAssistant.id);
+  return partRows.some((row) => {
+    if (typeof row.data !== "string" || row.data.length === 0)
+      return false;
+    try {
+      const part = JSON.parse(row.data);
+      return part.type === "tool" && part.providerExecuted !== true;
+    } catch {
+      return false;
+    }
+  });
+}
+function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
+  const result = new Map;
+  if (messageIds.length === 0)
+    return result;
+  try {
+    withReadOnlySessionDb((db) => {
+      const placeholders = messageIds.map(() => "?").join(",");
+      const rows = db.prepare(`SELECT id, time_created FROM message WHERE session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds);
+      for (const row of rows) {
+        if (typeof row.id === "string" && typeof row.time_created === "number") {
+          result.set(row.id, row.time_created);
+        }
+      }
+    });
+  } catch (error51) {
+    log("[magic-context] failed to resolve message times from OpenCode DB:", error51);
+  }
+  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();
+  init_logger();
+  await init_sqlite();
+});
+
 // src/hooks/magic-context/read-session-raw.ts
 function isRawMessageRow(row) {
   if (row === null || typeof row !== "object")
@@ -160374,15 +160510,55 @@ var init_migrations = __esm(async () => {
           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");
+        }
+      }
     }
   ];
 });
 
 // src/features/magic-context/tool-owner-backfill.ts
-import { existsSync as existsSync10 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join17 } from "node:path";
 function resolveOpencodeDbPath() {
-  return join14(getDataDir(), "opencode", "opencode.db");
+  return join17(getDataDir(), "opencode", "opencode.db");
 }
 function ensureBackfillStateTable(db) {
   db.exec(`
@@ -160417,7 +160593,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync10(opencodeDbPath)) {
+  if (!existsSync12(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");
@@ -160627,25 +160803,25 @@ var init_tool_owner_backfill = __esm(() => {
 });
 
 // src/features/magic-context/storage-db.ts
-import { copyFileSync, cpSync, existsSync as existsSync11, mkdirSync as mkdirSync5 } from "node:fs";
-import { join as join15 } from "node:path";
+import { copyFileSync, cpSync, existsSync as existsSync13, mkdirSync as mkdirSync5 } from "node:fs";
+import { join as join18 } from "node:path";
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join15(dbDir, "context.db") };
+  return { dbDir, dbPath: join18(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync11(targetDbPath))
+  if (existsSync13(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join15(legacyDir, "context.db");
-  if (!existsSync11(legacyDbPath))
+  const legacyDbPath = join18(legacyDir, "context.db");
+  if (!existsSync13(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
   mkdirSync5(targetDbDir, { recursive: true });
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
-    const dst = join15(targetDbDir, `context.db${suffix}`);
-    if (existsSync11(src)) {
+    const dst = join18(targetDbDir, `context.db${suffix}`);
+    if (existsSync13(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error51) {
@@ -160653,9 +160829,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join15(legacyDir, "models");
-  const targetModelsDir = join15(targetDbDir, "models");
-  if (existsSync11(legacyModelsDir) && !existsSync11(targetModelsDir)) {
+  const legacyModelsDir = join18(legacyDir, "models");
+  const targetModelsDir = join18(targetDbDir, "models");
+  if (existsSync13(legacyModelsDir) && !existsSync13(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error51) {
@@ -160803,6 +160979,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(
@@ -160880,7 +161076,11 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       -- 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
+      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);
@@ -160969,6 +161169,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   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'");
@@ -161045,7 +161246,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();
@@ -161062,6 +161271,11 @@ function openDatabase() {
     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) {
@@ -161089,6 +161303,7 @@ var databases, persistenceByDatabase, persistenceErrorByDatabase;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
+  init_project_key_files();
   init_tool_definition_tokens();
   init_tool_owner_backfill();
   await __promiseAll([
@@ -161526,6 +161741,30 @@ function clearPendingCompactionMarkerStateIf(db, sessionId, expected) {
              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;
+}
 function getSessionsWithPendingMarker(db) {
   const rows = db.prepare(`SELECT session_id FROM session_meta
              WHERE pending_compaction_marker_state IS NOT NULL
@@ -162059,12 +162298,12 @@ var init_storage = __esm(async () => {
 });
 
 // src/shared/models-dev-cache.ts
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
-import { homedir as homedir8, platform as platform3 } from "node:os";
-import { join as join16 } from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync14, readFileSync as readFileSync11 } from "node:fs";
+import { homedir as homedir9, platform as platform3 } from "node:os";
+import { join as join19 } from "node:path";
 function hashFast(input) {
-  return createHash4("sha1").update(input).digest("hex");
+  return createHash5("sha1").update(input).digest("hex");
 }
 function getModelsJsonPath() {
   const explicit = process.env.OPENCODE_MODELS_PATH?.trim();
@@ -162073,16 +162312,16 @@ function getModelsJsonPath() {
   const cacheBase = getCacheDir();
   const source = process.env.OPENCODE_MODELS_URL?.trim();
   const filename = source && source !== "https://models.dev" ? `models-${hashFast(source)}.json` : "models.json";
-  return join16(cacheBase, "opencode", filename);
+  return join19(cacheBase, "opencode", filename);
 }
 function getOpencodeConfigPath() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  const configDir = envDir ? envDir : platform3() === "win32" ? join16(homedir8(), ".config", "opencode") : join16(process.env.XDG_CONFIG_HOME || join16(homedir8(), ".config"), "opencode");
-  const jsonc = join16(configDir, "opencode.jsonc");
-  if (existsSync12(jsonc))
+  const configDir = envDir ? envDir : platform3() === "win32" ? join19(homedir9(), ".config", "opencode") : join19(process.env.XDG_CONFIG_HOME || join19(homedir9(), ".config"), "opencode");
+  const jsonc = join19(configDir, "opencode.jsonc");
+  if (existsSync14(jsonc))
     return jsonc;
-  const json2 = join16(configDir, "opencode.json");
-  if (existsSync12(json2))
+  const json2 = join19(configDir, "opencode.json");
+  if (existsSync14(json2))
     return json2;
   return null;
 }
@@ -162114,9 +162353,9 @@ function loadModelsDevMetadataFromFile() {
   const modelsJsonPath = getModelsJsonPath();
   let fileFound = false;
   try {
-    if (existsSync12(modelsJsonPath)) {
+    if (existsSync14(modelsJsonPath)) {
       fileFound = true;
-      const raw = readFileSync8(modelsJsonPath, "utf-8");
+      const raw = readFileSync11(modelsJsonPath, "utf-8");
       const data = JSON.parse(raw);
       for (const [providerId, provider2] of Object.entries(data)) {
         if (!provider2?.models || typeof provider2.models !== "object")
@@ -162131,8 +162370,8 @@ function loadModelsDevMetadataFromFile() {
   }
   try {
     const configPath = getOpencodeConfigPath();
-    if (configPath && existsSync12(configPath)) {
-      const config2 = parseJsonc(readFileSync8(configPath, "utf-8"));
+    if (configPath && existsSync14(configPath)) {
+      const config2 = parseJsonc(readFileSync11(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")
@@ -162239,7 +162478,7 @@ var init_rpc_notifications = __esm(() => {
 });
 
 // src/features/magic-context/compaction-marker.ts
-import { join as join17 } from "node:path";
+import { join as join20 } from "node:path";
 function randomBase62(length) {
   const chars = [];
   for (let i = 0;i < length; i++) {
@@ -162259,7 +162498,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join17(getDataDir(), "opencode", "opencode.db");
+  return join20(getDataDir(), "opencode", "opencode.db");
 }
 function isOpenCodeSchemaCompatible(db, dbPath) {
   if (cachedSchemaCompatible?.path === dbPath) {
@@ -162401,7 +162640,7 @@ var init_compaction_marker = __esm(async () => {
 });
 
 // src/hooks/magic-context/compaction-marker-manager.ts
-import { join as join18 } from "node:path";
+import { join as join21 } from "node:path";
 function validatePendingTarget(db, sessionId, pending) {
   const ocMessage = getOpenCodeMessageById(sessionId, pending.endMessageId);
   if (!ocMessage) {
@@ -162508,7 +162747,7 @@ function removeCompactionMarkerForSession(db, sessionId) {
   }
 }
 function checkCompactionMarkerConsistency(db) {
-  const opencodeDbPath = join18(getDataDir(), "opencode", "opencode.db");
+  const opencodeDbPath = join21(getDataDir(), "opencode", "opencode.db");
   let opencodeDb;
   try {
     opencodeDb = new Database(opencodeDbPath, { readonly: true });
@@ -162792,7 +163031,7 @@ var init_compartment_runner_validation = __esm(async () => {
 
 // src/hooks/magic-context/compartment-runner-historian.ts
 import { mkdirSync as mkdirSync6, unlinkSync, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join22 } from "node:path";
 function historianResponseDumpDir(directory) {
   return getProjectMagicContextHistorianDir(directory);
 }
@@ -162957,7 +163196,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));
       });
     }
@@ -163022,8 +163261,8 @@ function isTransientHistorianPromptError(message) {
   ].some((token) => normalized.includes(token));
 }
 function sleep(ms) {
-  return new Promise((resolve4) => {
-    setTimeout(resolve4, ms);
+  return new Promise((resolve6) => {
+    setTimeout(resolve6, ms);
   });
 }
 function cleanupHistorianDump(sessionId, dumpPath) {
@@ -163044,7 +163283,7 @@ function dumpHistorianResponse(sessionId, directory, label, text) {
     mkdirSync6(dumpDir, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join19(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    const dumpPath = join22(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
     writeFileSync5(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
@@ -164401,14 +164640,14 @@ var init_caveman = __esm(() => {
 
 // src/hooks/magic-context/historian-state-file.ts
 import { mkdirSync as mkdirSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join23 } from "node:path";
 function maybeWriteHistorianStateFile(sessionId, existingState, directory) {
   if (existingState.length <= HISTORIAN_STATE_INLINE_THRESHOLD)
     return;
   try {
     const dir = getProjectMagicContextHistorianDir(directory);
     mkdirSync7(dir, { recursive: true });
-    const path5 = join20(dir, `state-${sessionId}-${Date.now()}.xml`);
+    const path5 = join23(dir, `state-${sessionId}-${Date.now()}.xml`);
     writeFileSync6(path5, existingState, "utf8");
     return path5;
   } catch {
@@ -164911,7 +165150,7 @@ async function runCompressorPass(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));
       });
     }
@@ -165566,8 +165805,8 @@ var exports_tui_config = {};
 __export(exports_tui_config, {
   ensureTuiPluginEntry: () => ensureTuiPluginEntry
 });
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname8, join as join23 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname8, join as join27 } from "node:path";
 function isMagicContextEntry(entry) {
   if (!entry)
     return false;
@@ -165581,11 +165820,11 @@ function isMagicContextEntry(entry) {
 }
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join23(configDir, "tui.jsonc");
-  const jsonPath = join23(configDir, "tui.json");
-  if (existsSync14(jsoncPath))
+  const jsoncPath = join27(configDir, "tui.jsonc");
+  const jsonPath = join27(configDir, "tui.json");
+  if (existsSync16(jsoncPath))
     return jsoncPath;
-  if (existsSync14(jsonPath))
+  if (existsSync16(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -165593,9 +165832,9 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
-    if (existsSync14(configPath)) {
-      const raw = readFileSync11(configPath, "utf-8");
-      config2 = import_comment_json3.parse(raw) ?? {};
+    if (existsSync16(configPath)) {
+      const raw = readFileSync15(configPath, "utf-8");
+      config2 = import_comment_json4.parse(raw) ?? {};
     }
     const plugins = Array.isArray(config2.plugin) ? config2.plugin.filter((p) => typeof p === "string") : [];
     const existingIdx = plugins.findIndex(isMagicContextEntry);
@@ -165614,7 +165853,7 @@ function ensureTuiPluginEntry() {
     }
     config2.plugin = plugins;
     mkdirSync9(dirname8(configPath), { recursive: true });
-    writeFileSync8(configPath, `${import_comment_json3.stringify(config2, null, 2)}
+    writeFileSync8(configPath, `${import_comment_json4.stringify(config2, null, 2)}
 `);
     log(`[magic-context] updated TUI plugin entry in ${configPath}`);
     return true;
@@ -165623,11 +165862,11 @@ function ensureTuiPluginEntry() {
     return false;
   }
 }
-var import_comment_json3, PLUGIN_NAME = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY;
+var import_comment_json4, PLUGIN_NAME = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY;
 var init_tui_config = __esm(() => {
   init_logger();
   init_opencode_config_dir();
-  import_comment_json3 = __toESM(require_src2(), 1);
+  import_comment_json4 = __toESM(require_src2(), 1);
   PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 });
 // src/config/index.ts
@@ -166377,8 +166616,7 @@ async function runSidekick(deps) {
   } finally {
     if (agentSessionId) {
       await deps.client.session.delete({
-        path: { id: agentSessionId },
-        query: { directory: deps.sessionDirectory ?? deps.projectPath }
+        path: { id: agentSessionId }
       }).catch((error51) => {
         log("[magic-context] failed to delete sidekick child session:", error51);
       });
@@ -166735,8 +166973,17 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
     if (nodeModulesDir && basename(nodeModulesDir) === "node_modules") {
       const installDir = dirname4(nodeModulesDir);
       const packageJsonPath = join5(installDir, "package.json");
-      if (existsSync5(packageJsonPath))
-        return { installDir, packageJsonPath };
+      if (!existsSync5(packageJsonPath)) {
+        try {
+          writeFileSync2(packageJsonPath, `${JSON.stringify({ private: true, dependencies: {} }, null, 2)}
+`);
+          log(`[auto-update-checker] Seeded missing package.json at ${packageJsonPath} (issue #73)`);
+        } catch (err) {
+          warn2(`[auto-update-checker] Could not seed package.json at ${packageJsonPath}: ${String(err)}`);
+          return null;
+        }
+      }
+      return { installDir, packageJsonPath };
     }
     return null;
   }
@@ -167038,6 +167285,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)) {
@@ -167151,192 +167408,530 @@ init_assistant_message_extractor();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync11 } from "node:fs";
+import { join as join14 } from "node:path";
 
 // src/features/magic-context/key-files/identify-key-files.ts
+init_read_session_formatting();
+init_shared();
+init_assistant_message_extractor();
 init_logger();
+import { readFileSync as readFileSync10 } from "node:fs";
+import { join as join13 } from "node:path";
 
-// 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)
-  }));
+// src/features/magic-context/key-files/aft-availability.ts
+var import_comment_json3 = __toESM(require_src2(), 1);
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join11 } from "node:path";
+var overrideAvailability = null;
+function parseConfig(path4) {
+  if (!existsSync9(path4))
+    return null;
+  return import_comment_json3.parse(readFileSync8(path4, "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 || homedir8();
+  const opencodePaths = [
+    join11(home, ".config", "opencode", "opencode.jsonc"),
+    join11(home, ".config", "opencode", "opencode.json")
+  ];
+  const piPaths = [join11(home, ".pi", "agent", "settings.json")];
+  const checkedPaths = [...opencodePaths, ...piPaths];
+  let opencode = false;
+  for (const path4 of opencodePaths) {
+    try {
+      const config2 = parseConfig(path4);
+      if (hasAftAtKeys(config2, ["plugin", "plugins", "mcp", "mcp_servers"])) {
+        opencode = true;
+        break;
+      }
+    } catch {}
+  }
+  let pi = false;
+  for (const path4 of piPaths) {
+    try {
+      const config2 = parseConfig(path4);
+      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;
 }
 
-// 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 {
+// src/features/magic-context/key-files/identify-key-files.ts
+init_project_key_files();
+
+// src/features/magic-context/key-files/read-history.ts
+import { realpathSync as realpathSync2 } from "node:fs";
+import { relative, resolve as resolve5 } 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("/") ? resolve5(filePath) : resolve5(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);
 }
 
+// src/features/magic-context/key-files/storage-key-files.ts
+init_logger();
+
 // 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(`
 `);
-  return `## Identify Key Files for Pinning
+}
+function buildV6KeyFilesPrompt(args) {
+  const current = args.currentRows.map((row) => `- ${row.path}: ${row.localTokenEstimate} tokens, stale=${row.staleReason ?? "fresh"}`).join(`
+`);
+  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 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 {
+    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 parseKeyFilesOutput(text) {
-  const jsonMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/) ?? text.match(/\[[\s\S]*\]/);
-  if (!jsonMatch)
-    return [];
+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(readFileSync10(join13(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 {
-    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 [];
+    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);
   }
 }
-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 };
-}
 
 // src/features/magic-context/dreamer/runner.ts
 init_storage_memory();
@@ -167568,12 +168163,12 @@ function shouldSkipCircuitBreaker(error51, brief) {
 function logWithStackHead(message, stackHead) {
   log(message, stackHead ? { stackHead } : undefined);
 }
-function getOpenCodeDbPath2() {
-  return join12(getDataDir(), "opencode", "opencode.db");
+function getOpenCodeDbPath() {
+  return join14(getDataDir(), "opencode", "opencode.db");
 }
 function openOpenCodeDb() {
-  const dbPath = getOpenCodeDbPath2();
-  if (!existsSync9(dbPath)) {
+  const dbPath = getOpenCodeDbPath();
+  if (!existsSync11(dbPath)) {
     log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
     return null;
   }
@@ -167586,190 +168181,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`);
-          args.onLeaseLost?.(`key-files:${args.sessionId}`);
-          abortController.abort();
-        }
-      } catch (error51) {
-        args.onLeaseLost?.(`key-files:${args.sessionId}`, error51);
-        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) {
-      if (args.isLeaseLost?.() || abortController.signal.aborted) {
-        log(`[key-files][${args.sessionId}] lease lost during identification — skipping heuristic fallback`);
-        throw error51;
-      }
-      log(`[key-files][${args.sessionId}] identification failed: ${getErrorMessage(error51)} — using heuristic fallback`);
-      try {
-        applyHeuristicFallback();
-      } 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 (args.isLeaseLost?.()) {
-      log("[key-files] lease lost — stopping key-file identification");
-      break;
-    }
-    if (Date.now() > args.deadline) {
-      log("[key-files] deadline reached — stopping key-file identification");
-      break;
-    }
-    await identifyKeyFilesForSession({
-      db: args.db,
-      client: args.client,
-      parentSessionId: args.parentSessionId,
-      sessionDirectory: args.sessionDirectory,
-      holderId: args.holderId,
-      fallbackModels: args.fallbackModels,
-      onLeaseLost: args.onLeaseLost,
-      isLeaseLost: args.isLeaseLost,
-      deadline: args.deadline,
-      sessionId,
-      config: args.config
-    });
-  }
-}
 async function runDream(args) {
   const holderId = crypto.randomUUID();
   const startedAt = Date.now();
@@ -167888,8 +168299,8 @@ async function runDream(args) {
       try {
         const docsDir = args.sessionDirectory ?? args.projectIdentity;
         const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync9(join12(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync9(join12(docsDir, "STRUCTURE.md"))
+          architecture: existsSync11(join14(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync11(join14(docsDir, "STRUCTURE.md"))
         } : undefined;
         const userMemories = taskName === "archive-stale" ? getActiveUserMemories(args.db).map((um) => ({
           id: um.id,
@@ -167990,8 +168401,7 @@ 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);
           });
@@ -168092,19 +168502,24 @@ async function runDream(args) {
         if (!verifyLeaseStillHeld("before key-file identification")) {
           throw new Error(lostLeaseReason ?? "Dream lease lost before key-file identification");
         }
-        await identifyKeyFiles({
-          db: args.db,
-          client: args.client,
-          projectIdentity: args.projectIdentity,
-          parentSessionId,
-          sessionDirectory: args.sessionDirectory ?? args.projectIdentity,
-          holderId,
-          deadline,
-          config: args.experimentalPinKeyFiles,
-          fallbackModels: args.fallbackModels,
-          onLeaseLost: markLeaseLost,
-          isLeaseLost: () => lostLease
-        });
+        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");
         }
@@ -168322,8 +168737,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(() => {});
     }
   }
@@ -170463,9 +170877,34 @@ await init_read_session_chunk();
 // src/hooks/magic-context/transform.ts
 init_compartment_storage();
 init_project_identity();
+import * as crypto2 from "node:crypto";
 init_logger();
 await init_storage();
 
+// src/hooks/magic-context/boundary-execution.ts
+var FORCE_MATERIALIZE_PERCENTAGE2 = 85;
+function detectMidTurnBypassReason(input) {
+  if (input.contextUsage.percentage >= FORCE_MATERIALIZE_PERCENTAGE2)
+    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" };
+}
+
 // src/hooks/magic-context/cache-busting-signals.ts
 function canConsumeDeferredOnThisPass(args) {
   if (args.justAwaitedPublication)
@@ -170746,7 +171185,8 @@ init_read_session_formatting();
 init_send_session_notification();
 await __promiseAll([
   init_inject_compartments(),
-  init_read_session_chunk()
+  init_read_session_chunk(),
+  init_read_session_db()
 ]);
 // src/hooks/magic-context/sentinel.ts
 var WHOLE_MESSAGE_PLACEHOLDER_TEXT = "[dropped]";
@@ -171251,7 +171691,7 @@ async function runCompartmentPhase(args) {
   async function awaitCompartmentRun(activeRun, reason) {
     sessionLog(args.sessionId, reason);
     const timeoutMs = args.historianTimeoutMs ?? 120000;
-    const timeout = new Promise((resolve4) => setTimeout(() => resolve4("timeout"), timeoutMs));
+    const timeout = new Promise((resolve6) => setTimeout(() => resolve6("timeout"), timeoutMs));
     const result = await Promise.race([activeRun.promise.then(() => "done"), timeout]);
     if (result === "timeout") {
       sessionLog(args.sessionId, `transform: compartment await timed out after ${timeoutMs}ms — proceeding without waiting`);
@@ -171383,20 +171823,38 @@ async function runCompartmentPhase(args) {
 // src/hooks/magic-context/transform-context-state.ts
 init_logger();
 await init_storage();
+function loadPersistedUsageWatermark(db, sessionId) {
+  const result = db.prepare("SELECT last_response_time FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (result === null || typeof result !== "object")
+    return null;
+  const lastResponseTime = result.last_response_time;
+  return typeof lastResponseTime === "number" ? lastResponseTime : null;
+}
 function loadContextUsage(contextUsageMap, db, sessionId) {
-  let contextUsageEntry = contextUsageMap.get(sessionId);
-  if (!contextUsageEntry) {
-    try {
-      const persisted = loadPersistedUsage(db, sessionId);
-      if (persisted) {
-        contextUsageMap.set(sessionId, persisted);
-        contextUsageEntry = persisted;
-      }
-    } catch (error51) {
-      sessionLog(sessionId, "transform failed loading persisted usage:", error51);
+  const contextUsageEntry = contextUsageMap.get(sessionId);
+  try {
+    const persistedLastResponseTime = loadPersistedUsageWatermark(db, sessionId);
+    const cachedLastResponseTime = contextUsageEntry?.lastResponseTime ?? contextUsageEntry?.updatedAt;
+    if (contextUsageEntry && contextUsageEntry.lastResponseTime === undefined && (persistedLastResponseTime === null || persistedLastResponseTime === 0)) {
+      return contextUsageEntry.usage;
+    }
+    if (contextUsageEntry && cachedLastResponseTime === persistedLastResponseTime) {
+      return contextUsageEntry.usage;
+    }
+    const persisted = loadPersistedUsage(db, sessionId);
+    if (persisted) {
+      contextUsageMap.set(sessionId, {
+        ...persisted,
+        lastResponseTime: persistedLastResponseTime ?? persisted.updatedAt
+      });
+      return persisted.usage;
     }
+    contextUsageMap.delete(sessionId);
+  } catch (error51) {
+    sessionLog(sessionId, "transform failed loading persisted usage:", error51);
+    return contextUsageEntry?.usage ?? { percentage: 0, inputTokens: 0 };
   }
-  return contextUsageEntry?.usage ?? { percentage: 0, inputTokens: 0 };
+  return { percentage: 0, inputTokens: 0 };
 }
 function resolveSchedulerDecision(scheduler2, sessionMeta, contextUsage, sessionId, modelKey) {
   try {
@@ -172590,10 +173048,10 @@ var AUTO_SEARCH_TIMEOUT_MS = 3000;
 async function unifiedSearchWithTimeout(db, sessionId, projectPath, prompt, options, timeoutMs) {
   const controller = new AbortController;
   let timer;
-  const timeoutPromise = new Promise((resolve4) => {
+  const timeoutPromise = new Promise((resolve6) => {
     timer = setTimeout(() => {
       controller.abort();
-      resolve4(null);
+      resolve6(null);
     }, timeoutMs);
   });
   try {
@@ -173016,7 +173474,7 @@ function isVisibleNoteReadPart(part) {
 }
 
 // src/hooks/magic-context/todo-view.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } 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_";
@@ -173030,7 +173488,7 @@ function normalizeTodoStateJson(todos) {
     normalized.push({
       content: todo.content,
       status: todo.status,
-      priority: todo.priority
+      priority: todo.priority ?? "medium"
     });
   }
   return JSON.stringify(normalized);
@@ -173061,7 +173519,7 @@ function buildSyntheticTodoPart(stateJson) {
   };
 }
 function computeSyntheticCallId(stateJson) {
-  const hash2 = createHash5("sha256").update(stateJson).digest("hex").slice(0, 16);
+  const hash2 = createHash6("sha256").update(stateJson).digest("hex").slice(0, 16);
   return `${SYNTHETIC_CALL_ID_PREFIX}${hash2}`;
 }
 function parseTodoState(stateJson) {
@@ -173078,7 +173536,7 @@ function parseTodoState(stateJson) {
       result.push({
         content: item.content,
         status: item.status,
-        priority: item.priority
+        priority: item.priority ?? "medium"
       });
     }
     return result;
@@ -173090,7 +173548,7 @@ function isTodoItem(value) {
   if (value === null || typeof value !== "object")
     return false;
   const todo = value;
-  return typeof todo.content === "string" && typeof todo.status === "string" && typeof todo.priority === "string";
+  return typeof todo.content === "string" && typeof todo.status === "string" && (todo.priority === undefined || typeof todo.priority === "string");
 }
 
 // src/hooks/magic-context/transform-stage-logger.ts
@@ -173141,6 +173599,8 @@ async function runPostTransformPhase(args) {
   }
   let explicitMaterializedSuccessfully = false;
   let deferredMaterializedSuccessfully = false;
+  let heuristicsRanSuccessfully = false;
+  let pendingOpsRanSuccessfully = false;
   try {
     if (shouldApplyPendingOps) {
       const applyReason = isExplicitFlush ? "explicit_flush" : deferredMaterialize ? "deferred_materialization" : `scheduler_execute (scheduler=${args.schedulerDecision})`;
@@ -173218,6 +173678,10 @@ async function runPostTransformPhase(args) {
         explicitMaterializedSuccessfully = true;
       if (deferredMaterialize)
         deferredMaterializedSuccessfully = true;
+      heuristicsRanSuccessfully = true;
+    }
+    if (shouldApplyPendingOps) {
+      pendingOpsRanSuccessfully = true;
     }
   } catch (error51) {
     sessionLog(args.sessionId, "transform failed applying pending operations:", error51);
@@ -173416,6 +173880,18 @@ async function runPostTransformPhase(args) {
   if (explicitMaterializedSuccessfully || deferredMaterializedSuccessfully) {
     args.deferredMaterializationSessions.delete(args.sessionId);
   }
+  const workExecutedSuccessfully = explicitMaterializedSuccessfully || deferredMaterializedSuccessfully || heuristicsRanSuccessfully || pendingOpsRanSuccessfully;
+  if (workExecutedSuccessfully) {
+    try {
+      const currentFlag = peekDeferredExecutePending(args.db, args.sessionId);
+      if (currentFlag !== null) {
+        const cleared = clearDeferredExecutePendingIfMatches(args.db, args.sessionId, currentFlag);
+        sessionLog(args.sessionId, `[boundary-exec] deferred-execute drain: ${cleared ? "cleared" : "stale-noop"} reason=${currentFlag.reason}`);
+      }
+    } catch (err) {
+      sessionLog(args.sessionId, `[boundary-exec] drain failed (continuing): ${err}`);
+    }
+  }
   if (args.fullFeatureMode && args.autoSearch?.enabled && args.projectPath) {
     const visibleMemoryIds = getVisibleMemoryIds(args.db, args.sessionId) ?? undefined;
     try {
@@ -173622,10 +174098,31 @@ function createTransform(deps) {
     }
     const historyBudgetTokens = resolveHistoryBudgetTokens(deps.historyBudgetPercentage, contextUsageEarly, deps.executeThresholdPercentage, deps.getModelKey?.(sessionId), deps.executeThresholdTokens);
     const schedulerDecisionEarly = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId));
+    const midTurn = isMidTurn(deps, resolvedSessionId);
+    const bypassReason = detectMidTurnBypassReason({
+      contextUsage: contextUsageEarly,
+      sessionMeta,
+      historyRefreshSessions: deps.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(db, sessionId, flagPayload);
+    }
+    sessionLog(sessionId, `[boundary-exec] base=${schedulerDecisionEarly} bypass=${bypassReason} midTurn=${midTurn} effective=${midTurnAdjustedSchedulerDecision} sideEffect=${sideEffect}`);
     const historyRefreshExplicitBeforePrepare = deps.historyRefreshSessions.has(sessionId);
     const earlyActiveRunBlocksMaterialization = (getActiveCompartmentRun(sessionId) !== undefined || sessionMeta.compartmentInProgress) && contextUsageEarly.percentage < FORCE_MATERIALIZE_PERCENTAGE;
     const canConsumeDeferredEarly = canConsumeDeferredOnThisPass({
-      schedulerDecision: schedulerDecisionEarly,
+      schedulerDecision: midTurnAdjustedSchedulerDecision,
       contextPercentage: contextUsageEarly.percentage,
       justAwaitedPublication: false,
       activeRunBlocksMaterialization: earlyActiveRunBlocksMaterialization
@@ -173820,7 +174317,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
     logTransformTiming(sessionId, "stripReasoningFromMergedAssistants", tMergeStrip, `strippedParts=${strippedMergedReasoning}`);
     const watermark = getMaxDroppedTagNumber(db, sessionId);
     const contextUsage = contextUsageEarly;
-    const schedulerDecision = schedulerDecisionEarly;
+    const schedulerDecision = midTurnAdjustedSchedulerDecision;
     const rawGetNotifParams = deps.getNotificationParams;
     const tCompartmentPhase = performance.now();
     const compartmentPhase = await runCompartmentPhase({
@@ -173843,7 +174340,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       projectPath: projectIdentity,
       injectionBudgetTokens: deps.memoryConfig?.injectionBudgetTokens,
       getNotificationParams: rawGetNotifParams ? () => rawGetNotifParams(sessionId) : undefined,
-      safeForBackgroundCompression: isCacheBusting || schedulerDecisionEarly === "execute",
+      safeForBackgroundCompression: isCacheBusting || midTurnAdjustedSchedulerDecision === "execute",
       suppressBackgroundCompressionThisPass: historyBustThisPass,
       deferredHistoryRefreshSessions,
       skipAwaitForThisPass: skipCompartmentAwaitForThisPass,
@@ -173868,7 +174365,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
     logTransformTiming(sessionId, "compartmentPhase", tCompartmentPhase);
     const lateActiveRunBlocksMaterialization = getActiveCompartmentRun(sessionId) !== undefined && contextUsageEarly.percentage < FORCE_MATERIALIZE_PERCENTAGE;
     const canConsumeDeferredLate = canConsumeDeferredOnThisPass({
-      schedulerDecision: schedulerDecisionEarly,
+      schedulerDecision: midTurnAdjustedSchedulerDecision,
       contextPercentage: contextUsageEarly.percentage,
       justAwaitedPublication: compartmentPhase.justAwaitedPublication,
       activeRunBlocksMaterialization: lateActiveRunBlocksMaterialization
@@ -174237,7 +174734,8 @@ function createEventHandler2(deps) {
               percentage,
               inputTokens: totalInputTokens
             },
-            updatedAt: now
+            updatedAt: now,
+            lastResponseTime: now
           });
           updates.lastContextPercentage = percentage;
           updates.lastInputTokens = totalInputTokens;
@@ -174741,9 +175239,9 @@ function createToolExecuteAfterHook(args) {
 init_send_session_notification();
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync13, readFileSync as readFileSync9, realpathSync } from "node:fs";
-import { join as join21, resolve as resolve4, sep } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
+import { join as join25 } from "node:path";
 
 // src/agents/magic-context-prompt.ts
 function getToolHistoryGuidance(dropToolStructure) {
@@ -174833,19 +175331,146 @@ Prefer many small targeted operations over one large blanket operation. Compress
 }
 
 // src/hooks/magic-context/system-prompt-hash.ts
+init_logger();
+await init_storage();
+
+// src/hooks/magic-context/key-files-block.ts
 init_compartment_storage();
+import { readFileSync as readFileSync12, realpathSync as realpathSync3 } from "node:fs";
+import { join as join24, sep as sep2 } from "node:path";
+init_project_key_files();
 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 = join24(projectPath, row.path);
+      const real = realpathSync3(absPath);
+      if (!isUnderProject(projectPath, real)) {
+        nextStale = "missing";
+        observed = true;
+      } else {
+        const diskHash = sha256(readFileSync12(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/hooks/magic-context/system-prompt-hash.ts
 init_read_session_formatting();
-await init_storage();
 var MAGIC_CONTEXT_MARKER = "## Magic Context";
 var PROJECT_DOCS_MARKER = "<project-docs>";
 var USER_PROFILE_MARKER = "<user-profile>";
 var KEY_FILES_MARKER = "<key-files>";
 var cachedUserProfileBySession = new Map;
-var cachedKeyFilesBySession = new Map;
 function clearSystemPromptHashSession(sessionId, handleMaps) {
   cachedUserProfileBySession.delete(sessionId);
-  cachedKeyFilesBySession.delete(sessionId);
+  clearKeyFilesCacheForSession(sessionId);
   handleMaps.stickyDateBySession.delete(sessionId);
   handleMaps.cachedDocsBySession.delete(sessionId);
 }
@@ -174856,10 +175481,10 @@ var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join21(directory, filename);
+    const filePath = join25(directory, filename);
     try {
-      if (existsSync13(filePath)) {
-        const content = readFileSync9(filePath, "utf-8").trim();
+      if (existsSync15(filePath)) {
+        const content = readFileSync13(filePath, "utf-8").trim();
         if (content.length > 0) {
           sections.push(`<${filename}>
 ${content}
@@ -174956,71 +175581,20 @@ ${items}
         output.system.push(profileBlock);
       }
     }
-    if (deps.experimentalPinKeyFiles && !isSubagentSession) {
-      const hasCachedKeyFiles = cachedKeyFilesBySession.has(sessionId);
-      if (!hasCachedKeyFiles || isCacheBusting) {
-        const keyFileEntries = getKeyFiles(deps.db, sessionId);
-        if (keyFileEntries.length > 0) {
-          const sections = [];
-          const projectRoot = resolve4(deps.directory);
-          let remainingBudgetTokens = deps.experimentalPinKeyFilesTokenBudget ?? 1e4;
-          for (const entry of keyFileEntries) {
-            try {
-              const absPath = resolve4(deps.directory, entry.filePath);
-              if (!absPath.startsWith(projectRoot + sep) && absPath !== projectRoot) {
-                log(`[magic-context] key file path escapes project root, skipping: ${entry.filePath}`);
-                continue;
-              }
-              if (!existsSync13(absPath))
-                continue;
-              let realPath;
-              try {
-                realPath = realpathSync(absPath);
-              } catch {
-                continue;
-              }
-              if (!realPath.startsWith(projectRoot + sep) && realPath !== projectRoot) {
-                log(`[magic-context] key file symlink escapes project root, skipping: ${entry.filePath} → ${realPath}`);
-                continue;
-              }
-              const content = readFileSync9(realPath, "utf-8").trim();
-              if (content.length === 0)
-                continue;
-              const fileTokens = estimateTokens(content);
-              if (fileTokens > remainingBudgetTokens) {
-                log(`[magic-context] 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] failed to read key file ${entry.filePath}:`, error51);
-            }
-          }
-          if (sections.length > 0) {
-            cachedKeyFilesBySession.set(sessionId, `${KEY_FILES_MARKER}
-${sections.join(`
-
-`)}
-</key-files>`);
-            if (!hasCachedKeyFiles) {
-              sessionLog(sessionId, `loaded ${sections.length} key file(s) into system prompt`);
-            } else {
-              sessionLog(sessionId, "refreshed key files (cache-busting pass)");
-            }
-          } else {
-            cachedKeyFilesBySession.set(sessionId, null);
-          }
-        } else {
-          cachedKeyFilesBySession.set(sessionId, null);
+    if (deps.experimentalPinKeyFiles && sessionMetaEarly) {
+      const keyFilesBlock = readVersionedKeyFiles({
+        db: deps.db,
+        sessionId,
+        sessionMeta: sessionMetaEarly,
+        directory: deps.directory,
+        isCacheBusting,
+        config: {
+          enabled: deps.experimentalPinKeyFiles,
+          tokenBudget: deps.experimentalPinKeyFilesTokenBudget ?? 1e4
         }
-      }
-      const keyFilesBlock = cachedKeyFilesBySession.get(sessionId);
-      if (keyFilesBlock && !fullPrompt.includes(KEY_FILES_MARKER)) {
+      });
+      if (keyFilesBlock && !fullPrompt.includes(KEY_FILES_MARKER))
         output.system.push(keyFilesBlock);
-      }
     }
     const DATE_PATTERN = /Today's date: .+/;
     for (let i = 0;i < output.system.length; i++) {
@@ -175046,7 +175620,7 @@ ${sections.join(`
 `);
     if (systemContent.length === 0)
       return;
-    const currentHash = createHash6("md5").update(systemContent).digest("hex");
+    const currentHash = createHash7("md5").update(systemContent).digest("hex");
     if (!sessionMetaEarly) {
       return;
     }
@@ -177021,7 +177595,7 @@ function createToolRegistry(args) {
       console.warn(`[magic-context] embedding model changed from ${storedModelId} to ${currentModelId}; cleared embeddings for project ${launchProjectPath}`);
     }
   }
-  const resolveProjectPath = (directory) => resolveProjectIdentity(directory);
+  const resolveProjectPath2 = (directory) => resolveProjectIdentity(directory);
   const ctxReduceEnabled = pluginConfig.ctx_reduce_enabled !== false;
   const allTools = {
     ...ctxReduceEnabled ? createCtxReduceTools({
@@ -177032,11 +177606,11 @@ function createToolRegistry(args) {
     ...createCtxNoteTools({
       db,
       dreamerEnabled: pluginConfig.dreamer?.enabled === true,
-      resolveProjectPath
+      resolveProjectPath: resolveProjectPath2
     }),
     ...createCtxSearchTools({
       db,
-      resolveProjectPath,
+      resolveProjectPath: resolveProjectPath2,
       memoryEnabled,
       embeddingEnabled: embeddingConfig2.provider !== "off",
       gitCommitsEnabled: pluginConfig.experimental?.git_commit_indexing?.enabled === true
@@ -177044,7 +177618,7 @@ function createToolRegistry(args) {
     ...memoryEnabled ? {
       ...createCtxMemoryTools({
         db,
-        resolveProjectPath,
+        resolveProjectPath: resolveProjectPath2,
         memoryEnabled: true,
         embeddingEnabled: embeddingConfig2.provider !== "off",
         allowedActions: ["write", "delete"]
@@ -177069,7 +177643,7 @@ init_logger();
 import {
   mkdirSync as mkdirSync8,
   readdirSync,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync14,
   renameSync as renameSync2,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync7
@@ -177078,17 +177652,17 @@ import { createServer } from "node:http";
 import { dirname as dirname7 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { createHash as createHash7 } from "node:crypto";
-import { join as join22 } from "node:path";
+import { createHash as createHash8 } from "node:crypto";
+import { join as join26 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
-  return createHash7("sha256").update(normalized).digest("hex").slice(0, 16);
+  return createHash8("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortDir(storageDir, directory) {
-  return join22(storageDir, "rpc", projectHash(directory));
+  return join26(storageDir, "rpc", projectHash(directory));
 }
 function rpcPortFilePath(storageDir, directory, pid = process.pid) {
-  return join22(rpcPortDir(storageDir, directory), `port-${pid}.json`);
+  return join26(rpcPortDir(storageDir, directory), `port-${pid}.json`);
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
@@ -177146,7 +177720,7 @@ class MagicContextRpcServer {
     this.handlers.set(method, handler);
   }
   async start() {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const server = createServer((req, res) => this.dispatch(req, res));
       server.on("error", (err) => {
         log(`[rpc] server error: ${err.message}`);
@@ -177175,7 +177749,7 @@ class MagicContextRpcServer {
         } catch (err) {
           log(`[rpc] failed to write port file: ${err}`);
         }
-        resolve5(this.port);
+        resolve6(this.port);
       });
       server.unref();
     });
@@ -177185,7 +177759,7 @@ class MagicContextRpcServer {
       for (const entry of readdirSync(this.portDir)) {
         if (!entry.startsWith("port-") || !entry.endsWith(".json"))
           continue;
-        const record2 = parseRpcPortFile(readFileSync10(`${this.portDir}/${entry}`, "utf-8"));
+        const record2 = parseRpcPortFile(readFileSync14(`${this.portDir}/${entry}`, "utf-8"));
         if (!record2 || record2.pid === process.pid || !isPidAlive(record2.pid))
           continue;
         log(`[rpc] another Magic Context RPC server is active for this project (pid ${record2.pid}, port ${record2.port}); starting separate instance on a new port`);