@cortexkit/pi-magic-context 0.19.0 → 0.20.0

package/dist/index.js

@@ -16202,14 +16202,6 @@ function closeQuietly(db) {
 }
 
 // ../plugin/src/hooks/magic-context/read-session-db.ts
-var exports_read_session_db = {};
-__export(exports_read_session_db, {
-  withReadOnlySessionDb: () => withReadOnlySessionDb,
-  getRawSessionMessageCountFromDb: () => getRawSessionMessageCountFromDb,
-  getMessageTimesFromOpenCodeDb: () => getMessageTimesFromOpenCodeDb,
-  findLastAssistantModelFromOpenCodeDb: () => findLastAssistantModelFromOpenCodeDb,
-  closeReadOnlySessionDb: () => closeReadOnlySessionDb
-});
 import { join as join4 } from "node:path";
 function getOpenCodeDbPath() {
   return join4(getDataDir(), "opencode", "opencode.db");
@@ -16239,9 +16231,6 @@ function getReadOnlySessionDb() {
 function withReadOnlySessionDb(fn) {
   return fn(getReadOnlySessionDb());
 }
-function closeReadOnlySessionDb() {
-  closeCachedReadOnlyDb();
-}
 function getRawSessionMessageCountFromDb(db, sessionId) {
   const row = db.prepare(`SELECT COUNT(*) as count FROM message WHERE session_id = ?
              AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
@@ -16267,34 +16256,6 @@ function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
   }
   return result;
 }
-function findLastAssistantModelFromOpenCodeDb(sessionId) {
-  try {
-    return withReadOnlySessionDb((db) => {
-      const row = db.prepare(`SELECT json_extract(data, '$.providerID') as providerID,
-                            json_extract(data, '$.modelID') as modelID,
-                            json_extract(data, '$.agent') as agent
-                     FROM message
-                     WHERE session_id = ?
-                       AND json_extract(data, '$.role') = 'assistant'
-                       AND json_extract(data, '$.providerID') IS NOT NULL
-                       AND json_extract(data, '$.modelID') IS NOT NULL
-                     ORDER BY time_created DESC
-                     LIMIT 1`).get(sessionId);
-      if (!row || typeof row.providerID !== "string" || typeof row.modelID !== "string") {
-        return null;
-      }
-      const agent = typeof row.agent === "string" && row.agent.length > 0 ? row.agent : undefined;
-      return {
-        providerID: row.providerID,
-        modelID: row.modelID,
-        ...agent ? { agent } : {}
-      };
-    });
-  } catch (error51) {
-    log("[magic-context] failed to recover live model from OpenCode DB:", error51);
-    return null;
-  }
-}
 var cachedReadOnlyDb = null;
 var init_read_session_db = __esm(async () => {
   init_data_path();
@@ -16302,34 +16263,6 @@ var init_read_session_db = __esm(async () => {
   await init_sqlite();
 });
 
-// ../plugin/src/shared/rpc-notifications.ts
-var exports_rpc_notifications = {};
-__export(exports_rpc_notifications, {
-  pushNotification: () => pushNotification,
-  isTuiConnected: () => isTuiConnected,
-  drainNotifications: () => drainNotifications
-});
-function pushNotification(type, payload, sessionId) {
-  queue2.push({ id: nextNotificationId++, type, payload, sessionId });
-  if (queue2.length > 100) {
-    queue2 = queue2.slice(-50);
-  }
-}
-function drainNotifications(lastReceivedId = 0) {
-  lastDrainAt = Date.now();
-  if (lastReceivedId > 0) {
-    queue2 = queue2.filter((notification) => notification.id > lastReceivedId);
-  }
-  return [...queue2];
-}
-function isTuiConnected() {
-  return lastDrainAt > 0 && Date.now() - lastDrainAt < TUI_CONNECTED_WINDOW_MS;
-}
-var queue2, nextNotificationId = 1, lastDrainAt = 0, TUI_CONNECTED_WINDOW_MS = 3000;
-var init_rpc_notifications = __esm(() => {
-  queue2 = [];
-});
-
 // ../../node_modules/.bun/esprima@4.0.1/node_modules/esprima/dist/esprima.js
 var require_esprima = __commonJS((exports, module) => {
   (function webpackUniversalModuleDefinition(root, factory) {
@@ -23937,10 +23870,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join12 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join9 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join12(comment, inside, gap);
+    return join9(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -23962,13 +23895,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join12(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join9(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join12(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -23989,13 +23922,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join12(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join9(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join12(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -24087,10 +24020,38 @@ var require_src2 = __commonJS((exports, module) => {
   };
 });
 
+// ../plugin/src/shared/rpc-notifications.ts
+var exports_rpc_notifications = {};
+__export(exports_rpc_notifications, {
+  pushNotification: () => pushNotification,
+  isTuiConnected: () => isTuiConnected,
+  drainNotifications: () => drainNotifications
+});
+function pushNotification(type, payload, sessionId) {
+  queue2.push({ id: nextNotificationId++, type, payload, sessionId });
+  if (queue2.length > 100) {
+    queue2 = queue2.slice(-50);
+  }
+}
+function drainNotifications(lastReceivedId = 0) {
+  lastDrainAt = Date.now();
+  if (lastReceivedId > 0) {
+    queue2 = queue2.filter((notification) => notification.id > lastReceivedId);
+  }
+  return [...queue2];
+}
+function isTuiConnected() {
+  return lastDrainAt > 0 && Date.now() - lastDrainAt < TUI_CONNECTED_WINDOW_MS;
+}
+var queue2, nextNotificationId = 1, lastDrainAt = 0, TUI_CONNECTED_WINDOW_MS = 3000;
+var init_rpc_notifications = __esm(() => {
+  queue2 = [];
+});
+
 // src/index.ts
 init_embedding();
 import { createRequire as createRequire2 } from "node:module";
-import { join as join14 } from "node:path";
+import { join as join18 } from "node:path";
 
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execSync } from "node:child_process";
@@ -157818,8 +157779,8 @@ function escapeXmlContent(s) {
 }
 // ../plugin/src/features/magic-context/storage-db.ts
 init_data_path();
-import { copyFileSync, cpSync, existsSync as existsSync3, mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join6 } from "node:path";
+import { copyFileSync, cpSync, existsSync as existsSync4, mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join7 } from "node:path";
 
 // ../plugin/src/shared/error-message.ts
 function getErrorMessage(error51) {
@@ -157901,6 +157862,119 @@ function safeString(value) {
 init_logger();
 await init_sqlite();
 
+// ../plugin/src/features/magic-context/key-files/project-key-files.ts
+init_logger();
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync2, readFileSync, realpathSync } from "node:fs";
+import { join as join5, resolve, sep } from "node:path";
+var MISSING_CONTENT_HASH = "<missing>";
+var ORPHAN_GRACE_MS = 7 * 24 * 60 * 60 * 1000;
+function sha256(input) {
+  return createHash3("sha256").update(input).digest("hex");
+}
+function resolveProjectPath(directory) {
+  if (!directory?.trim())
+    return null;
+  try {
+    return realpathSync(directory);
+  } catch {
+    return resolve(directory);
+  }
+}
+function rowToProjectKeyFile(row) {
+  return {
+    projectPath: String(row.project_path),
+    path: String(row.path),
+    content: String(row.content),
+    contentHash: String(row.content_hash),
+    localTokenEstimate: Number(row.local_token_estimate),
+    generatedAt: Number(row.generated_at),
+    generatedByModel: row.generated_by_model == null ? null : String(row.generated_by_model),
+    generationConfigHash: String(row.generation_config_hash),
+    staleReason: row.stale_reason == null ? null : String(row.stale_reason)
+  };
+}
+function readCurrentKeyFiles(db, projectPath) {
+  const resolvedProjectPath = resolveProjectPath(projectPath) ?? projectPath;
+  const rows = db.prepare(`SELECT project_path, path, content, content_hash, local_token_estimate,
+                    generated_at, generated_by_model, generation_config_hash, stale_reason
+               FROM project_key_files
+              WHERE project_path = ?
+              ORDER BY generated_at DESC, path ASC`).all(resolvedProjectPath);
+  return rows.map(rowToProjectKeyFile);
+}
+function getKeyFilesVersion(db, projectPath) {
+  const resolvedProjectPath = resolveProjectPath(projectPath) ?? projectPath;
+  const row = db.prepare("SELECT version FROM project_key_files_version WHERE project_path = ?").get(resolvedProjectPath);
+  return Number(row?.version ?? 0);
+}
+function bumpKeyFilesVersion(db, projectPath) {
+  const resolvedProjectPath = resolveProjectPath(projectPath) ?? projectPath;
+  db.prepare(`INSERT INTO project_key_files_version (project_path, version)
+         VALUES (?, 1)
+         ON CONFLICT(project_path) DO UPDATE SET version = version + 1`).run(resolvedProjectPath);
+  return getKeyFilesVersion(db, resolvedProjectPath);
+}
+function resolveCommitFiles(projectPath, files) {
+  return files.map((file2) => {
+    try {
+      const disk = readFileSync(join5(projectPath, file2.path));
+      return {
+        ...file2,
+        contentHash: sha256(disk),
+        staleReason: null
+      };
+    } catch {
+      return {
+        ...file2,
+        contentHash: MISSING_CONTENT_HASH,
+        staleReason: "missing"
+      };
+    }
+  });
+}
+function insertResolvedKeyFiles(db, projectPath, files, generatedAt, generatedByModel, generationConfigHash) {
+  const insert = db.prepare(`INSERT INTO project_key_files
+           (project_path, path, content, content_hash, local_token_estimate,
+            generated_at, generated_by_model, generation_config_hash, stale_reason)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+  for (const file2 of files) {
+    insert.run(projectPath, file2.path, file2.content, file2.contentHash, file2.localTokenEstimate, generatedAt, generatedByModel, generationConfigHash, file2.staleReason);
+  }
+}
+function deleteOrphanProjectKeyFiles(db, now = Date.now()) {
+  const cutoff = now - ORPHAN_GRACE_MS;
+  const rows = db.prepare(`SELECT project_path AS projectPath, MAX(generated_at) AS lastGen
+               FROM project_key_files
+              GROUP BY project_path
+             HAVING lastGen < ?`).all(cutoff);
+  let deletedProjects = 0;
+  for (const row of rows) {
+    if (existsSync2(row.projectPath))
+      continue;
+    try {
+      db.prepare("DELETE FROM project_key_files WHERE project_path = ?").run(row.projectPath);
+      db.prepare("DELETE FROM project_key_files_version WHERE project_path = ?").run(row.projectPath);
+      deletedProjects++;
+    } catch (error51) {
+      log(`[key-files] orphan GC failed for ${row.projectPath}:`, error51);
+    }
+  }
+  return deletedProjects;
+}
+function isRelativeProjectFile(projectPath, relativePath) {
+  if (!relativePath || relativePath.startsWith("/") || relativePath.includes(".."))
+    return false;
+  try {
+    const root = realpathSync(projectPath);
+    const absPath = resolve(projectPath, relativePath);
+    const real = realpathSync(absPath);
+    return real.startsWith(root + sep) || real === root;
+  } catch {
+    return false;
+  }
+}
+
 // ../plugin/src/features/magic-context/migrations.ts
 init_logger();
 var MIGRATIONS = [
@@ -158201,6 +158275,46 @@ var MIGRATIONS = [
         db.exec("ALTER TABLE session_meta ADD COLUMN pending_compaction_marker_state TEXT");
       }
     }
+  },
+  {
+    version: 14,
+    description: "Add project-scoped key files and version counter",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS project_key_files (
+                    project_path           TEXT    NOT NULL,
+                    path                   TEXT    NOT NULL,
+                    content                TEXT    NOT NULL,
+                    content_hash           TEXT    NOT NULL,
+                    local_token_estimate   INTEGER NOT NULL,
+                    generated_at           INTEGER NOT NULL,
+                    generated_by_model     TEXT,
+                    generation_config_hash TEXT    NOT NULL,
+                    stale_reason           TEXT,
+                    PRIMARY KEY (project_path, path)
+                );
+
+                CREATE INDEX IF NOT EXISTS idx_project_key_files_project
+                    ON project_key_files(project_path);
+                CREATE INDEX IF NOT EXISTS idx_project_key_files_generated_at
+                    ON project_key_files(project_path, generated_at);
+
+                CREATE TABLE IF NOT EXISTS project_key_files_version (
+                    project_path TEXT    PRIMARY KEY,
+                    version      INTEGER NOT NULL DEFAULT 0
+                );
+            `);
+    }
+  },
+  {
+    version: 15,
+    description: "Add deferred_execute_state column for boundary execution drain",
+    up: (db) => {
+      const cols = db.prepare("PRAGMA table_info(session_meta)").all();
+      if (!cols.some((c) => c.name === "deferred_execute_state")) {
+        db.exec("ALTER TABLE session_meta ADD COLUMN deferred_execute_state TEXT");
+      }
+    }
   }
 ];
 function ensureMigrationsTable(db) {
@@ -158324,12 +158438,12 @@ function loadToolDefinitionMeasurements(db) {
 // ../plugin/src/features/magic-context/tool-owner-backfill.ts
 init_data_path();
 init_logger();
-import { existsSync as existsSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join6 } from "node:path";
 var LEASE_DURATION_MS = 5 * 60 * 1000;
 var LEASE_RENEWAL_MS = 60 * 1000;
 function resolveOpencodeDbPath() {
-  return join5(getDataDir(), "opencode", "opencode.db");
+  return join6(getDataDir(), "opencode", "opencode.db");
 }
 function ensureBackfillStateTable(db) {
   db.exec(`
@@ -158364,7 +158478,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync2(opencodeDbPath)) {
+  if (!existsSync3(opencodeDbPath)) {
     log(`[backfill] OpenCode DB not found at ${opencodeDbPath} — marking all unbackfilled sessions as skipped. Lazy adoption (defense-in-depth) handles legacy rows at runtime.`);
     markAllUnbackfilledSessionsSkipped(db);
     result.sessionsSkippedNoOcDb = countSessionsByStatus(db, "skipped");
@@ -158572,21 +158686,21 @@ var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join6(dbDir, "context.db") };
+  return { dbDir, dbPath: join7(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync3(targetDbPath))
+  if (existsSync4(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join6(legacyDir, "context.db");
-  if (!existsSync3(legacyDbPath))
+  const legacyDbPath = join7(legacyDir, "context.db");
+  if (!existsSync4(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
   mkdirSync4(targetDbDir, { recursive: true });
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
-    const dst = join6(targetDbDir, `context.db${suffix}`);
-    if (existsSync3(src)) {
+    const dst = join7(targetDbDir, `context.db${suffix}`);
+    if (existsSync4(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error51) {
@@ -158594,9 +158708,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join6(legacyDir, "models");
-  const targetModelsDir = join6(targetDbDir, "models");
-  if (existsSync3(legacyModelsDir) && !existsSync3(targetModelsDir)) {
+  const legacyModelsDir = join7(legacyDir, "models");
+  const targetModelsDir = join7(targetDbDir, "models");
+  if (existsSync4(legacyModelsDir) && !existsSync4(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error51) {
@@ -158744,6 +158858,26 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     );
     CREATE INDEX IF NOT EXISTS idx_dream_runs_project ON dream_runs(project_path, finished_at DESC);
 
+    CREATE TABLE IF NOT EXISTS project_key_files (
+      project_path           TEXT    NOT NULL,
+      path                   TEXT    NOT NULL,
+      content                TEXT    NOT NULL,
+      content_hash           TEXT    NOT NULL,
+      local_token_estimate   INTEGER NOT NULL,
+      generated_at           INTEGER NOT NULL,
+      generated_by_model     TEXT,
+      generation_config_hash TEXT    NOT NULL,
+      stale_reason           TEXT,
+      PRIMARY KEY (project_path, path)
+    );
+    CREATE INDEX IF NOT EXISTS idx_project_key_files_project ON project_key_files(project_path);
+    CREATE INDEX IF NOT EXISTS idx_project_key_files_generated_at ON project_key_files(project_path, generated_at);
+
+    CREATE TABLE IF NOT EXISTS project_key_files_version (
+      project_path TEXT    PRIMARY KEY,
+      version      INTEGER NOT NULL DEFAULT 0
+    );
+
     -- (smart_notes: see note above; merged into unified notes table by migration v1)
 
     CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
@@ -158821,7 +158955,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);
@@ -158910,6 +159048,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'");
@@ -158986,7 +159125,15 @@ function ensureColumn(db, table, column, definition) {
   if (rows.some((row) => row.name === column)) {
     return;
   }
-  db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  try {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  } catch (err) {
+    const recheck = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (recheck.some((row) => row.name === column)) {
+      return;
+    }
+    throw err;
+  }
 }
 function openDatabase() {
   const { dbDir, dbPath } = resolveDatabasePath();
@@ -159003,6 +159150,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) {
@@ -159124,6 +159276,12 @@ function isPersistedNoteNudgeRow(row) {
   const r = row;
   return typeof r.note_nudge_trigger_pending === "number" && typeof r.note_nudge_trigger_message_id === "string" && typeof r.note_nudge_sticky_text === "string" && typeof r.note_nudge_sticky_message_id === "string";
 }
+function isPersistedTodoSyntheticAnchorRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.todo_synthetic_call_id === "string" && typeof r.todo_synthetic_anchor_message_id === "string" && typeof r.todo_synthetic_state_json === "string";
+}
 function isPersistedHistorianFailureRow(row) {
   if (row === null || typeof row !== "object")
     return false;
@@ -159200,6 +159358,29 @@ function setPersistedDeliveredNoteNudge(db, sessionId, text, messageId = "") {
 function clearPersistedNoteNudge(db, sessionId) {
   db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 0, note_nudge_trigger_message_id = '', note_nudge_sticky_text = '', note_nudge_sticky_message_id = '' WHERE session_id = ?").run(sessionId);
 }
+function getPersistedTodoSyntheticAnchor(db, sessionId) {
+  const result = db.prepare("SELECT todo_synthetic_call_id, todo_synthetic_anchor_message_id, todo_synthetic_state_json FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!isPersistedTodoSyntheticAnchorRow(result)) {
+    return null;
+  }
+  if (result.todo_synthetic_call_id.length === 0 || result.todo_synthetic_anchor_message_id.length === 0) {
+    return null;
+  }
+  return {
+    callId: result.todo_synthetic_call_id,
+    messageId: result.todo_synthetic_anchor_message_id,
+    stateJson: result.todo_synthetic_state_json
+  };
+}
+function setPersistedTodoSyntheticAnchor(db, sessionId, callId, messageId, stateJson) {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET todo_synthetic_call_id = ?, todo_synthetic_anchor_message_id = ?, todo_synthetic_state_json = ? WHERE session_id = ?").run(callId, messageId, stateJson, sessionId);
+  })();
+}
+function clearPersistedTodoSyntheticAnchor(db, sessionId) {
+  db.prepare("UPDATE session_meta SET todo_synthetic_call_id = '', todo_synthetic_anchor_message_id = '', todo_synthetic_state_json = '' WHERE session_id = ?").run(sessionId);
+}
 function getNoteLastReadAt(db, sessionId) {
   try {
     const result = db.prepare("SELECT note_last_read_at FROM session_meta WHERE session_id = ?").get(sessionId);
@@ -159326,6 +159507,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;
+}
 // ../plugin/src/features/magic-context/resolve-subagent-fallback.ts
 init_logger();
 await init_read_session_db();
@@ -159920,10 +160125,10 @@ function getAgentFallbackModels(agent) {
 
 // ../plugin/src/shared/models-dev-cache.ts
 init_data_path();
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync4, readFileSync } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2, platform } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // ../plugin/src/shared/jsonc-parser.ts
 function stripJsonComments(content) {
@@ -160029,7 +160234,7 @@ var recentlySeenApiSizes = new Set;
 var fileCache = null;
 var fileLastAttempt = 0;
 function hashFast(input) {
-  return createHash3("sha1").update(input).digest("hex");
+  return createHash4("sha1").update(input).digest("hex");
 }
 function getModelsJsonPath() {
   const explicit = process.env.OPENCODE_MODELS_PATH?.trim();
@@ -160038,16 +160243,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 join7(cacheBase, "opencode", filename);
+  return join8(cacheBase, "opencode", filename);
 }
 function getOpencodeConfigPath() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  const configDir = envDir ? envDir : platform() === "win32" ? join7(homedir2(), ".config", "opencode") : join7(process.env.XDG_CONFIG_HOME || join7(homedir2(), ".config"), "opencode");
-  const jsonc = join7(configDir, "opencode.jsonc");
-  if (existsSync4(jsonc))
+  const configDir = envDir ? envDir : platform() === "win32" ? join8(homedir2(), ".config", "opencode") : join8(process.env.XDG_CONFIG_HOME || join8(homedir2(), ".config"), "opencode");
+  const jsonc = join8(configDir, "opencode.jsonc");
+  if (existsSync5(jsonc))
     return jsonc;
-  const json2 = join7(configDir, "opencode.json");
-  if (existsSync4(json2))
+  const json2 = join8(configDir, "opencode.json");
+  if (existsSync5(json2))
     return json2;
   return null;
 }
@@ -160079,9 +160284,9 @@ function loadModelsDevMetadataFromFile() {
   const modelsJsonPath = getModelsJsonPath();
   let fileFound = false;
   try {
-    if (existsSync4(modelsJsonPath)) {
+    if (existsSync5(modelsJsonPath)) {
       fileFound = true;
-      const raw = readFileSync(modelsJsonPath, "utf-8");
+      const raw = readFileSync2(modelsJsonPath, "utf-8");
       const data = JSON.parse(raw);
       for (const [providerId, provider2] of Object.entries(data)) {
         if (!provider2?.models || typeof provider2.models !== "object")
@@ -160096,8 +160301,8 @@ function loadModelsDevMetadataFromFile() {
   }
   try {
     const configPath = getOpencodeConfigPath();
-    if (configPath && existsSync4(configPath)) {
-      const config2 = parseJsonc(readFileSync(configPath, "utf-8"));
+    if (configPath && existsSync5(configPath)) {
+      const config2 = parseJsonc(readFileSync2(configPath, "utf-8"));
       if (config2.provider && typeof config2.provider === "object") {
         for (const [providerId, provider2] of Object.entries(config2.provider)) {
           if (!provider2?.models || typeof provider2.models !== "object")
@@ -160392,6 +160597,84 @@ function clearNoteNudgeState(db, sessionId, options) {
   lastDeliveredAt.delete(sessionId);
 }
 
+// ../plugin/src/hooks/magic-context/todo-view.ts
+import { createHash as createHash5 } from "node:crypto";
+var TERMINAL_STATUSES = new Set(["completed", "cancelled"]);
+var TITLE_DONE_STATUSES = new Set(["completed"]);
+var SYNTHETIC_CALL_ID_PREFIX = "mc_synthetic_todo_";
+function normalizeTodoStateJson(todos) {
+  if (!Array.isArray(todos))
+    return null;
+  const normalized = [];
+  for (const todo of todos) {
+    if (!isTodoItem(todo))
+      return null;
+    normalized.push({
+      content: todo.content,
+      status: todo.status,
+      priority: todo.priority ?? "medium"
+    });
+  }
+  return JSON.stringify(normalized);
+}
+function buildSyntheticTodoPart(stateJson) {
+  const todos = parseTodoState(stateJson);
+  if (todos === null || todos.length === 0)
+    return null;
+  if (todos.every((t) => TERMINAL_STATUSES.has(t.status)))
+    return null;
+  const callID = computeSyntheticCallId(stateJson);
+  const activeCount = todos.filter((t) => !TITLE_DONE_STATUSES.has(t.status)).length;
+  const output = JSON.stringify(todos, null, 2);
+  const ts = 0;
+  return {
+    type: "tool",
+    callID,
+    tool: "todowrite",
+    state: {
+      status: "completed",
+      input: { todos },
+      output,
+      title: `${activeCount} todos`,
+      metadata: { todos, truncated: false },
+      time: { start: ts, end: ts }
+    },
+    syntheticTodoMarker: true
+  };
+}
+function computeSyntheticCallId(stateJson) {
+  const hash2 = createHash5("sha256").update(stateJson).digest("hex").slice(0, 16);
+  return `${SYNTHETIC_CALL_ID_PREFIX}${hash2}`;
+}
+function parseTodoState(stateJson) {
+  if (stateJson.length === 0)
+    return null;
+  try {
+    const parsed = JSON.parse(stateJson);
+    if (!Array.isArray(parsed))
+      return null;
+    const result = [];
+    for (const item of parsed) {
+      if (!isTodoItem(item))
+        continue;
+      result.push({
+        content: item.content,
+        status: item.status,
+        priority: item.priority ?? "medium"
+      });
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function isTodoItem(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const todo = value;
+  return typeof todo.content === "string" && typeof todo.status === "string" && (todo.priority === undefined || typeof todo.priority === "string");
+}
+
 // src/index.ts
 init_data_path();
 init_logger();
@@ -160421,7 +160704,7 @@ init_logger();
 
 // src/subagent-runner.ts
 import * as childProcess from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { dirname as dirname3, resolve as resolvePath } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
@@ -160429,7 +160712,7 @@ function resolveSubagentEntryPath() {
   try {
     const here = dirname3(fileURLToPath(import.meta.url));
     const candidate = resolvePath(here, "subagent-entry.js");
-    if (existsSync5(candidate))
+    if (existsSync6(candidate))
       return candidate;
     return;
   } catch {
@@ -160454,13 +160737,13 @@ class PiSubagentRunner {
   async run(options) {
     const startTime = Date.now();
     const args = buildArgs(options);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let settled = false;
       const settle = (result) => {
         if (settled)
           return;
         settled = true;
-        resolve(result);
+        resolve2(result);
       };
       const emitProgress = (event) => {
         if (!options.onProgress)
@@ -160928,6 +161211,16 @@ function isLeaseActive(db) {
 function getLeaseHolder(db) {
   return getDreamState(db, LEASE_HOLDER_KEY);
 }
+function peekLeaseHolderAndExpiry(db, expectedHolder) {
+  const holder = getDreamState(db, LEASE_HOLDER_KEY);
+  if (holder !== expectedHolder)
+    return false;
+  const expiryStr = getDreamState(db, LEASE_EXPIRY_KEY);
+  if (!expiryStr)
+    return false;
+  const expiry = Number(expiryStr);
+  return Number.isFinite(expiry) && expiry >= Date.now();
+}
 function acquireLease(db, holderId) {
   return db.transaction(() => {
     if (isLeaseActive(db)) {
@@ -161040,8 +161333,8 @@ function clearStaleEntries(db, maxAgeMs) {
 // src/commands/ctx-dream.ts
 init_logger();
 // ../plugin/src/features/magic-context/dreamer/runner.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join11 } from "node:path";
 
 // ../plugin/src/shared/index.ts
 init_logger();
@@ -161335,187 +161628,519 @@ init_logger();
 await init_sqlite();
 
 // ../plugin/src/features/magic-context/key-files/identify-key-files.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join10 } from "node:path";
 init_logger();
 
-// ../plugin/src/features/magic-context/key-files/read-stats.ts
-function getSessionReadStats(openCodeDb, sessionId, minReads) {
-  const fullReads = openCodeDb.prepare(`
-        WITH full_reads AS (
-            SELECT 
-                json_extract(json_extract(data, '$.state'), '$.input.filePath') as file_path,
-                LENGTH(json_extract(json_extract(data, '$.state'), '$.output')) as output_bytes,
-                p.time_created,
-                ROW_NUMBER() OVER (
-                    PARTITION BY json_extract(json_extract(data, '$.state'), '$.input.filePath') 
-                    ORDER BY p.time_created DESC
-                ) as rn
-            FROM part p
-            WHERE p.session_id = ?
-                AND json_extract(data, '$.type') = 'tool'
-                AND json_extract(data, '$.tool') = 'read'
-                AND json_extract(json_extract(data, '$.state'), '$.input.filePath') IS NOT NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.startLine') IS NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.start_line') IS NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.endLine') IS NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.end_line') IS NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.offset') IS NULL
-                AND json_extract(json_extract(data, '$.state'), '$.input.limit') IS NULL
-        ),
-        file_counts AS (
-            SELECT file_path, COUNT(*) as full_read_count
-            FROM full_reads
-            GROUP BY file_path
-            HAVING full_read_count >= ?
-        )
-        SELECT 
-            r.file_path,
-            fc.full_read_count,
-            r.output_bytes as latest_read_bytes
-        FROM full_reads r
-        JOIN file_counts fc ON r.file_path = fc.file_path
-        WHERE r.rn = 1
-        ORDER BY fc.full_read_count DESC
-    `).all(sessionId, minReads);
-  if (fullReads.length === 0)
-    return [];
-  const editCounts = new Map;
-  const editRows = openCodeDb.prepare(`
-        SELECT 
-            json_extract(json_extract(data, '$.state'), '$.input.filePath') as file_path,
-            COUNT(*) as edit_count
-        FROM part p
-        WHERE p.session_id = ?
-            AND json_extract(data, '$.type') = 'tool'
-            AND json_extract(data, '$.tool') IN ('edit', 'write', 'mcp_edit', 'mcp_write')
-            AND json_extract(json_extract(data, '$.state'), '$.input.filePath') IS NOT NULL
-        GROUP BY file_path
-    `).all(sessionId);
-  for (const row of editRows) {
-    editCounts.set(row.file_path, row.edit_count);
-  }
-  return fullReads.map((row) => ({
-    filePath: row.file_path,
-    fullReadCount: row.full_read_count,
-    spreadAcrossCompartments: 0,
-    editCount: editCounts.get(row.file_path) ?? 0,
-    latestReadBytes: row.latest_read_bytes ?? 0,
-    latestReadTokens: Math.ceil((row.latest_read_bytes ?? 0) / 3.5)
-  }));
+// ../plugin/src/features/magic-context/key-files/aft-availability.ts
+var import_comment_json = __toESM(require_src2(), 1);
+import { existsSync as existsSync7, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join9 } from "node:path";
+var overrideAvailability = null;
+function parseConfig(path5) {
+  if (!existsSync7(path5))
+    return null;
+  return import_comment_json.parse(readFileSync3(path5, "utf-8"));
+}
+function entryMatchesAft(entry) {
+  const value = Array.isArray(entry) ? entry[0] : entry;
+  return typeof value === "string" && (value.includes("@cortexkit/aft") || value.includes("aft-opencode") || value.includes("aft-pi"));
+}
+function hasAftInArray(value) {
+  return Array.isArray(value) && value.some(entryMatchesAft);
+}
+function hasAftAtKeys(value, keys) {
+  if (!value || typeof value !== "object")
+    return false;
+  const record2 = value;
+  for (const key of keys) {
+    if (hasAftInArray(record2[key]))
+      return true;
+  }
+  return false;
+}
+function getAftAvailability() {
+  const home = process.env.HOME || homedir3();
+  const opencodePaths = [
+    join9(home, ".config", "opencode", "opencode.jsonc"),
+    join9(home, ".config", "opencode", "opencode.json")
+  ];
+  const piPaths = [join9(home, ".pi", "agent", "settings.json")];
+  const checkedPaths = [...opencodePaths, ...piPaths];
+  let opencode = false;
+  for (const path5 of opencodePaths) {
+    try {
+      const config2 = parseConfig(path5);
+      if (hasAftAtKeys(config2, ["plugin", "plugins", "mcp", "mcp_servers"])) {
+        opencode = true;
+        break;
+      }
+    } catch {}
+  }
+  let pi = false;
+  for (const path5 of piPaths) {
+    try {
+      const config2 = parseConfig(path5);
+      if (hasAftAtKeys(config2, ["packages", "extensions"])) {
+        pi = true;
+        break;
+      }
+      const agent = config2?.agent;
+      if (hasAftAtKeys(agent, ["packages", "extensions"])) {
+        pi = true;
+        break;
+      }
+    } catch {}
+  }
+  const detected = opencode || pi;
+  return {
+    available: overrideAvailability ?? detected,
+    opencode,
+    pi,
+    checkedPaths
+  };
+}
+function isAftAvailable() {
+  return getAftAvailability().available;
 }
 
-// ../plugin/src/features/magic-context/key-files/storage-key-files.ts
-init_logger();
-function getKeyFiles(db, sessionId) {
-  try {
-    const row = db.prepare("SELECT key_files FROM session_meta WHERE session_id = ?").get(sessionId);
-    if (!row?.key_files)
-      return [];
-    const parsed = JSON.parse(row.key_files);
-    if (!Array.isArray(parsed))
-      return [];
-    return parsed.filter((e) => typeof e === "object" && e !== null && typeof e.filePath === "string" && typeof e.tokens === "number");
-  } catch {
+// ../plugin/src/features/magic-context/key-files/read-history.ts
+import { realpathSync as realpathSync2 } from "node:fs";
+import { relative, resolve as resolve2 } from "node:path";
+function toMs(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string") {
+    const n = Number(value);
+    if (Number.isFinite(n))
+      return n;
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return 0;
+}
+function toPositiveInt(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+function coalesceRanges(ranges) {
+  if (ranges.length === 0)
     return [];
+  const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
+  const merged = [];
+  for (const range of sorted) {
+    const last = merged.at(-1);
+    if (last && range.start <= last.end + 10) {
+      last.end = Math.max(last.end, range.end);
+      last.count += range.count;
+      last.lastReadAt = Math.max(last.lastReadAt, range.lastReadAt);
+    } else {
+      merged.push({ ...range });
+    }
   }
+  return merged.sort((a, b) => b.lastReadAt - a.lastReadAt || b.count - a.count).slice(0, 3);
 }
-function setKeyFiles(db, sessionId, files) {
+function normalizeProjectRelativePath(projectPath, filePath) {
+  const root = realpathSync2(projectPath);
+  const abs = filePath.startsWith("/") ? resolve2(filePath) : resolve2(root, filePath);
+  let real = abs;
   try {
-    db.prepare("INSERT OR IGNORE INTO session_meta (session_id) VALUES (?)").run(sessionId);
-    db.prepare("UPDATE session_meta SET key_files = ? WHERE session_id = ?").run(JSON.stringify(files), sessionId);
-  } catch (error51) {
-    sessionLog(sessionId, "failed to persist key files:", error51);
+    real = realpathSync2(abs);
+  } catch {}
+  if (!real.startsWith(`${root}/`) && real !== root)
+    return null;
+  const rel = relative(root, real).replaceAll("\\", "/");
+  if (!rel || rel.startsWith(".."))
+    return null;
+  return rel;
+}
+function primarySessionIds(db) {
+  try {
+    const rows = db.prepare("SELECT session_id AS sessionId FROM session_meta WHERE is_subagent = 0").all();
+    return new Set(rows.map((row) => row.sessionId));
+  } catch {
+    return new Set;
   }
 }
-function greedyFitFiles(rankedFiles, tokenBudget) {
-  const selected = [];
-  let remainingBudget = tokenBudget;
-  for (const file2 of rankedFiles) {
-    if (file2.tokens <= 0)
+function collectKeyFileCandidates(args) {
+  const primaryIds = primarySessionIds(args.magicDb);
+  if (primaryIds.size === 0)
+    return [];
+  const reads = args.openCodeDb.prepare(`SELECT p.session_id,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.filePath') AS file_path,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.startLine') AS start_line,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.endLine') AS end_line,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.offset') AS offset_value,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.limit') AS limit_value,
+                    LENGTH(json_extract(json_extract(p.data, '$.state'), '$.output')) AS output_bytes,
+                    p.time_created
+               FROM part p
+              WHERE json_extract(p.data, '$.type') = 'tool'
+                AND json_extract(p.data, '$.tool') = 'read'
+                AND json_extract(json_extract(p.data, '$.state'), '$.input.filePath') IS NOT NULL`).all();
+  const byPath = new Map;
+  for (const row of reads) {
+    if (!primaryIds.has(row.session_id) || !row.file_path)
       continue;
-    if (file2.tokens > remainingBudget)
+    const rel = normalizeProjectRelativePath(args.projectPath, row.file_path);
+    if (!rel)
       continue;
-    selected.push({ filePath: file2.filePath, tokens: file2.tokens });
-    remainingBudget -= file2.tokens;
-    if (remainingBudget <= 0)
-      break;
+    const timestamp = toMs(row.time_created);
+    const candidate = byPath.get(rel) ?? {
+      path: rel,
+      totalReads: 0,
+      rangedReads: 0,
+      fullReads: 0,
+      editCount: 0,
+      latestReadBytes: 0,
+      firstReadAt: timestamp || Date.now(),
+      lastReadAt: 0,
+      ranges: [],
+      rangeMap: new Map
+    };
+    candidate.totalReads++;
+    candidate.firstReadAt = Math.min(candidate.firstReadAt, timestamp || candidate.firstReadAt);
+    candidate.lastReadAt = Math.max(candidate.lastReadAt, timestamp);
+    if (timestamp >= candidate.lastReadAt)
+      candidate.latestReadBytes = Number(row.output_bytes ?? 0);
+    const start = toPositiveInt(row.start_line) ?? toPositiveInt(row.offset_value);
+    const explicitEnd = toPositiveInt(row.end_line);
+    const limit = toPositiveInt(row.limit_value);
+    const end = explicitEnd ?? (start && limit ? start + limit - 1 : null);
+    if (start && end) {
+      candidate.rangedReads++;
+      const key = `${start}:${end}`;
+      const existing = candidate.rangeMap.get(key);
+      if (existing) {
+        existing.count++;
+        existing.lastReadAt = Math.max(existing.lastReadAt, timestamp);
+      } else {
+        candidate.rangeMap.set(key, { start, end, count: 1, lastReadAt: timestamp });
+      }
+    } else {
+      candidate.fullReads++;
+    }
+    byPath.set(rel, candidate);
+  }
+  const edits = args.openCodeDb.prepare(`SELECT p.session_id,
+                    json_extract(json_extract(p.data, '$.state'), '$.input.filePath') AS file_path,
+                    COUNT(*) AS edit_count
+               FROM part p
+              WHERE json_extract(p.data, '$.type') = 'tool'
+                AND json_extract(p.data, '$.tool') IN ('edit', 'write', 'mcp_edit', 'mcp_write')
+                AND json_extract(json_extract(p.data, '$.state'), '$.input.filePath') IS NOT NULL
+              GROUP BY p.session_id, file_path`).all();
+  for (const row of edits) {
+    if (!primaryIds.has(row.session_id) || !row.file_path)
+      continue;
+    const rel = normalizeProjectRelativePath(args.projectPath, row.file_path);
+    if (!rel)
+      continue;
+    const candidate = byPath.get(rel);
+    if (candidate)
+      candidate.editCount += Number(row.edit_count ?? 0);
   }
-  return selected;
+  return [...byPath.values()].filter((candidate) => candidate.totalReads >= args.minReads).map(({ rangeMap, ...candidate }) => ({
+    ...candidate,
+    ranges: coalesceRanges([...rangeMap.values()])
+  })).sort((a, b) => b.totalReads - a.totalReads || b.lastReadAt - a.lastReadAt).slice(0, 200);
 }
 
+// ../plugin/src/features/magic-context/key-files/storage-key-files.ts
+init_logger();
+
 // ../plugin/src/features/magic-context/key-files/identify-key-files.ts
 var KEY_FILES_SYSTEM_PROMPT = "You are a file importance evaluator. Given read statistics about files in a coding session, identify which are core orientation files worth pinning in context. Return a JSON array.";
-function buildKeyFilesPrompt(candidates, tokenBudget, minReads) {
-  const statsText = candidates.map((s) => `- **${s.filePath}** — ${s.fullReadCount} full reads, ${s.editCount} edits, ~${s.latestReadTokens} tokens`).join(`
+class KeyFilesValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KeyFilesValidationError";
+  }
+}
+function computeGenerationConfigHash(config2) {
+  return sha256(JSON.stringify({ budget: config2.token_budget, min_reads: config2.min_reads }));
+}
+function extractJsonObject(text) {
+  const fenced = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (fenced?.[1])
+    return fenced[1];
+  const object2 = text.match(/\{[\s\S]*\}/);
+  if (object2?.[0])
+    return object2[0];
+  throw new KeyFilesValidationError("missing JSON object");
+}
+function formatCandidates(candidates) {
+  return candidates.map((candidate) => {
+    const ranges = candidate.ranges.map((range) => `${range.start}-${range.end} (${range.count}x)`).join(", ");
+    return `| ${candidate.path} | ${candidate.totalReads} | ${new Date(candidate.lastReadAt).toISOString()} | ${ranges || "full reads"} |`;
+  }).join(`
+`);
+}
+function buildV6KeyFilesPrompt(args) {
+  const current = args.currentRows.map((row) => `- ${row.path}: ${row.localTokenEstimate} tokens, stale=${row.staleReason ?? "fresh"}`).join(`
 `);
-  return `## Identify Key Files for Pinning
+  return `## Task: Identify project key files
 
-The following files were fully read ${minReads}+ times during a coding session.
-Identify which ones are **core orientation files** worth keeping permanently in context.
+You are deciding which files this project's primary agent should always see as orientation context. The injection budget is **${args.config.token_budget} tokens** for all files combined.
 
-### Signals of a core orientation file:
-- Read many times across different phases of work (not clustered in one task)
-- Read without editing — consulted for understanding, not modification
-- Contains architecture, configuration, types, or key abstractions
+## Read history (primary sessions only, project-scoped)
 
-### Signals of a NON-core file (exclude):
-- Read many times but always edited — actively working on it
-- Very large (>5000 tokens) — too expensive to pin
-- Test files, scripts, or generated files
+| path | total reads | last read | common line ranges |
+| --- | ---: | --- | --- |
+${formatCandidates(args.candidates)}
 
-### Token budget: ${tokenBudget} tokens total
+## Current key files (if any)
 
-### Files:
-${statsText}
+${current || "(none)"}
+
+## Tools available
+
+- \`aft_outline(target=<path>)\` — get symbol outline for a file
+- \`aft_zoom(filePath=<path>, symbol=<name>)\` — get full source of one symbol
+
+## Output (strict JSON)
 
-### Output Format
-Return a JSON array ranked by importance (most important first):
 \`\`\`json
-[
-  {"filePath": "src/path/to/file.ts", "tokens": 2500, "reason": "brief reason"}
-]
+{
+  "no_change": false,
+  "files": [
+    {
+      "path": "src/example.ts",
+      "content": "...outline + symbol bodies stitched from src/example.ts only...",
+      "approx_token_estimate": 1200
+    }
+  ]
+}
 \`\`\`
 
-Only include files you're confident are true orientation files. Return empty array if none qualify.`;
+If current key files are still optimal, return \`{ "no_change": true, "files": [] }\`.
+
+Rules:
+- Each row's content MUST come from ONLY the one file at path. If two files matter, emit two rows.
+- Do NOT emit source_files. One row = one file = one hash.
+- Total approx_token_estimate must be < ${args.config.token_budget}.
+- path must be relative, no .., no absolute paths, no symlinks escaping project root.
+- path must be unique case-sensitively and case-insensitively.
+- content must be plain text; no XML tags inside.`;
+}
+function validateLlmOutput(raw, config2, projectPath) {
+  let obj;
+  try {
+    obj = JSON.parse(extractJsonObject(raw));
+  } catch (error51) {
+    if (error51 instanceof KeyFilesValidationError)
+      throw error51;
+    throw new KeyFilesValidationError(`invalid JSON: ${getErrorMessage(error51)}`);
+  }
+  if (!obj || typeof obj !== "object")
+    throw new KeyFilesValidationError("output must be object");
+  const record2 = obj;
+  if (typeof record2.no_change !== "boolean")
+    throw new KeyFilesValidationError("missing no_change");
+  if (!Array.isArray(record2.files))
+    throw new KeyFilesValidationError("missing files array");
+  if (record2.no_change && record2.files.length > 0)
+    throw new KeyFilesValidationError("no_change=true with files");
+  if (!record2.no_change && record2.files.length === 0)
+    throw new KeyFilesValidationError("no_change=false with empty files");
+  const seen = new Set;
+  const seenLower = new Set;
+  const files = [];
+  for (const item of record2.files) {
+    if (!item || typeof item !== "object")
+      throw new KeyFilesValidationError("bad file entry");
+    const file2 = item;
+    if ("source_files" in file2) {
+      throw new KeyFilesValidationError(`source_files field not allowed (one file per row): ${String(file2.path)}`);
+    }
+    if (typeof file2.path !== "string" || file2.path.length === 0)
+      throw new KeyFilesValidationError("bad path");
+    if (file2.path.startsWith("/") || file2.path.includes(".."))
+      throw new KeyFilesValidationError(`escape: ${file2.path}`);
+    if (seen.has(file2.path))
+      throw new KeyFilesValidationError(`dup path: ${file2.path}`);
+    if (seenLower.has(file2.path.toLowerCase()))
+      throw new KeyFilesValidationError(`case-dup: ${file2.path}`);
+    seen.add(file2.path);
+    seenLower.add(file2.path.toLowerCase());
+    if (!isRelativeProjectFile(projectPath, file2.path))
+      throw new KeyFilesValidationError(`unreadable: ${file2.path}`);
+    if (typeof file2.content !== "string")
+      throw new KeyFilesValidationError(`bad content: ${file2.path}`);
+    if (file2.content.length > 1e5)
+      throw new KeyFilesValidationError(`content >100KB: ${file2.path}`);
+    if (typeof file2.approx_token_estimate !== "number" || file2.approx_token_estimate < 0) {
+      throw new KeyFilesValidationError(`bad token estimate: ${file2.path}`);
+    }
+    const local = estimateTokens(file2.content);
+    if (file2.approx_token_estimate > 0 && (local / file2.approx_token_estimate > 1.5 || local / file2.approx_token_estimate < 0.5)) {
+      log(`key-files: token estimate divergence for ${file2.path}: claimed=${file2.approx_token_estimate}, plugin=${local}`);
+    }
+    files.push({
+      path: file2.path,
+      content: file2.content,
+      approx_token_estimate: file2.approx_token_estimate,
+      local_token_estimate: local
+    });
+  }
+  const total = files.reduce((sum, file2) => sum + file2.local_token_estimate, 0);
+  if (total > config2.token_budget)
+    throw new KeyFilesValidationError(`total ${total} > budget ${config2.token_budget}`);
+  return { no_change: record2.no_change, files };
 }
-function parseKeyFilesOutput(text) {
-  const jsonMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/) ?? text.match(/\[[\s\S]*\]/);
-  if (!jsonMatch)
-    return [];
+function commitKeyFiles(args) {
+  if (args.validated.no_change)
+    return null;
+  const projectPath = resolveProjectPath(args.projectPath) ?? args.projectPath;
+  const resolved = resolveCommitFiles(projectPath, args.validated.files.map((file2) => ({
+    path: file2.path,
+    content: file2.content,
+    localTokenEstimate: file2.local_token_estimate
+  })));
+  const generatedAt = Date.now();
+  const bump = args.bumpVersion ?? bumpKeyFilesVersion;
+  args.db.exec("BEGIN IMMEDIATE");
+  let committed = false;
   try {
-    const raw = jsonMatch[1] ?? jsonMatch[0];
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed))
-      return [];
-    return parsed.filter((item) => typeof item === "object" && item !== null && typeof item.filePath === "string" && typeof item.tokens === "number").map((item) => ({ filePath: item.filePath, tokens: item.tokens }));
-  } catch {
-    return [];
+    if (!peekLeaseHolderAndExpiry(args.db, args.leaseHolderId)) {
+      log(`key-files commit aborted: lease lost (holder ${args.leaseHolderId})`);
+      return null;
+    }
+    args.db.prepare("DELETE FROM project_key_files WHERE project_path = ?").run(projectPath);
+    insertResolvedKeyFiles(args.db, projectPath, resolved, generatedAt, args.modelId, args.configHash);
+    const version2 = bump(args.db, projectPath);
+    args.db.exec("COMMIT");
+    committed = true;
+    log(`key-files committed: ${resolved.length} files, version=${version2}, ${resolved.filter((r) => r.staleReason).length} pre-stale`);
+    return version2;
+  } finally {
+    if (!committed) {
+      try {
+        args.db.exec("ROLLBACK");
+      } catch {}
+    }
   }
 }
-function getKeyFileCandidates(openCodeDb, sessionId, minReads, tokenBudget, projectDirectory) {
-  const stats = getSessionReadStats(openCodeDb, sessionId, minReads);
-  const maxPerFileTokens = Math.min(tokenBudget / 2, 5000);
-  const projectPrefix = projectDirectory ? `${projectDirectory.replace(/\/$/, "")}/` : undefined;
-  return stats.filter((s) => s.latestReadTokens > 0 && s.latestReadTokens <= maxPerFileTokens && (!projectPrefix || s.filePath.startsWith(projectPrefix)));
-}
-function applyKeyFileResults(db, sessionId, llmRanked, tokenBudget, candidatePaths) {
-  const filtered = candidatePaths ? llmRanked.filter((f) => candidatePaths.has(f.filePath)) : llmRanked;
-  const selected = greedyFitFiles(filtered, tokenBudget);
-  setKeyFiles(db, sessionId, selected);
-  const totalTokens = selected.reduce((sum, f) => sum + f.tokens, 0);
-  log(`[key-files][${sessionId}] pinned ${selected.length} files (${totalTokens} tokens): ${selected.map((f) => f.filePath).join(", ")}`);
-  return { filesIdentified: selected.length, totalTokens };
-}
-function heuristicKeyFileSelection(db, sessionId, candidates, tokenBudget) {
-  const scored = candidates.map((c) => ({
-    filePath: c.filePath,
-    tokens: c.latestReadTokens,
-    score: c.fullReadCount * 2 - c.editCount * 3
-  })).filter((c) => c.score > 0).sort((a, b) => b.score - a.score);
-  const selected = greedyFitFiles(scored, tokenBudget);
-  setKeyFiles(db, sessionId, selected);
-  const totalTokens = selected.reduce((sum, f) => sum + f.tokens, 0);
-  log(`[key-files][${sessionId}] heuristic pinned ${selected.length} files (${totalTokens} tokens)`);
-  return { filesIdentified: selected.length, totalTokens };
+async function 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;
+    });
+  }
+}
+async function runKeyFilesTask(args) {
+  if (!args.config.enabled)
+    return { committedVersion: null, candidates: 0, noChange: false };
+  if (!isAftAvailable()) {
+    log("[key-files] AFT not available, skipping key-files task");
+    return { committedVersion: null, candidates: 0, noChange: false };
+  }
+  const projectPath = resolveProjectPath(args.projectPath) ?? args.projectPath;
+  const candidates = collectKeyFileCandidates({
+    openCodeDb: args.openCodeDb,
+    magicDb: args.db,
+    projectPath,
+    minReads: args.config.min_reads
+  });
+  if (candidates.length === 0)
+    return { committedVersion: null, candidates: 0, noChange: false };
+  const currentRows = readCurrentKeyFiles(args.db, projectPath);
+  const configHash = computeGenerationConfigHash(args.config);
+  const allRowsFreshAndCurrent = currentRows.length > 0 && currentRows.every((row) => {
+    if (row.staleReason !== null || row.generationConfigHash !== configHash)
+      return false;
+    try {
+      return sha256(readFileSync4(join10(projectPath, row.path))) === row.contentHash;
+    } catch {
+      return false;
+    }
+  });
+  const currentPaths = new Set(currentRows.map((row) => row.path));
+  if (allRowsFreshAndCurrent && candidates.every((candidate) => currentPaths.has(candidate.path))) {
+    log(`key-files: no_change short-circuit (${currentRows.length} rows fresh)`);
+    return { committedVersion: null, candidates: candidates.length, noChange: true };
+  }
+  const prompt = buildV6KeyFilesPrompt({ candidates, currentRows, config: args.config });
+  let validated;
+  const leaseInterval = setInterval(() => {
+    try {
+      if (!renewLease(args.db, args.holderId)) {
+        log("[key-files] lease renewal failed during LLM call");
+      }
+    } catch (error51) {
+      log(`[key-files] lease renewal threw: ${getErrorMessage(error51)}`);
+    }
+  }, 60000);
+  try {
+    try {
+      const raw = await runKeyFilesLlm({
+        client: args.client,
+        parentSessionId: args.parentSessionId,
+        projectPath,
+        prompt,
+        deadline: args.deadline,
+        fallbackModels: args.fallbackModels
+      });
+      validated = validateLlmOutput(raw, args.config, projectPath);
+    } catch (error51) {
+      log(`[key-files] LLM validation failed: ${getErrorMessage(error51)}`);
+      throw error51;
+    }
+    if (validated.no_change)
+      return { committedVersion: null, candidates: candidates.length, noChange: true };
+    const committedVersion = commitKeyFiles({
+      db: args.db,
+      projectPath,
+      validated,
+      configHash,
+      modelId: args.fallbackModels?.[0] ?? "dreamer",
+      leaseHolderId: args.holderId
+    });
+    renewLease(args.db, args.holderId);
+    return { committedVersion, candidates: candidates.length, noChange: false };
+  } finally {
+    clearInterval(leaseInterval);
+  }
 }
 
 // ../plugin/src/features/magic-context/memory/embedding-cache.ts
@@ -162579,11 +163204,11 @@ function logWithStackHead(message, stackHead) {
   log(message, stackHead ? { stackHead } : undefined);
 }
 function getOpenCodeDbPath2() {
-  return join8(getDataDir(), "opencode", "opencode.db");
+  return join11(getDataDir(), "opencode", "opencode.db");
 }
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath2();
-  if (!existsSync6(dbPath)) {
+  if (!existsSync8(dbPath)) {
     log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
     return null;
   }
@@ -162596,190 +163221,6 @@ function openOpenCodeDb() {
     return null;
   }
 }
-function isSessionIdRow(row) {
-  if (row === null || typeof row !== "object") {
-    return false;
-  }
-  return typeof row.sessionId === "string";
-}
-function hasExplicitEmptyKeyFilesOutput(text) {
-  return /```(?:json)?\s*\[\s*\]\s*```/s.test(text) || /^\s*\[\s*\]\s*$/s.test(text);
-}
-async function getActiveProjectSessionIds(args) {
-  try {
-    const { withReadOnlySessionDb: withReadOnlySessionDb2 } = await init_read_session_db().then(() => exports_read_session_db);
-    const projectSessionIds = withReadOnlySessionDb2((openCodeDb) => {
-      const bareIdentity = args.projectIdentity.replace(/^git:/, "");
-      const rows = openCodeDb.prepare("SELECT id FROM session WHERE project_id = ? AND parent_id IS NULL ORDER BY time_updated DESC").all(bareIdentity);
-      return new Set(rows.map((r) => r.id));
-    });
-    if (projectSessionIds.size === 0) {
-      return [];
-    }
-    return args.db.prepare("SELECT session_id AS sessionId FROM session_meta WHERE is_subagent = 0 ORDER BY session_id ASC").all().filter(isSessionIdRow).map((row) => row.sessionId).filter((sessionId) => projectSessionIds.has(sessionId));
-  } catch (error51) {
-    sessionLog(args.projectIdentity, `key-files: OpenCode DB lookup failed, falling back to SDK list: ${getErrorMessage(error51)}`);
-    const listResponse = await args.client.session.list({
-      query: { directory: args.sessionDirectory ?? args.projectIdentity }
-    });
-    const sessions = normalizeSDKResponse(listResponse, [], {
-      preferResponseOnMissingData: true
-    });
-    const projectSessionIds = new Set(sessions.map((session) => typeof session?.id === "string" ? session.id : null).filter((sessionId) => Boolean(sessionId)));
-    if (projectSessionIds.size === 0) {
-      return [];
-    }
-    return args.db.prepare("SELECT session_id AS sessionId FROM session_meta WHERE is_subagent = 0 ORDER BY session_id ASC").all().filter(isSessionIdRow).map((row) => row.sessionId).filter((sessionId) => projectSessionIds.has(sessionId));
-  }
-}
-async function identifyKeyFilesForSession(args) {
-  let openCodeDb = null;
-  try {
-    openCodeDb = openOpenCodeDb();
-    if (!openCodeDb) {
-      return;
-    }
-    const candidates = getKeyFileCandidates(openCodeDb, args.sessionId, args.config.min_reads, args.config.token_budget, args.sessionDirectory);
-    if (candidates.length === 0) {
-      log(`[key-files][${args.sessionId}] no candidates found — skipping`);
-      return;
-    }
-    const prompt = buildKeyFilesPrompt(candidates, args.config.token_budget, args.config.min_reads);
-    const applyHeuristicFallback = () => {
-      heuristicKeyFileSelection(args.db, args.sessionId, candidates, args.config.token_budget);
-    };
-    let agentSessionId = null;
-    const abortController = new AbortController;
-    const leaseInterval = setInterval(() => {
-      try {
-        if (!renewLease(args.db, args.holderId)) {
-          log(`[key-files][${args.sessionId}] lease renewal failed — aborting`);
-          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();
@@ -162898,8 +163339,8 @@ async function runDream(args) {
       try {
         const docsDir = args.sessionDirectory ?? args.projectIdentity;
         const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync6(join8(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync6(join8(docsDir, "STRUCTURE.md"))
+          architecture: existsSync8(join11(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync8(join11(docsDir, "STRUCTURE.md"))
         } : undefined;
         const userMemories = taskName === "archive-stale" ? getActiveUserMemories(args.db).map((um) => ({
           id: um.id,
@@ -163000,8 +163441,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);
           });
@@ -163102,19 +163542,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");
         }
@@ -163332,8 +163777,7 @@ Only include notes whose conditions you could definitively evaluate. Skip notes
     clearInterval(leaseInterval);
     if (agentSessionId) {
       await args.client.session.delete({
-        path: { id: agentSessionId },
-        query: { directory: args.sessionDirectory ?? args.projectIdentity }
+        path: { id: agentSessionId }
       }).catch(() => {});
     }
   }
@@ -164451,6 +164895,9 @@ function executeFlush(db, sessionId) {
   }
 }
 
+// src/context-handler.ts
+import * as crypto2 from "node:crypto";
+
 // ../plugin/src/features/magic-context/scheduler.ts
 init_logger();
 var TTL_PATTERN = /^(\d+)([smh])$/;
@@ -164848,6 +165295,30 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
   return didMutateMessage;
 }
 
+// ../plugin/src/hooks/magic-context/boundary-execution.ts
+var FORCE_MATERIALIZE_PERCENTAGE = 85;
+function detectMidTurnBypassReason(input) {
+  if (input.contextUsage.percentage >= FORCE_MATERIALIZE_PERCENTAGE)
+    return "force-materialize";
+  if (input.historyRefreshSessions.has(input.sessionId))
+    return "explicit-bust";
+  if (input.sessionMeta.isSubagent)
+    return "subagent";
+  return "none";
+}
+function applyMidTurnDeferral(input) {
+  if (input.base === "defer") {
+    return { midTurnAdjustedSchedulerDecision: "defer", sideEffect: "none" };
+  }
+  if (input.bypassReason !== "none") {
+    return { midTurnAdjustedSchedulerDecision: "execute", sideEffect: "none" };
+  }
+  if (input.midTurn) {
+    return { midTurnAdjustedSchedulerDecision: "defer", sideEffect: "set-flag" };
+  }
+  return { midTurnAdjustedSchedulerDecision: "execute", sideEffect: "none" };
+}
+
 // ../plugin/src/hooks/magic-context/caveman.ts
 var PRESERVATION_PATTERNS = [
   /```[\s\S]*?```/g,
@@ -166619,10 +167090,10 @@ var DEFAULT_MIN_PROMPT_CHARS = 20;
 async function unifiedSearchWithTimeout(db, sessionId, projectPath, prompt, options, timeoutMs) {
   const controller = new AbortController;
   let timer;
-  const timeoutPromise = new Promise((resolve) => {
+  const timeoutPromise = new Promise((resolve3) => {
     timer = setTimeout(() => {
       controller.abort();
-      resolve(null);
+      resolve3(null);
     }, timeoutMs);
   });
   try {
@@ -168272,7 +168743,7 @@ function getReducedRecompTokenBudget(currentBudget) {
 // ../plugin/src/hooks/magic-context/historian-state-file.ts
 init_data_path();
 import { mkdirSync as mkdirSync5, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join12 } from "node:path";
 var HISTORIAN_STATE_INLINE_THRESHOLD = 30000;
 function maybeWriteHistorianStateFile(sessionId, existingState, directory) {
   if (existingState.length <= HISTORIAN_STATE_INLINE_THRESHOLD)
@@ -168280,7 +168751,7 @@ function maybeWriteHistorianStateFile(sessionId, existingState, directory) {
   try {
     const dir = getProjectMagicContextHistorianDir(directory);
     mkdirSync5(dir, { recursive: true });
-    const path5 = join9(dir, `state-${sessionId}-${Date.now()}.xml`);
+    const path5 = join12(dir, `state-${sessionId}-${Date.now()}.xml`);
     writeFileSync2(path5, existingState, "utf8");
     return path5;
   } catch {
@@ -168297,6 +168768,238 @@ function cleanupHistorianStateFile(path5) {
 
 // src/pi-historian-runner.ts
 init_logger();
+
+// src/read-session-pi.ts
+function isMidTurnPi(event, _sessionId) {
+  const messages = event?.messages;
+  if (!Array.isArray(messages))
+    return false;
+  let latestAssistantIndex = -1;
+  let latestAssistant = null;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg !== null && typeof msg === "object") {
+      const record2 = msg;
+      if (record2.role === "assistant") {
+        latestAssistantIndex = i;
+        latestAssistant = record2;
+        break;
+      }
+    }
+  }
+  if (latestAssistant === null)
+    return false;
+  if (latestAssistant.stopReason === "toolUse")
+    return true;
+  const toolCallIds = getToolCallIds(latestAssistant.content);
+  if (toolCallIds.size === 0)
+    return false;
+  const pairedToolResultIds = new Set;
+  for (const msg of messages.slice(latestAssistantIndex + 1)) {
+    if (msg === null || typeof msg !== "object")
+      continue;
+    const record2 = msg;
+    if (record2.role !== "toolResult")
+      continue;
+    if (typeof record2.toolCallId === "string") {
+      pairedToolResultIds.add(record2.toolCallId);
+    }
+  }
+  for (const id of toolCallIds) {
+    if (!pairedToolResultIds.has(id))
+      return true;
+  }
+  return false;
+}
+function getToolCallIds(content) {
+  const ids = new Set;
+  if (!Array.isArray(content))
+    return ids;
+  for (const item of content) {
+    if (item === null || typeof item !== "object")
+      continue;
+    const record2 = item;
+    if (record2.type === "toolCall" && typeof record2.id === "string") {
+      ids.add(record2.id);
+    }
+  }
+  return ids;
+}
+function readPiSessionMessages(ctx) {
+  const sm = ctx.sessionManager;
+  if (sm === undefined)
+    return [];
+  const getBranch = sm.getBranch;
+  if (typeof getBranch !== "function")
+    return [];
+  let entries;
+  try {
+    entries = getBranch.call(sm);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(entries))
+    return [];
+  return convertEntriesToRawMessages(entries);
+}
+function convertEntriesToRawMessages(entries) {
+  const result = [];
+  let nextOrdinal = 1;
+  let pendingToolParts = [];
+  let pendingFirstRealId = "";
+  for (const entry of entries) {
+    if (!isMessageEntry(entry)) {
+      continue;
+    }
+    const msg = entry.message;
+    const role = msg.role;
+    if (role === "toolResult") {
+      pendingToolParts.push(...synthesizeToolResultParts(msg));
+      if (pendingFirstRealId === "") {
+        pendingFirstRealId = entry.id;
+      }
+      continue;
+    }
+    if (role === "user") {
+      const parts = [
+        ...pendingToolParts,
+        ...synthesizeUserParts(msg)
+      ];
+      pendingToolParts = [];
+      pendingFirstRealId = "";
+      result.push({
+        ordinal: nextOrdinal++,
+        id: entry.id,
+        role: "user",
+        parts
+      });
+      continue;
+    }
+    if (role === "assistant") {
+      if (pendingToolParts.length > 0) {
+        result.push({
+          ordinal: nextOrdinal++,
+          id: pendingFirstRealId,
+          role: "user",
+          parts: pendingToolParts
+        });
+        pendingToolParts = [];
+        pendingFirstRealId = "";
+      }
+      result.push({
+        ordinal: nextOrdinal++,
+        id: entry.id,
+        role: "assistant",
+        parts: synthesizeAssistantParts(msg)
+      });
+      continue;
+    }
+    result.push({
+      ordinal: nextOrdinal++,
+      id: entry.id,
+      role: typeof role === "string" ? role : "unknown",
+      parts: []
+    });
+  }
+  if (pendingToolParts.length > 0) {
+    result.push({
+      ordinal: nextOrdinal,
+      id: pendingFirstRealId,
+      role: "user",
+      parts: pendingToolParts
+    });
+  }
+  return result;
+}
+function isMessageEntry(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const v = value;
+  if (v.type !== "message")
+    return false;
+  if (typeof v.id !== "string")
+    return false;
+  if (v.message === null || typeof v.message !== "object")
+    return false;
+  return true;
+}
+function synthesizeUserParts(msg) {
+  const m = msg;
+  if (typeof m.content === "string") {
+    if (m.content.trim().length === 0)
+      return [];
+    return [{ type: "text", text: m.content }];
+  }
+  if (!Array.isArray(m.content))
+    return [];
+  const parts = [];
+  for (const c of m.content) {
+    if (c === null || typeof c !== "object")
+      continue;
+    const cc = c;
+    if (cc.type === "text" && typeof cc.text === "string") {
+      parts.push({ type: "text", text: cc.text });
+    }
+  }
+  return parts;
+}
+function synthesizeAssistantParts(msg) {
+  const m = msg;
+  if (!Array.isArray(m.content))
+    return [];
+  const parts = [];
+  for (const c of m.content) {
+    if (c === null || typeof c !== "object")
+      continue;
+    const cc = c;
+    if (cc.type === "text" && typeof cc.text === "string") {
+      parts.push({ type: "text", text: cc.text });
+    } else if (cc.type === "toolCall" && typeof cc.id === "string") {
+      parts.push({
+        type: "tool",
+        tool: typeof cc.name === "string" ? cc.name : "unknown",
+        callID: cc.id,
+        state: {
+          input: cc.arguments ?? {}
+        }
+      });
+    }
+  }
+  return parts;
+}
+function synthesizeToolResultParts(msg) {
+  const m = msg;
+  const callID = typeof m.toolCallId === "string" ? m.toolCallId : "";
+  const tool = typeof m.toolName === "string" ? m.toolName : "unknown";
+  if (!callID)
+    return [];
+  let output = "";
+  if (Array.isArray(m.content)) {
+    const fragments = [];
+    for (const c of m.content) {
+      if (c === null || typeof c !== "object")
+        continue;
+      const cc = c;
+      if (cc.type === "text" && typeof cc.text === "string") {
+        fragments.push(cc.text);
+      }
+    }
+    output = fragments.join(`
+`);
+  }
+  return [
+    {
+      type: "tool",
+      tool,
+      callID,
+      state: {
+        output
+      }
+    }
+  ];
+}
+
+// src/pi-historian-runner.ts
 var HISTORIAN_AGENT_NAME = "magic-context-historian";
 var DEFAULT_HISTORIAN_TIMEOUT_MS2 = 120000;
 var HISTORIAN_ALERT_COOLDOWN_MS = 60 * 1000;
@@ -168591,191 +169294,160 @@ function appendPiNativeCompaction(args) {
   }
 }
 function findFirstKeptEntryId(entries, lastCompactedOrdinal) {
-  let ordinal = 0;
-  for (const entry of entries) {
-    if (!entry || typeof entry !== "object")
-      continue;
-    const e = entry;
-    if (e.type !== "message")
-      continue;
-    const role = e.message?.role;
-    if (role !== "user" && role !== "assistant")
-      continue;
-    ordinal++;
-    if (ordinal === lastCompactedOrdinal + 1) {
-      return typeof e.id === "string" && e.id.length > 0 ? e.id : null;
-    }
-  }
-  return null;
+  const rawMessages = convertEntriesToRawMessages(entries);
+  const target = lastCompactedOrdinal + 1;
+  const match = rawMessages.find((m) => m.ordinal === target);
+  if (!match)
+    return null;
+  return match.id.length > 0 ? match.id : null;
 }
 
-// src/read-session-pi.ts
-function readPiSessionMessages(ctx) {
-  const sm = ctx.sessionManager;
-  if (sm === undefined)
-    return [];
-  const getBranch = sm.getBranch;
-  if (typeof getBranch !== "function")
-    return [];
-  let entries;
-  try {
-    entries = getBranch.call(sm);
-  } catch {
-    return [];
+// src/pi-todo-inject.ts
+function getMessageId(message) {
+  if (typeof message.responseId === "string" && message.responseId.length > 0) {
+    return message.responseId;
   }
-  if (!Array.isArray(entries))
-    return [];
-  return convertEntriesToRawMessages(entries);
+  if (typeof message.timestamp === "number") {
+    return `pi-ts-${message.timestamp}`;
+  }
+  return "";
 }
-function convertEntriesToRawMessages(entries) {
-  const result = [];
-  let nextOrdinal = 1;
-  let pendingToolParts = [];
-  for (const entry of entries) {
-    if (!isMessageEntry(entry)) {
-      continue;
-    }
-    const msg = entry.message;
-    const role = msg.role;
-    if (role === "toolResult") {
-      pendingToolParts.push(...synthesizeToolResultParts(msg));
-      continue;
-    }
-    if (role === "user") {
-      const parts = [
-        ...pendingToolParts,
-        ...synthesizeUserParts(msg)
-      ];
-      pendingToolParts = [];
-      result.push({
-        ordinal: nextOrdinal++,
-        id: entry.id,
-        role: "user",
-        parts
-      });
-      continue;
-    }
-    if (role === "assistant") {
-      if (pendingToolParts.length > 0) {
-        result.push({
-          ordinal: nextOrdinal++,
-          id: "",
-          role: "user",
-          parts: pendingToolParts
-        });
-        pendingToolParts = [];
-      }
-      result.push({
-        ordinal: nextOrdinal++,
-        id: entry.id,
-        role: "assistant",
-        parts: synthesizeAssistantParts(msg)
-      });
+function hasToolCallWithId(message, callId) {
+  if (!Array.isArray(message.content))
+    return false;
+  for (const block of message.content) {
+    if (!block || typeof block !== "object")
       continue;
-    }
-    result.push({
-      ordinal: nextOrdinal++,
-      id: entry.id,
-      role: typeof role === "string" ? role : "unknown",
-      parts: []
-    });
+    const t = block.type;
+    const id = block.id;
+    if (t === "toolCall" && id === callId)
+      return true;
   }
-  if (pendingToolParts.length > 0) {
-    result.push({
-      ordinal: nextOrdinal,
-      id: "",
-      role: "user",
-      parts: pendingToolParts
-    });
+  return false;
+}
+function findToolResultAfter(messages, assistantIndex, callId) {
+  for (let i = assistantIndex + 1;i < messages.length; i += 1) {
+    const m = messages[i];
+    if (!m || typeof m !== "object")
+      continue;
+    const role = m.role;
+    const tcId = m.toolCallId;
+    if (role === "toolResult" && tcId === callId)
+      return i;
+    if (role === "assistant")
+      return -1;
   }
-  return result;
+  return -1;
 }
-function isMessageEntry(value) {
-  if (value === null || typeof value !== "object")
-    return false;
-  const v = value;
-  if (v.type !== "message")
-    return false;
-  if (typeof v.id !== "string")
-    return false;
-  if (v.message === null || typeof v.message !== "object")
-    return false;
-  return true;
+function piBlocksFromSynthetic(part) {
+  return {
+    call: {
+      type: "toolCall",
+      id: part.callID,
+      name: part.tool,
+      arguments: { todos: part.state.input.todos },
+      syntheticTodoMarker: true
+    },
+    result: {
+      role: "toolResult",
+      toolCallId: part.callID,
+      toolName: part.tool,
+      content: [{ type: "text", text: part.state.output }],
+      timestamp: 0,
+      syntheticTodoMarker: true
+    }
+  };
 }
-function synthesizeUserParts(msg) {
-  const m = msg;
-  if (typeof m.content === "string") {
-    if (m.content.trim().length === 0)
-      return [];
-    return [{ type: "text", text: m.content }];
-  }
-  if (!Array.isArray(m.content))
-    return [];
-  const parts = [];
-  for (const c of m.content) {
-    if (c === null || typeof c !== "object")
+function injectByAssistantId(messages, messageId, part) {
+  for (let i = 0;i < messages.length; i += 1) {
+    const m = messages[i];
+    if (!m || typeof m !== "object")
       continue;
-    const cc = c;
-    if (cc.type === "text" && typeof cc.text === "string") {
-      parts.push({ type: "text", text: cc.text });
+    if (m.role !== "assistant")
+      continue;
+    const assistant = m;
+    if (getMessageId(assistant) !== messageId)
+      continue;
+    if (hasToolCallWithId(assistant, part.callID)) {
+      if (findToolResultAfter(messages, i, part.callID) >= 0)
+        return true;
+    }
+    const { call, result } = piBlocksFromSynthetic(part);
+    if (!Array.isArray(assistant.content))
+      assistant.content = [];
+    if (!hasToolCallWithId(assistant, part.callID)) {
+      assistant.content.push(call);
+    }
+    if (findToolResultAfter(messages, i, part.callID) < 0) {
+      messages.splice(i + 1, 0, result);
     }
+    return true;
   }
-  return parts;
+  return false;
 }
-function synthesizeAssistantParts(msg) {
-  const m = msg;
-  if (!Array.isArray(m.content))
-    return [];
-  const parts = [];
-  for (const c of m.content) {
-    if (c === null || typeof c !== "object")
+function injectIntoLatestAssistant(messages, part) {
+  for (let i = messages.length - 1;i >= 0; i -= 1) {
+    const m = messages[i];
+    if (!m || typeof m !== "object")
       continue;
-    const cc = c;
-    if (cc.type === "text" && typeof cc.text === "string") {
-      parts.push({ type: "text", text: cc.text });
-    } else if (cc.type === "toolCall" && typeof cc.id === "string") {
-      parts.push({
-        type: "tool",
-        tool: typeof cc.name === "string" ? cc.name : "unknown",
-        callID: cc.id,
-        state: {
-          input: cc.arguments ?? {}
-        }
-      });
+    if (m.role !== "assistant")
+      continue;
+    const assistant = m;
+    const id = getMessageId(assistant);
+    if (id.length === 0)
+      continue;
+    if (hasToolCallWithId(assistant, part.callID)) {
+      if (findToolResultAfter(messages, i, part.callID) >= 0)
+        return id;
+    }
+    const { call, result } = piBlocksFromSynthetic(part);
+    if (!Array.isArray(assistant.content))
+      assistant.content = [];
+    if (!hasToolCallWithId(assistant, part.callID)) {
+      assistant.content.push(call);
+    }
+    if (findToolResultAfter(messages, i, part.callID) < 0) {
+      messages.splice(i + 1, 0, result);
     }
+    return id;
   }
-  return parts;
+  return null;
 }
-function synthesizeToolResultParts(msg) {
-  const m = msg;
-  const callID = typeof m.toolCallId === "string" ? m.toolCallId : "";
-  const tool = typeof m.toolName === "string" ? m.toolName : "unknown";
-  if (!callID)
-    return [];
-  let output = "";
-  if (Array.isArray(m.content)) {
-    const fragments = [];
-    for (const c of m.content) {
-      if (c === null || typeof c !== "object")
-        continue;
-      const cc = c;
-      if (cc.type === "text" && typeof cc.text === "string") {
-        fragments.push(cc.text);
+function injectSyntheticTodowriteForPi(args) {
+  if (args.isSubagent)
+    return args.messages;
+  const persistedAnchor = getPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+  if (args.isCacheBusting) {
+    const part2 = buildSyntheticTodoPart(args.lastTodoState);
+    if (part2 === null) {
+      if (persistedAnchor) {
+        clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
       }
+      return args.messages;
     }
-    output = fragments.join(`
-`);
-  }
-  return [
-    {
-      type: "tool",
-      tool,
-      callID,
-      state: {
-        output
+    if (persistedAnchor && persistedAnchor.callId === part2.callID && injectByAssistantId(args.messages, persistedAnchor.messageId, part2)) {
+      if (persistedAnchor.stateJson.length === 0) {
+        setPersistedTodoSyntheticAnchor(args.db, args.sessionId, persistedAnchor.callId, persistedAnchor.messageId, args.lastTodoState);
       }
+      return args.messages;
     }
-  ];
+    const anchoredMessageId = injectIntoLatestAssistant(args.messages, part2);
+    if (anchoredMessageId) {
+      setPersistedTodoSyntheticAnchor(args.db, args.sessionId, part2.callID, anchoredMessageId, args.lastTodoState);
+    } else if (persistedAnchor) {
+      clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+    }
+    return args.messages;
+  }
+  if (!persistedAnchor || persistedAnchor.stateJson.length === 0) {
+    return args.messages;
+  }
+  const part = buildSyntheticTodoPart(persistedAnchor.stateJson);
+  if (part === null || part.callID !== persistedAnchor.callId) {
+    return args.messages;
+  }
+  injectByAssistantId(args.messages, persistedAnchor.messageId, part);
+  return args.messages;
 }
 
 // src/reasoning-replay-pi.ts
@@ -169546,6 +170218,17 @@ var recentReduceBySession = new Map;
 var liveModelBySession = new Map;
 var toolUsageSinceUserTurn = new Map;
 var latestUserMessageBySession = new Map;
+function resolvePiContextModelKey(ctx) {
+  const model = ctx.model;
+  if (!model)
+    return;
+  if (typeof model.provider !== "string" || model.provider.length === 0) {
+    return;
+  }
+  if (typeof model.id !== "string" || model.id.length === 0)
+    return;
+  return `${model.provider}/${model.id}`;
+}
 function readPiSessionMessageById(ctx, messageId) {
   return readPiSessionMessages(ctx).find((message) => message.id === messageId) ?? null;
 }
@@ -169768,8 +170451,32 @@ function registerPiContextHandler(pi, options) {
       const isFirstContextPassForSession = !firstContextPassSeenBySession.has(sessionId);
       firstContextPassSeenBySession.add(sessionId);
       const piUsage = ctx.getContextUsage?.();
-      let usagePercentage = typeof piUsage?.percent === "number" ? piUsage.percent : 0;
-      const usageInputTokens = typeof piUsage?.tokens === "number" ? piUsage.tokens : 0;
+      const previousModelKey = liveModelBySession.get(sessionId);
+      const currentModelKey = resolvePiContextModelKey(ctx);
+      const modelChanged = previousModelKey !== undefined && currentModelKey !== undefined && previousModelKey !== currentModelKey;
+      if (currentModelKey !== undefined) {
+        liveModelBySession.set(sessionId, currentModelKey);
+      }
+      const sessionMetaForUsage = getOrCreateSessionMeta(options.db, sessionId);
+      if ((isFirstContextPassForSession || modelChanged) && (sessionMetaForUsage.lastContextPercentage > 0 || sessionMetaForUsage.lastInputTokens > 0)) {
+        const reason = isFirstContextPassForSession ? "first pass" : `model switch ${previousModelKey} -> ${currentModelKey}`;
+        sessionLog(sessionId, `pi transform: ${reason} reset — percentage=${sessionMetaForUsage.lastContextPercentage.toFixed(1)}% tokens=${sessionMetaForUsage.lastInputTokens} — clearing stale usage state`);
+        updateSessionMeta(options.db, sessionId, {
+          lastContextPercentage: 0,
+          lastInputTokens: 0
+        });
+        sessionMetaForUsage.lastContextPercentage = 0;
+        sessionMetaForUsage.lastInputTokens = 0;
+      }
+      let usagePercentage = 0;
+      let usageInputTokens = 0;
+      if (sessionMetaForUsage.lastContextPercentage > 0 && sessionMetaForUsage.lastInputTokens > 0) {
+        usagePercentage = sessionMetaForUsage.lastContextPercentage;
+        usageInputTokens = sessionMetaForUsage.lastInputTokens;
+      } else {
+        usagePercentage = typeof piUsage?.percent === "number" ? piUsage.percent : 0;
+        usageInputTokens = typeof piUsage?.tokens === "number" ? piUsage.tokens : 0;
+      }
       let usageContextLimit = typeof piUsage?.contextWindow === "number" && piUsage.contextWindow > 0 ? piUsage.contextWindow : undefined;
       try {
         const overflowState = getOverflowState(options.db, sessionId);
@@ -169783,7 +170490,7 @@ function registerPiContextHandler(pi, options) {
       } catch (err) {
         sessionLog(sessionId, `pi transform: overflow state read failed: ${err instanceof Error ? err.message : String(err)}`);
       }
-      const sessionMeta = getOrCreateSessionMeta(options.db, sessionId);
+      const sessionMeta = sessionMetaForUsage;
       const modelKey = liveModelBySession.get(sessionId);
       let schedulerDecision;
       try {
@@ -169798,6 +170505,29 @@ function registerPiContextHandler(pi, options) {
         schedulerDecision = "execute";
         sessionLog(sessionId, `pi transform: large imported session detected (${piMessageCount} messages, no usage baseline) — forcing execute on first pass`);
       }
+      const schedulerDecisionEarly = schedulerDecision;
+      const midTurn = isMidTurnPi(event, sessionId);
+      const bypassReason = detectMidTurnBypassReason({
+        contextUsage: { percentage: usagePercentage },
+        sessionMeta,
+        historyRefreshSessions,
+        sessionId
+      });
+      const { midTurnAdjustedSchedulerDecision, sideEffect } = applyMidTurnDeferral({
+        base: schedulerDecisionEarly,
+        bypassReason,
+        midTurn
+      });
+      if (sideEffect === "set-flag") {
+        const flagPayload = {
+          id: crypto2.randomUUID(),
+          reason: `${schedulerDecisionEarly}-${bypassReason}`,
+          recordedAt: Date.now()
+        };
+        setDeferredExecutePendingIfAbsent(options.db, sessionId, flagPayload);
+      }
+      schedulerDecision = midTurnAdjustedSchedulerDecision;
+      sessionLog(sessionId, `pi [boundary-exec] base=${schedulerDecisionEarly} bypass=${bypassReason} midTurn=${midTurn} effective=${midTurnAdjustedSchedulerDecision} sideEffect=${sideEffect}`);
       const forceMaterialization = usagePercentage >= FORCE_MATERIALIZATION_PERCENTAGE;
       const isEmergency = usagePercentage >= EMERGENCY_BLOCK_PERCENTAGE;
       if (isEmergency) {
@@ -169812,7 +170542,7 @@ function registerPiContextHandler(pi, options) {
           try {
             await Promise.race([
               histPromise,
-              new Promise((resolve) => setTimeout(resolve, 30000))
+              new Promise((resolve3) => setTimeout(resolve3, 30000))
             ]);
             sessionLog(sessionId, "pi EMERGENCY: historian wait completed (or timed out)");
           } catch {}
@@ -169904,6 +170634,22 @@ function registerPiContextHandler(pi, options) {
           sessionLog(sessionId, `pi auto-search failed: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
+      try {
+        const sessionMetaForTodo = getOrCreateSessionMeta(options.db, sessionId);
+        if (!sessionMetaForTodo.isSubagent && sessionMetaForTodo.lastTodoState !== "") {
+          const isCacheBustingForTodo = isCacheBusting || result.executedWorkThisPass;
+          outputMessages = injectSyntheticTodowriteForPi({
+            db: options.db,
+            sessionId,
+            isSubagent: sessionMetaForTodo.isSubagent,
+            isCacheBusting: isCacheBustingForTodo,
+            lastTodoState: sessionMetaForTodo.lastTodoState,
+            messages: outputMessages
+          });
+        }
+      } catch (err) {
+        sessionLog(sessionId, `pi synthetic todowrite injection failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
       clearLastTransformErrorIfSet(options.db, sessionId);
       return { messages: outputMessages };
     } catch (err) {
@@ -170085,16 +170831,25 @@ function maybeFireHistorian(args) {
   }
   let usage;
   try {
-    const piUsage = ctx.getContextUsage?.();
-    if (!piUsage || piUsage.tokens === null || piUsage.percent === null || piUsage.contextWindow === 0) {
-      sessionLog(sessionId, `pi-historian trigger eval: no usage info yet (tokens=${piUsage?.tokens ?? "<no piUsage>"}, percent=${piUsage?.percent ?? "<no piUsage>"}, contextWindow=${piUsage?.contextWindow ?? "<no piUsage>"})`);
-      return;
+    const sessionMetaForUsage = getOrCreateSessionMeta(db, sessionId);
+    if (sessionMetaForUsage.lastContextPercentage > 0 && sessionMetaForUsage.lastInputTokens > 0) {
+      usage = {
+        percentage: sessionMetaForUsage.lastContextPercentage,
+        inputTokens: sessionMetaForUsage.lastInputTokens
+      };
+      sessionLog(sessionId, `pi-historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens) [from session_meta], checking trigger...`);
+    } else {
+      const piUsage = ctx.getContextUsage?.();
+      if (!piUsage || piUsage.tokens === null || piUsage.percent === null || piUsage.contextWindow === 0) {
+        sessionLog(sessionId, `pi-historian trigger eval: no usage info yet (tokens=${piUsage?.tokens ?? "<no piUsage>"}, percent=${piUsage?.percent ?? "<no piUsage>"}, contextWindow=${piUsage?.contextWindow ?? "<no piUsage>"})`);
+        return;
+      }
+      usage = {
+        percentage: piUsage.percent,
+        inputTokens: piUsage.tokens
+      };
+      sessionLog(sessionId, `pi-historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens) [piUsage fallback], checking trigger...`);
     }
-    usage = {
-      percentage: piUsage.percent,
-      inputTokens: piUsage.tokens
-    };
-    sessionLog(sessionId, `pi-historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens), checking trigger...`);
   } catch (err) {
     sessionLog(sessionId, `pi-historian trigger eval: getContextUsage threw: ${err instanceof Error ? err.message : String(err)}`);
     return;
@@ -170106,6 +170861,11 @@ function maybeFireHistorian(args) {
   let triggered = false;
   try {
     if (isFirstContextPassForSession) {
+      const sessionMeta2 = getOrCreateSessionMeta(db, sessionId);
+      if (sessionMeta2.compartmentInProgress && !inFlightHistorian.has(sessionId)) {
+        updateSessionMeta(db, sessionId, { compartmentInProgress: false });
+        sessionLog(sessionId, "pi-historian: cleared stale compartmentInProgress flag on first context pass after restart");
+      }
       const failureState = getHistorianFailureState(db, sessionId);
       const shouldRecoverOnFirstPass = failureState.failureCount > 0 && hasEligiblePiCompartmentHistory(db, sessionId);
       if (shouldRecoverOnFirstPass) {
@@ -170149,6 +170909,7 @@ Historian previously failed ${failureState.failureCount} time(s), so magic-conte
   }
 }
 async function runPipeline(args) {
+  let executedWorkThisPass = false;
   if (args.temporalAwareness) {
     try {
       const injected = injectPiTemporalMarkers(args.messages);
@@ -170179,9 +170940,15 @@ async function runPipeline(args) {
   }
   const hasPendingMaterializeSignal = hasPendingMaterialization(args.sessionId);
   if (args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal) {
-    applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags);
-    if (hasPendingMaterializeSignal) {
-      consumePendingMaterialization(args.sessionId);
+    try {
+      applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags);
+      executedWorkThisPass = true;
+      if (hasPendingMaterializeSignal) {
+        consumePendingMaterialization(args.sessionId);
+      }
+    } catch (err) {
+      sessionLog(args.sessionId, `pi pending operations failed: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
     }
   }
   const flushedSliceTags = getTagsByNumbers(args.db, args.sessionId, [
@@ -170235,6 +171002,7 @@ async function runPipeline(args) {
         caveman: args.heuristics.caveman
       });
       heuristicsExecuted = true;
+      executedWorkThisPass = true;
     } catch (err) {
       sessionLog(args.sessionId, `pi heuristic cleanup failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -170257,6 +171025,7 @@ async function runPipeline(args) {
           sessionLog(args.sessionId, `pi reasoning cleared on execute: cleared=${clearOutcome.cleared} watermark=${prevWatermark}->${clearOutcome.newWatermark}`);
         }
       }
+      executedWorkThisPass = true;
     } catch (err) {
       sessionLog(args.sessionId, `pi reasoning clearing failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -170279,6 +171048,16 @@ async function runPipeline(args) {
     messages: args.messages,
     isCacheBusting: args.isCacheBusting
   });
+  if (executedWorkThisPass) {
+    try {
+      const currentFlag = peekDeferredExecutePending(args.db, args.sessionId);
+      if (currentFlag !== null) {
+        clearDeferredExecutePendingIfMatches(args.db, args.sessionId, currentFlag);
+      }
+    } catch (err) {
+      sessionLog(args.sessionId, `pi [boundary-exec] drain failed (continuing): ${err}`);
+    }
+  }
   const outputMessages = transcript.getOutputMessages();
   try {
     const counts = tokenizePiMessages(outputMessages);
@@ -170292,6 +171071,7 @@ async function runPipeline(args) {
   return {
     messages: outputMessages,
     heuristicsExecuted,
+    executedWorkThisPass,
     historyInjected: injectionResult?.injected ?? false,
     heuristicsResult,
     injectionResult
@@ -170488,7 +171268,7 @@ init_logger();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { join as join10 } from "node:path";
+import { join as join13 } from "node:path";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 function randomBase62(length) {
   const chars = [];
@@ -170509,7 +171289,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join10(getDataDir(), "opencode", "opencode.db");
+  return join13(getDataDir(), "opencode", "opencode.db");
 }
 var cachedWriteDb = null;
 var REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
@@ -171059,7 +171839,7 @@ async function runCompressorPass2(args) {
     return null;
   } finally {
     if (agentSessionId) {
-      await client.session.delete({ path: { id: agentSessionId }, query: { directory } }).catch((e) => {
+      await client.session.delete({ path: { id: agentSessionId } }).catch((e) => {
         sessionLog(sessionId, "compressor: session cleanup failed:", getErrorMessage(e));
       });
     }
@@ -171068,7 +171848,7 @@ async function runCompressorPass2(args) {
 
 // ../plugin/src/hooks/magic-context/compartment-runner-historian.ts
 import { mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join14 } from "node:path";
 init_magic_context();
 init_data_path();
 function historianResponseDumpDir(directory) {
@@ -171236,7 +172016,7 @@ async function runHistorianPrompt(args) {
     };
   } finally {
     if (agentSessionId) {
-      await client.session.delete({ path: { id: agentSessionId }, query: { directory: sessionDirectory } }).catch((e) => {
+      await client.session.delete({ path: { id: agentSessionId } }).catch((e) => {
         sessionLog(parentSessionId, "compartment agent: session cleanup failed", getErrorMessage(e));
       });
     }
@@ -171301,8 +172081,8 @@ function isTransientHistorianPromptError(message) {
   ].some((token) => normalized.includes(token));
 }
 function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
   });
 }
 function cleanupHistorianDump(sessionId, dumpPath) {
@@ -171323,7 +172103,7 @@ function dumpHistorianResponse(sessionId, directory, label, text) {
     mkdirSync6(dumpDir, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join11(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    const dumpPath = join14(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
     writeFileSync3(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
@@ -172525,11 +173305,11 @@ import {
   matchesKey,
   truncateToWidth,
   visibleWidth
-} from "@mariozechner/pi-tui";
+} from "@earendil-works/pi-tui";
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.19.0",
+  version: "0.20.0",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -172555,7 +173335,7 @@ var package_default = {
     "README.md"
   ],
   scripts: {
-    build: "bun build src/index.ts src/subagent-entry.ts --outdir dist --target node --format esm --external @mariozechner/pi-coding-agent --external @mariozechner/pi-tui --external @huggingface/transformers --external better-sqlite3",
+    build: "bun build src/index.ts src/subagent-entry.ts --outdir dist --target node --format esm --external @earendil-works/pi-coding-agent --external @earendil-works/pi-tui --external @huggingface/transformers --external better-sqlite3",
     typecheck: "tsc --noEmit",
     test: "bun test",
     lint: "biome check src",
@@ -172575,15 +173355,15 @@ var package_default = {
   },
   devDependencies: {
     "@biomejs/biome": "^2.4.7",
-    "@mariozechner/pi-coding-agent": "^0.71.0",
-    "@mariozechner/pi-tui": "^0.71.0",
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@earendil-works/pi-tui": "^0.74.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
     typescript: "^5.8.0"
   },
   peerDependencies: {
-    "@mariozechner/pi-coding-agent": "^0.71.0",
-    "@mariozechner/pi-tui": "^0.71.0"
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@earendil-works/pi-tui": "^0.74.0"
   },
   exports: {
     ".": {
@@ -173066,14 +173846,14 @@ function readHistorianState(db, sessionId, meta3) {
 
 // src/config/index.ts
 init_magic_context();
-import { existsSync as existsSync8, readFileSync as readFileSync3 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join15 } from "node:path";
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync7, readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname4, isAbsolute, resolve } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, isAbsolute, resolve as resolve3 } from "node:path";
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
 var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function substituteConfigVariables(input) {
@@ -173110,17 +173890,17 @@ function substituteConfigVariables(input) {
     }
     let filePath = rawPath.trim();
     if (filePath.startsWith("~/")) {
-      filePath = resolve(homedir3(), filePath.slice(2));
+      filePath = resolve3(homedir4(), filePath.slice(2));
     } else if (!isAbsolute(filePath)) {
-      filePath = resolve(configDir, filePath);
+      filePath = resolve3(configDir, filePath);
     }
-    if (!existsSync7(filePath)) {
+    if (!existsSync9(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
     let contents;
     try {
-      contents = readFileSync2(filePath, "utf-8").trim();
+      contents = readFileSync5(filePath, "utf-8").trim();
     } catch (error51) {
       const message = error51 instanceof Error ? error51.message : String(error51);
       warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
@@ -173133,23 +173913,23 @@ function substituteConfigVariables(input) {
 }
 
 // src/config/index.ts
-var import_comment_json = __toESM(require_src2(), 1);
+var import_comment_json2 = __toESM(require_src2(), 1);
 var CONFIG_FILE_NAME = "magic-context";
 function getProjectConfigPaths(cwd) {
-  const basePath = join12(cwd, ".pi", CONFIG_FILE_NAME);
+  const basePath = join15(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
-  const home = process.env.HOME ?? homedir4();
-  const basePath = join12(home, ".pi", "agent", CONFIG_FILE_NAME);
+  const home = process.env.HOME ?? homedir5();
+  const basePath = join15(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path5) => existsSync8(path5));
+  return paths.find((path5) => existsSync10(path5));
 }
 function loadConfigFile(path5, scope) {
   try {
-    const rawText = readFileSync3(path5, "utf-8");
+    const rawText = readFileSync6(path5, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
       configPath: path5
@@ -173157,7 +173937,7 @@ function loadConfigFile(path5, scope) {
     return {
       path: path5,
       scope,
-      config: import_comment_json.parse(substituted.text),
+      config: import_comment_json2.parse(substituted.text),
       warnings: substituted.warnings.map((warning) => `${path5}: ${warning}`)
     };
   } catch (error51) {
@@ -173271,6 +174051,42 @@ function loadPiConfig(opts = {}) {
   };
 }
 
+// src/pi-pressure.ts
+function extractAssistantUsage(message) {
+  if (!message || typeof message !== "object")
+    return null;
+  const m = message;
+  if (m.role !== "assistant")
+    return null;
+  if (!m.usage || typeof m.usage !== "object")
+    return null;
+  const u = m.usage;
+  const result = {};
+  if (typeof u.input === "number")
+    result.input = u.input;
+  if (typeof u.output === "number")
+    result.output = u.output;
+  if (typeof u.cacheRead === "number")
+    result.cacheRead = u.cacheRead;
+  if (typeof u.cacheWrite === "number")
+    result.cacheWrite = u.cacheWrite;
+  if (typeof u.totalTokens === "number")
+    result.totalTokens = u.totalTokens;
+  return result;
+}
+function computePiPressure(usage, contextLimit) {
+  if (!usage)
+    return null;
+  const input = usage.input ?? 0;
+  const cacheRead = usage.cacheRead ?? 0;
+  const cacheWrite = usage.cacheWrite ?? 0;
+  const inputTokens = input + cacheRead + cacheWrite;
+  if (inputTokens === 0)
+    return null;
+  const percentage = contextLimit > 0 ? inputTokens / contextLimit * 100 : 0;
+  return { inputTokens, percentage };
+}
+
 // src/strip-tag-prefix.ts
 var TAG_PREFIX_REGEX2 = /^(\u00a7\d+\u00a7\s*)+/;
 function stripTagPrefixFromAssistantMessage(message) {
@@ -173296,9 +174112,9 @@ function stripTagPrefixFromAssistantMessage(message) {
 }
 
 // src/system-prompt.ts
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync4, realpathSync } from "node:fs";
-import { join as join13, resolve as resolve2, sep } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
+import { join as join17 } from "node:path";
 
 // ../plugin/src/agents/magic-context-prompt.ts
 function getToolHistoryGuidance(dropToolStructure) {
@@ -173387,23 +174203,146 @@ ${GENERIC_SECTION}
 Prefer many small targeted operations over one large blanket operation. Compress early and often — don't wait for warnings.`;
 }
 
+// ../plugin/src/hooks/magic-context/key-files-block.ts
+import { readFileSync as readFileSync7, realpathSync as realpathSync3 } from "node:fs";
+import { join as join16, sep as sep2 } from "node:path";
+init_logger();
+var cachedKeyFilesBySession = new Map;
+var staleUpdates = new Map;
+function staleKey(update) {
+  return `${update.projectPath}\x00${update.path}\x00${update.generatedAtWitness}\x00${update.staleReason}`;
+}
+function queueStaleUpdate(projectPath, path5, generatedAtWitness, staleReason) {
+  const update = { projectPath, path: path5, generatedAtWitness, staleReason };
+  staleUpdates.set(staleKey(update), update);
+}
+function flushStaleUpdates(db) {
+  if (staleUpdates.size === 0)
+    return 0;
+  const updates = [...staleUpdates.values()];
+  staleUpdates.clear();
+  const stmt = db.prepare(`UPDATE project_key_files
+            SET stale_reason = ?1
+          WHERE project_path = ?2
+            AND path = ?3
+            AND generated_at = ?4
+            AND (stale_reason IS NULL OR stale_reason != ?1)`);
+  let changed = 0;
+  for (const update of updates) {
+    try {
+      changed += stmt.run(update.staleReason, update.projectPath, update.path, update.generatedAtWitness).changes;
+    } catch (error51) {
+      log("[key-files] flushStaleUpdates failed:", error51);
+    }
+  }
+  return changed;
+}
+function clearKeyFilesCacheForSession(sessionId) {
+  cachedKeyFilesBySession.delete(sessionId);
+}
+function isUnderProject(projectPath, absPath) {
+  const root = realpathSync3(projectPath);
+  return absPath.startsWith(root + sep2) || absPath === root;
+}
+function buildKeyFilesBlock(db, projectPath, config2 = { enabled: true, tokenBudget: 1e4 }) {
+  if (!config2.enabled)
+    return null;
+  if (!isAftAvailable())
+    return null;
+  const rows = readCurrentKeyFiles(db, projectPath);
+  if (rows.length === 0)
+    return null;
+  for (const row of rows) {
+    if (row.staleReason !== null)
+      continue;
+    let nextStale = null;
+    let observed = false;
+    try {
+      const absPath = join16(projectPath, row.path);
+      const real = realpathSync3(absPath);
+      if (!isUnderProject(projectPath, real)) {
+        nextStale = "missing";
+        observed = true;
+      } else {
+        const diskHash = sha256(readFileSync7(real));
+        if (diskHash !== row.contentHash)
+          nextStale = "content_drift";
+        observed = true;
+      }
+    } catch (error51) {
+      const code = error51?.code;
+      if (code === "ENOENT" || code === "ELOOP") {
+        nextStale = "missing";
+        observed = true;
+      } else {
+        log(`[key-files] freshness check transient failure: ${row.path}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+      }
+    }
+    if (observed && nextStale !== null) {
+      queueStaleUpdate(row.projectPath, row.path, row.generatedAt, nextStale);
+    }
+  }
+  const blocks = [];
+  let used = 0;
+  for (const row of rows) {
+    if (used + row.localTokenEstimate > config2.tokenBudget)
+      break;
+    blocks.push(`  <key-file path="${escapeXmlAttr(row.path)}">
+${escapeXmlContent(row.content)}
+  </key-file>`);
+    used += row.localTokenEstimate;
+  }
+  if (blocks.length === 0)
+    return null;
+  const rendered = `<key-files>
+${blocks.join(`
+`)}
+</key-files>`;
+  flushStaleUpdates(db);
+  return rendered;
+}
+function readVersionedKeyFiles(args) {
+  const config2 = args.config ?? { enabled: true, tokenBudget: 1e4 };
+  if (args.sessionMeta.isSubagent)
+    return null;
+  if (!config2.enabled)
+    return null;
+  if (!isAftAvailable())
+    return null;
+  const projectPath = resolveProjectPath(args.directory ?? args.sessionMeta.sessionId);
+  if (!projectPath)
+    return null;
+  const currentVersion = getKeyFilesVersion(args.db, projectPath);
+  if (args.sessionId) {
+    const cached2 = cachedKeyFilesBySession.get(args.sessionId);
+    if (cached2 && !args.isCacheBusting && cached2.version === currentVersion) {
+      return cached2.value;
+    }
+  }
+  const value = buildKeyFilesBlock(args.db, projectPath, config2);
+  if (args.sessionId) {
+    cachedKeyFilesBySession.set(args.sessionId, { value, version: currentVersion });
+    if (value)
+      sessionLog(args.sessionId, `loaded key-files block (v${currentVersion}, ${value.length} chars)`);
+  }
+  return value;
+}
+
 // src/system-prompt.ts
 init_logger();
 var PROJECT_DOCS_MARKER = "<project-docs>";
 var USER_PROFILE_MARKER = "<user-profile>";
-var KEY_FILES_MARKER = "<key-files>";
 var stickyDateBySession = new Map;
 var cachedDocsBySession = new Map;
 var cachedUserProfileBySession = new Map;
-var cachedKeyFilesBySession = new Map;
 var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join13(directory, filename);
+    const filePath = join17(directory, filename);
     try {
-      if (existsSync9(filePath)) {
-        const content = readFileSync4(filePath, "utf-8").trim();
+      if (existsSync11(filePath)) {
+        const content = readFileSync8(filePath, "utf-8").trim();
         if (content.length > 0) {
           sections.push(`<${filename}>
 ${content}
@@ -173432,56 +174371,6 @@ function buildUserProfileBlock(db) {
 ${items}
 </user-profile>`;
 }
-function buildKeyFilesBlock(db, sessionId, directory, tokenBudget) {
-  const entries = getKeyFiles(db, sessionId);
-  if (entries.length === 0)
-    return null;
-  const sections = [];
-  const projectRoot = resolve2(directory);
-  let remainingBudgetTokens = tokenBudget;
-  for (const entry of entries) {
-    try {
-      const absPath = resolve2(directory, entry.filePath);
-      if (!absPath.startsWith(projectRoot + sep) && absPath !== projectRoot) {
-        log(`[magic-context-pi] key file path escapes project root, skipping: ${entry.filePath}`);
-        continue;
-      }
-      if (!existsSync9(absPath))
-        continue;
-      let realPath;
-      try {
-        realPath = realpathSync(absPath);
-      } catch {
-        continue;
-      }
-      if (!realPath.startsWith(projectRoot + sep) && realPath !== projectRoot) {
-        log(`[magic-context-pi] key file symlink escapes project root, skipping: ${entry.filePath} → ${realPath}`);
-        continue;
-      }
-      const content = readFileSync4(realPath, "utf-8").trim();
-      if (content.length === 0)
-        continue;
-      const fileTokens = estimateTokens(content);
-      if (fileTokens > remainingBudgetTokens) {
-        log(`[magic-context-pi] key file ${entry.filePath} exceeds remaining budget (${fileTokens} > ${remainingBudgetTokens}), skipping`);
-        continue;
-      }
-      remainingBudgetTokens -= fileTokens;
-      sections.push(`<file path="${escapeXmlAttr(entry.filePath)}">
-${escapeXmlContent(content)}
-</file>`);
-    } catch (error51) {
-      log(`[magic-context-pi] failed to read key file ${entry.filePath}:`, error51);
-    }
-  }
-  if (sections.length === 0)
-    return null;
-  return `${KEY_FILES_MARKER}
-${sections.join(`
-
-`)}
-</key-files>`;
-}
 function buildMagicContextBlock(opts) {
   const sections = [];
   const sessionId = opts.sessionId;
@@ -173509,13 +174398,23 @@ function buildMagicContextBlock(opts) {
       sections.push(profileBlock);
   }
   if (opts.pinKeyFilesEnabled && sessionId) {
-    const keyFilesBlock = readCachedAdjunct({
-      cache: cachedKeyFilesBySession,
+    let sessionMeta = null;
+    try {
+      sessionMeta = getOrCreateSessionMeta(opts.db, sessionId);
+    } catch (error51) {
+      sessionLog(sessionId, "Pi key-files session meta load failed:", error51);
+    }
+    const keyFilesBlock = sessionMeta ? readVersionedKeyFiles({
+      db: opts.db,
       sessionId,
+      sessionMeta,
+      directory: opts.cwd,
       isCacheBusting,
-      compute: () => buildKeyFilesBlock(opts.db, sessionId, opts.cwd, opts.pinKeyFilesTokenBudget ?? 1e4),
-      describe: "key files"
-    });
+      config: {
+        enabled: opts.pinKeyFilesEnabled,
+        tokenBudget: opts.pinKeyFilesTokenBudget ?? 1e4
+      }
+    }) : null;
     if (keyFilesBlock)
       sections.push(keyFilesBlock);
   }
@@ -173580,7 +174479,7 @@ function processSystemPromptForCache(args) {
       sessionLog(sessionId, `system prompt date frozen: real=${liveDate}, using=${stickyDate} (cache-stable pass)`);
     }
   }
-  const currentHash = createHash4("md5").update(frozenPrompt).digest("hex");
+  const currentHash = createHash6("md5").update(frozenPrompt).digest("hex");
   const hashChanged = !isFirstHash && currentHash !== previousHash;
   if (hashChanged) {
     sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${frozenPrompt.length})`);
@@ -173608,7 +174507,7 @@ function clearPiSystemPromptSession(sessionId) {
   stickyDateBySession.delete(sessionId);
   cachedDocsBySession.delete(sessionId);
   cachedUserProfileBySession.delete(sessionId);
-  cachedKeyFilesBySession.delete(sessionId);
+  clearKeyFilesCacheForSession(sessionId);
 }
 
 // ../plugin/src/tools/ctx-expand/constants.ts
@@ -178498,6 +179397,70 @@ function createCtxSearchTool(deps) {
   };
 }
 
+// src/tools/todowrite.ts
+var STATUS_VALUES = [
+  "pending",
+  "in_progress",
+  "completed",
+  "cancelled"
+];
+var PRIORITY_VALUES = ["high", "medium", "low"];
+var TodoItem = exports_typebox.Object({
+  content: exports_typebox.String({ description: "Brief description of the task" }),
+  status: exports_typebox.Union(STATUS_VALUES.map((v) => exports_typebox.Literal(v))),
+  priority: exports_typebox.Optional(exports_typebox.Union(PRIORITY_VALUES.map((v) => exports_typebox.Literal(v)))),
+  id: exports_typebox.Optional(exports_typebox.String({ description: "Optional stable id for the todo" }))
+});
+var TodowriteParams = exports_typebox.Object({
+  todos: exports_typebox.Array(TodoItem, {
+    description: "Replace the current task list with this complete set of todos. Include every task you intend to track this turn — pending, in_progress, completed, or cancelled — because the list overwrites previous state."
+  })
+});
+var TOOL_DESCRIPTION = [
+  "Manage your task list for this session.",
+  "",
+  "Use this tool to plan multi-step work, track in-flight tasks, and",
+  "mark progress as you complete steps. Pass the COMPLETE updated list",
+  "of todos every time — this tool replaces the prior list rather than",
+  "appending to it.",
+  "",
+  "Task states:",
+  "  - pending: not started yet",
+  "  - in_progress: currently working on (limit to ONE task at a time)",
+  "  - completed: finished successfully",
+  "  - cancelled: no longer needed",
+  "",
+  "Use this tool proactively for non-trivial work spanning 3+ steps.",
+  "Skip it for single-shot answers or trivial 1-2 step tasks."
+].join(`
+`);
+function createTodowriteTool() {
+  return {
+    name: "todowrite",
+    label: "Todos",
+    description: TOOL_DESCRIPTION,
+    parameters: TodowriteParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const todos = params.todos ?? [];
+      const completed = todos.filter((t) => t.status === "completed").length;
+      const active = todos.length - completed;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(todos, null, 2)
+          }
+        ],
+        details: {
+          todos,
+          title: `${active} todos`,
+          truncated: false
+        }
+      };
+    }
+  };
+}
+
 // src/tools/index.ts
 function registerMagicContextTools(pi, opts) {
   pi.registerTool(createCtxSearchTool({
@@ -178517,6 +179480,7 @@ function registerMagicContextTools(pi, opts) {
     dreamerEnabled: opts.dreamerEnabled ?? false
   }));
   pi.registerTool(createCtxExpandTool({ db: opts.db }));
+  pi.registerTool(createTodowriteTool());
   if (opts.ctxReduceEnabled === true) {
     pi.registerTool(createCtxReduceTool({
       db: opts.db,
@@ -178631,7 +179595,7 @@ function resolveDreamerFromConfig(config2) {
 }
 async function src_default2(pi) {
   const storageDir = getMagicContextStorageDir();
-  const dbPath = join14(storageDir, "context.db");
+  const dbPath = join18(storageDir, "context.db");
   let db;
   try {
     db = openDatabase();
@@ -178841,9 +179805,17 @@ ${block}` : event.systemPrompt;
       if (event.toolName === "todowrite") {
         const todoArgs = event.args;
         const todos = todoArgs?.todos;
+        const sessionMeta = Array.isArray(todos) ? getOrCreateSessionMeta(db, sessionId) : null;
+        if (sessionMeta && !sessionMeta.isSubagent) {
+          const normalizedTodos = normalizeTodoStateJson(todos);
+          if (normalizedTodos !== null) {
+            updateSessionMeta(db, sessionId, {
+              lastTodoState: normalizedTodos
+            });
+          }
+        }
         if (Array.isArray(todos) && todos.length > 0 && todos.every((t) => t.status === "completed" || t.status === "cancelled")) {
-          const sessionMeta = getOrCreateSessionMeta(db, sessionId);
-          if (!sessionMeta.isSubagent) {
+          if (sessionMeta && !sessionMeta.isSubagent) {
             onNoteTrigger(db, sessionId, "todos_complete");
           }
         }
@@ -178897,14 +179869,62 @@ ${block}` : event.systemPrompt;
         cacheTtlConfig: config2.cache_ttl
       });
       const piUsage = ctx.getContextUsage?.();
-      const updates = { lastResponseTime: Date.now() };
-      if (piUsage && typeof piUsage.percent === "number") {
-        updates.lastContextPercentage = piUsage.percent;
+      const piContextWindow = piUsage && typeof piUsage.contextWindow === "number" ? piUsage.contextWindow : 0;
+      let effectiveContextLimit = piContextWindow;
+      try {
+        const overflowState = getOverflowState(db, sessionId);
+        if (overflowState.detectedContextLimit > 0) {
+          effectiveContextLimit = effectiveContextLimit > 0 ? Math.min(effectiveContextLimit, overflowState.detectedContextLimit) : overflowState.detectedContextLimit;
+        }
+      } catch (err5) {
+        warn("message_end: getOverflowState failed:", err5);
       }
-      if (piUsage && typeof piUsage.tokens === "number") {
+      const usage = extractAssistantUsage(event.message);
+      const pressure = computePiPressure(usage, effectiveContextLimit);
+      const updates = { lastResponseTime: Date.now() };
+      if (pressure) {
+        updates.lastContextPercentage = pressure.percentage;
+        updates.lastInputTokens = pressure.inputTokens;
+      } else if (piUsage && typeof piUsage.tokens === "number") {
         updates.lastInputTokens = piUsage.tokens;
+        if (piUsage.contextWindow > 0) {
+          updates.lastContextPercentage = piUsage.tokens / piUsage.contextWindow * 100;
+        }
       }
       updateSessionMeta(db, sessionId, updates);
+      try {
+        const sessionMetaForTodo = getOrCreateSessionMeta(db, sessionId);
+        if (!sessionMetaForTodo.isSubagent) {
+          const msg = event.message;
+          if (msg && msg.role === "assistant" && Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+              if (!block || typeof block !== "object")
+                continue;
+              const b = block;
+              if (b.type !== "toolCall")
+                continue;
+              if (typeof b.name !== "string")
+                continue;
+              if (!/^todo.*write$|^write.*todo$|^todowrite$/i.test(b.name)) {
+                continue;
+              }
+              const args = b.arguments;
+              const todos = args?.todos;
+              if (!Array.isArray(todos))
+                continue;
+              const normalized = normalizeTodoStateJson(todos);
+              if (normalized === null)
+                continue;
+              updateSessionMeta(db, sessionId, {
+                lastTodoState: normalized
+              });
+              break;
+            }
+          }
+        }
+      } catch (err5) {
+        warn("message_end: synthetic todowrite capture failed:", err5);
+      }
     } catch (err5) {
       warn("message_end: persist session_meta usage failed:", err5);
     }
@@ -178936,7 +179956,7 @@ ${block}` : event.systemPrompt;
     try {
       await Promise.race([
         awaitInFlightHistorians(),
-        new Promise((resolve3) => setTimeout(resolve3, SHUTDOWN_DRAIN_MS))
+        new Promise((resolve4) => setTimeout(resolve4, SHUTDOWN_DRAIN_MS))
       ]);
     } catch (err5) {
       warn("shutdown: historian drain threw:", err5);
@@ -178944,7 +179964,7 @@ ${block}` : event.systemPrompt;
     try {
       await Promise.race([
         awaitInFlightDreamers(),
-        new Promise((resolve3) => setTimeout(resolve3, SHUTDOWN_DRAIN_MS))
+        new Promise((resolve4) => setTimeout(resolve4, SHUTDOWN_DRAIN_MS))
       ]);
     } catch (err5) {
       warn("shutdown: dreamer drain threw:", err5);