@cortexkit/pi-magic-context 0.19.0 → 0.20.0

package/dist/subagent-entry.js

@@ -23808,10 +23808,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join6 = (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 join7 = (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 join6(comment, inside, gap);
+    return join7(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -23833,13 +23833,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join6(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join7(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 += join6(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join7(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) => {
@@ -23860,13 +23860,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join6(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join7(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 += join6(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join7(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) {
@@ -23959,17 +23959,9 @@ var require_src2 = __commonJS((exports, module) => {
 });
 
 // ../plugin/src/hooks/magic-context/read-session-db.ts
-var exports_read_session_db = {};
-__export(exports_read_session_db, {
-  withReadOnlySessionDb: () => withReadOnlySessionDb,
-  getRawSessionMessageCountFromDb: () => getRawSessionMessageCountFromDb,
-  getMessageTimesFromOpenCodeDb: () => getMessageTimesFromOpenCodeDb,
-  findLastAssistantModelFromOpenCodeDb: () => findLastAssistantModelFromOpenCodeDb,
-  closeReadOnlySessionDb: () => closeReadOnlySessionDb
-});
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function getOpenCodeDbPath() {
-  return join7(getDataDir(), "opencode", "opencode.db");
+  return join8(getDataDir(), "opencode", "opencode.db");
 }
 function closeCachedReadOnlyDb() {
   if (!cachedReadOnlyDb) {
@@ -23996,9 +23988,6 @@ function getReadOnlySessionDb() {
 function withReadOnlySessionDb(fn) {
   return fn(getReadOnlySessionDb());
 }
-function closeReadOnlySessionDb() {
-  closeCachedReadOnlyDb();
-}
 function getRawSessionMessageCountFromDb(db, sessionId) {
   const row = db.prepare(`SELECT COUNT(*) as count FROM message WHERE session_id = ?
              AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
@@ -24024,34 +24013,6 @@ function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
   }
   return result;
 }
-function findLastAssistantModelFromOpenCodeDb(sessionId) {
-  try {
-    return withReadOnlySessionDb((db) => {
-      const row = db.prepare(`SELECT json_extract(data, '$.providerID') as providerID,
-                            json_extract(data, '$.modelID') as modelID,
-                            json_extract(data, '$.agent') as agent
-                     FROM message
-                     WHERE session_id = ?
-                       AND json_extract(data, '$.role') = 'assistant'
-                       AND json_extract(data, '$.providerID') IS NOT NULL
-                       AND json_extract(data, '$.modelID') IS NOT NULL
-                     ORDER BY time_created DESC
-                     LIMIT 1`).get(sessionId);
-      if (!row || typeof row.providerID !== "string" || typeof row.modelID !== "string") {
-        return null;
-      }
-      const agent = typeof row.agent === "string" && row.agent.length > 0 ? row.agent : undefined;
-      return {
-        providerID: row.providerID,
-        modelID: row.modelID,
-        ...agent ? { agent } : {}
-      };
-    });
-  } catch (error51) {
-    log("[magic-context] failed to recover live model from OpenCode DB:", error51);
-    return null;
-  }
-}
 var cachedReadOnlyDb = null;
 var init_read_session_db = __esm(async () => {
   init_data_path();
@@ -24064,8 +24025,8 @@ init_embedding();
 
 // ../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 join5 } from "node:path";
+import { copyFileSync, cpSync, existsSync as existsSync4, mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join6 } from "node:path";
 
 // ../plugin/src/shared/error-message.ts
 function getErrorMessage(error51) {
@@ -24147,6 +24108,119 @@ function safeString(value) {
 init_logger();
 await init_sqlite();
 
+// ../plugin/src/features/magic-context/key-files/project-key-files.ts
+init_logger();
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync2, readFileSync, realpathSync } from "node:fs";
+import { join as join4, resolve, sep } from "node:path";
+var MISSING_CONTENT_HASH = "<missing>";
+var ORPHAN_GRACE_MS = 7 * 24 * 60 * 60 * 1000;
+function sha256(input) {
+  return createHash2("sha256").update(input).digest("hex");
+}
+function resolveProjectPath(directory) {
+  if (!directory?.trim())
+    return null;
+  try {
+    return realpathSync(directory);
+  } catch {
+    return resolve(directory);
+  }
+}
+function rowToProjectKeyFile(row) {
+  return {
+    projectPath: String(row.project_path),
+    path: String(row.path),
+    content: String(row.content),
+    contentHash: String(row.content_hash),
+    localTokenEstimate: Number(row.local_token_estimate),
+    generatedAt: Number(row.generated_at),
+    generatedByModel: row.generated_by_model == null ? null : String(row.generated_by_model),
+    generationConfigHash: String(row.generation_config_hash),
+    staleReason: row.stale_reason == null ? null : String(row.stale_reason)
+  };
+}
+function readCurrentKeyFiles(db, projectPath) {
+  const resolvedProjectPath = resolveProjectPath(projectPath) ?? projectPath;
+  const rows = db.prepare(`SELECT project_path, path, content, content_hash, local_token_estimate,
+                    generated_at, generated_by_model, generation_config_hash, stale_reason
+               FROM project_key_files
+              WHERE project_path = ?
+              ORDER BY generated_at DESC, path ASC`).all(resolvedProjectPath);
+  return rows.map(rowToProjectKeyFile);
+}
+function getKeyFilesVersion(db, projectPath) {
+  const resolvedProjectPath = resolveProjectPath(projectPath) ?? projectPath;
+  const row = db.prepare("SELECT version FROM project_key_files_version WHERE project_path = ?").get(resolvedProjectPath);
+  return Number(row?.version ?? 0);
+}
+function bumpKeyFilesVersion(db, projectPath) {
+  const resolvedProjectPath = resolveProjectPath(projectPath) ?? projectPath;
+  db.prepare(`INSERT INTO project_key_files_version (project_path, version)
+         VALUES (?, 1)
+         ON CONFLICT(project_path) DO UPDATE SET version = version + 1`).run(resolvedProjectPath);
+  return getKeyFilesVersion(db, resolvedProjectPath);
+}
+function resolveCommitFiles(projectPath, files) {
+  return files.map((file2) => {
+    try {
+      const disk = readFileSync(join4(projectPath, file2.path));
+      return {
+        ...file2,
+        contentHash: sha256(disk),
+        staleReason: null
+      };
+    } catch {
+      return {
+        ...file2,
+        contentHash: MISSING_CONTENT_HASH,
+        staleReason: "missing"
+      };
+    }
+  });
+}
+function insertResolvedKeyFiles(db, projectPath, files, generatedAt, generatedByModel, generationConfigHash) {
+  const insert = db.prepare(`INSERT INTO project_key_files
+           (project_path, path, content, content_hash, local_token_estimate,
+            generated_at, generated_by_model, generation_config_hash, stale_reason)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+  for (const file2 of files) {
+    insert.run(projectPath, file2.path, file2.content, file2.contentHash, file2.localTokenEstimate, generatedAt, generatedByModel, generationConfigHash, file2.staleReason);
+  }
+}
+function deleteOrphanProjectKeyFiles(db, now = Date.now()) {
+  const cutoff = now - ORPHAN_GRACE_MS;
+  const rows = db.prepare(`SELECT project_path AS projectPath, MAX(generated_at) AS lastGen
+               FROM project_key_files
+              GROUP BY project_path
+             HAVING lastGen < ?`).all(cutoff);
+  let deletedProjects = 0;
+  for (const row of rows) {
+    if (existsSync2(row.projectPath))
+      continue;
+    try {
+      db.prepare("DELETE FROM project_key_files WHERE project_path = ?").run(row.projectPath);
+      db.prepare("DELETE FROM project_key_files_version WHERE project_path = ?").run(row.projectPath);
+      deletedProjects++;
+    } catch (error51) {
+      log(`[key-files] orphan GC failed for ${row.projectPath}:`, error51);
+    }
+  }
+  return deletedProjects;
+}
+function isRelativeProjectFile(projectPath, relativePath) {
+  if (!relativePath || relativePath.startsWith("/") || relativePath.includes(".."))
+    return false;
+  try {
+    const root = realpathSync(projectPath);
+    const absPath = resolve(projectPath, relativePath);
+    const real = realpathSync(absPath);
+    return real.startsWith(root + sep) || real === root;
+  } catch {
+    return false;
+  }
+}
+
 // ../plugin/src/features/magic-context/migrations.ts
 init_logger();
 var MIGRATIONS = [
@@ -24447,6 +24521,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) {
@@ -157162,12 +157276,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 join4 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join5 } from "node:path";
 var LEASE_DURATION_MS = 5 * 60 * 1000;
 var LEASE_RENEWAL_MS = 60 * 1000;
 function resolveOpencodeDbPath() {
-  return join4(getDataDir(), "opencode", "opencode.db");
+  return join5(getDataDir(), "opencode", "opencode.db");
 }
 function ensureBackfillStateTable(db) {
   db.exec(`
@@ -157202,7 +157316,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync2(opencodeDbPath)) {
+  if (!existsSync3(opencodeDbPath)) {
     log(`[backfill] OpenCode DB not found at ${opencodeDbPath} — marking all unbackfilled sessions as skipped. Lazy adoption (defense-in-depth) handles legacy rows at runtime.`);
     markAllUnbackfilledSessionsSkipped(db);
     result.sessionsSkippedNoOcDb = countSessionsByStatus(db, "skipped");
@@ -157410,21 +157524,21 @@ var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join5(dbDir, "context.db") };
+  return { dbDir, dbPath: join6(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync3(targetDbPath))
+  if (existsSync4(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join5(legacyDir, "context.db");
-  if (!existsSync3(legacyDbPath))
+  const legacyDbPath = join6(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 = join5(targetDbDir, `context.db${suffix}`);
-    if (existsSync3(src)) {
+    const dst = join6(targetDbDir, `context.db${suffix}`);
+    if (existsSync4(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error51) {
@@ -157432,9 +157546,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join5(legacyDir, "models");
-  const targetModelsDir = join5(targetDbDir, "models");
-  if (existsSync3(legacyModelsDir) && !existsSync3(targetModelsDir)) {
+  const legacyModelsDir = join6(legacyDir, "models");
+  const targetModelsDir = join6(targetDbDir, "models");
+  if (existsSync4(legacyModelsDir) && !existsSync4(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error51) {
@@ -157582,6 +157696,26 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     );
     CREATE INDEX IF NOT EXISTS idx_dream_runs_project ON dream_runs(project_path, finished_at DESC);
 
+    CREATE TABLE IF NOT EXISTS project_key_files (
+      project_path           TEXT    NOT NULL,
+      path                   TEXT    NOT NULL,
+      content                TEXT    NOT NULL,
+      content_hash           TEXT    NOT NULL,
+      local_token_estimate   INTEGER NOT NULL,
+      generated_at           INTEGER NOT NULL,
+      generated_by_model     TEXT,
+      generation_config_hash TEXT    NOT NULL,
+      stale_reason           TEXT,
+      PRIMARY KEY (project_path, path)
+    );
+    CREATE INDEX IF NOT EXISTS idx_project_key_files_project ON project_key_files(project_path);
+    CREATE INDEX IF NOT EXISTS idx_project_key_files_generated_at ON project_key_files(project_path, generated_at);
+
+    CREATE TABLE IF NOT EXISTS project_key_files_version (
+      project_path TEXT    PRIMARY KEY,
+      version      INTEGER NOT NULL DEFAULT 0
+    );
+
     -- (smart_notes: see note above; merged into unified notes table by migration v1)
 
     CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
@@ -157659,7 +157793,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);
@@ -157748,6 +157886,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'");
@@ -157824,7 +157963,15 @@ function ensureColumn(db, table, column, definition) {
   if (rows.some((row) => row.name === column)) {
     return;
   }
-  db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  try {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  } catch (err) {
+    const recheck = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (recheck.some((row) => row.name === column)) {
+      return;
+    }
+    throw err;
+  }
 }
 function openDatabase() {
   const { dbDir, dbPath } = resolveDatabasePath();
@@ -157841,6 +157988,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) {
@@ -157864,14 +158016,14 @@ init_logger();
 
 // src/config/index.ts
 init_magic_context();
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync4, readFileSync } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, isAbsolute, resolve } from "node:path";
+import { dirname as dirname3, isAbsolute, resolve as resolve2 } from "node:path";
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
 var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function substituteConfigVariables(input) {
@@ -157908,17 +158060,17 @@ function substituteConfigVariables(input) {
     }
     let filePath = rawPath.trim();
     if (filePath.startsWith("~/")) {
-      filePath = resolve(homedir2(), filePath.slice(2));
+      filePath = resolve2(homedir2(), filePath.slice(2));
     } else if (!isAbsolute(filePath)) {
-      filePath = resolve(configDir, filePath);
+      filePath = resolve2(configDir, filePath);
     }
-    if (!existsSync4(filePath)) {
+    if (!existsSync5(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
     let contents;
     try {
-      contents = readFileSync(filePath, "utf-8").trim();
+      contents = readFileSync2(filePath, "utf-8").trim();
     } catch (error51) {
       const message = error51 instanceof Error ? error51.message : String(error51);
       warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
@@ -157934,20 +158086,20 @@ function substituteConfigVariables(input) {
 var import_comment_json = __toESM(require_src2(), 1);
 var CONFIG_FILE_NAME = "magic-context";
 function getProjectConfigPaths(cwd) {
-  const basePath = join6(cwd, ".pi", CONFIG_FILE_NAME);
+  const basePath = join7(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
   const home = process.env.HOME ?? homedir3();
-  const basePath = join6(home, ".pi", "agent", CONFIG_FILE_NAME);
+  const basePath = join7(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path4) => existsSync5(path4));
+  return paths.find((path4) => existsSync6(path4));
 }
 function loadConfigFile(path4, scope) {
   try {
-    const rawText = readFileSync2(path4, "utf-8");
+    const rawText = readFileSync3(path4, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
       configPath: path4
@@ -162556,6 +162708,61 @@ __export(exports_typebox, {
   Any: () => Any
 });
 // src/read-session-pi.ts
+function isMidTurnPi(event, _sessionId) {
+  const messages = event?.messages;
+  if (!Array.isArray(messages))
+    return false;
+  let latestAssistantIndex = -1;
+  let latestAssistant = null;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg !== null && typeof msg === "object") {
+      const record4 = msg;
+      if (record4.role === "assistant") {
+        latestAssistantIndex = i;
+        latestAssistant = record4;
+        break;
+      }
+    }
+  }
+  if (latestAssistant === null)
+    return false;
+  if (latestAssistant.stopReason === "toolUse")
+    return true;
+  const toolCallIds = getToolCallIds(latestAssistant.content);
+  if (toolCallIds.size === 0)
+    return false;
+  const pairedToolResultIds = new Set;
+  for (const msg of messages.slice(latestAssistantIndex + 1)) {
+    if (msg === null || typeof msg !== "object")
+      continue;
+    const record4 = msg;
+    if (record4.role !== "toolResult")
+      continue;
+    if (typeof record4.toolCallId === "string") {
+      pairedToolResultIds.add(record4.toolCallId);
+    }
+  }
+  for (const id of toolCallIds) {
+    if (!pairedToolResultIds.has(id))
+      return true;
+  }
+  return false;
+}
+function getToolCallIds(content) {
+  const ids = new Set;
+  if (!Array.isArray(content))
+    return ids;
+  for (const item of content) {
+    if (item === null || typeof item !== "object")
+      continue;
+    const record4 = item;
+    if (record4.type === "toolCall" && typeof record4.id === "string") {
+      ids.add(record4.id);
+    }
+  }
+  return ids;
+}
 function readPiSessionMessages(ctx) {
   const sm = ctx.sessionManager;
   if (sm === undefined)
@@ -162577,6 +162784,7 @@ function convertEntriesToRawMessages(entries) {
   const result = [];
   let nextOrdinal = 1;
   let pendingToolParts = [];
+  let pendingFirstRealId = "";
   for (const entry of entries) {
     if (!isMessageEntry(entry)) {
       continue;
@@ -162585,6 +162793,9 @@ function convertEntriesToRawMessages(entries) {
     const role = msg.role;
     if (role === "toolResult") {
       pendingToolParts.push(...synthesizeToolResultParts(msg));
+      if (pendingFirstRealId === "") {
+        pendingFirstRealId = entry.id;
+      }
       continue;
     }
     if (role === "user") {
@@ -162593,6 +162804,7 @@ function convertEntriesToRawMessages(entries) {
         ...synthesizeUserParts(msg)
       ];
       pendingToolParts = [];
+      pendingFirstRealId = "";
       result.push({
         ordinal: nextOrdinal++,
         id: entry.id,
@@ -162605,11 +162817,12 @@ function convertEntriesToRawMessages(entries) {
       if (pendingToolParts.length > 0) {
         result.push({
           ordinal: nextOrdinal++,
-          id: "",
+          id: pendingFirstRealId,
           role: "user",
           parts: pendingToolParts
         });
         pendingToolParts = [];
+        pendingFirstRealId = "";
       }
       result.push({
         ordinal: nextOrdinal++,
@@ -162629,7 +162842,7 @@ function convertEntriesToRawMessages(entries) {
   if (pendingToolParts.length > 0) {
     result.push({
       ordinal: nextOrdinal,
-      id: "",
+      id: pendingFirstRealId,
       role: "user",
       parts: pendingToolParts
     });
@@ -163130,7 +163343,7 @@ init_normalize_hash();
 
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execSync } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import path4 from "node:path";
 var GIT_TIMEOUT_MS = 5000;
 var resolvedCache = new Map;
@@ -163151,7 +163364,7 @@ function getRootCommitHash(directory) {
 }
 function directoryFallback(directory) {
   const canonical = path4.resolve(directory);
-  const hash2 = createHash2("md5").update(canonical).digest("hex").slice(0, 12);
+  const hash2 = createHash3("md5").update(canonical).digest("hex").slice(0, 12);
   return `dir:${hash2}`;
 }
 function resolveProjectIdentity(directory) {
@@ -164216,6 +164429,12 @@ function isPersistedNoteNudgeRow(row) {
   const r = row;
   return typeof r.note_nudge_trigger_pending === "number" && typeof r.note_nudge_trigger_message_id === "string" && typeof r.note_nudge_sticky_text === "string" && typeof r.note_nudge_sticky_message_id === "string";
 }
+function isPersistedTodoSyntheticAnchorRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.todo_synthetic_call_id === "string" && typeof r.todo_synthetic_anchor_message_id === "string" && typeof r.todo_synthetic_state_json === "string";
+}
 function isPersistedHistorianFailureRow(row) {
   if (row === null || typeof row !== "object")
     return false;
@@ -164292,6 +164511,29 @@ function setPersistedDeliveredNoteNudge(db, sessionId, text, messageId = "") {
 function clearPersistedNoteNudge(db, sessionId) {
   db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 0, note_nudge_trigger_message_id = '', note_nudge_sticky_text = '', note_nudge_sticky_message_id = '' WHERE session_id = ?").run(sessionId);
 }
+function getPersistedTodoSyntheticAnchor(db, sessionId) {
+  const result = db.prepare("SELECT todo_synthetic_call_id, todo_synthetic_anchor_message_id, todo_synthetic_state_json FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!isPersistedTodoSyntheticAnchorRow(result)) {
+    return null;
+  }
+  if (result.todo_synthetic_call_id.length === 0 || result.todo_synthetic_anchor_message_id.length === 0) {
+    return null;
+  }
+  return {
+    callId: result.todo_synthetic_call_id,
+    messageId: result.todo_synthetic_anchor_message_id,
+    stateJson: result.todo_synthetic_state_json
+  };
+}
+function setPersistedTodoSyntheticAnchor(db, sessionId, callId, messageId, stateJson) {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET todo_synthetic_call_id = ?, todo_synthetic_anchor_message_id = ?, todo_synthetic_state_json = ? WHERE session_id = ?").run(callId, messageId, stateJson, sessionId);
+  })();
+}
+function clearPersistedTodoSyntheticAnchor(db, sessionId) {
+  db.prepare("UPDATE session_meta SET todo_synthetic_call_id = '', todo_synthetic_anchor_message_id = '', todo_synthetic_state_json = '' WHERE session_id = ?").run(sessionId);
+}
 function getNoteLastReadAt(db, sessionId) {
   try {
     const result = db.prepare("SELECT note_last_read_at FROM session_meta WHERE session_id = ?").get(sessionId);
@@ -164418,6 +164660,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();
@@ -166590,6 +166856,70 @@ function createCtxSearchTool(deps) {
   };
 }
 
+// src/tools/todowrite.ts
+var STATUS_VALUES = [
+  "pending",
+  "in_progress",
+  "completed",
+  "cancelled"
+];
+var PRIORITY_VALUES = ["high", "medium", "low"];
+var TodoItem = exports_typebox.Object({
+  content: exports_typebox.String({ description: "Brief description of the task" }),
+  status: exports_typebox.Union(STATUS_VALUES.map((v) => exports_typebox.Literal(v))),
+  priority: exports_typebox.Optional(exports_typebox.Union(PRIORITY_VALUES.map((v) => exports_typebox.Literal(v)))),
+  id: exports_typebox.Optional(exports_typebox.String({ description: "Optional stable id for the todo" }))
+});
+var TodowriteParams = exports_typebox.Object({
+  todos: exports_typebox.Array(TodoItem, {
+    description: "Replace the current task list with this complete set of todos. Include every task you intend to track this turn — pending, in_progress, completed, or cancelled — because the list overwrites previous state."
+  })
+});
+var TOOL_DESCRIPTION = [
+  "Manage your task list for this session.",
+  "",
+  "Use this tool to plan multi-step work, track in-flight tasks, and",
+  "mark progress as you complete steps. Pass the COMPLETE updated list",
+  "of todos every time — this tool replaces the prior list rather than",
+  "appending to it.",
+  "",
+  "Task states:",
+  "  - pending: not started yet",
+  "  - in_progress: currently working on (limit to ONE task at a time)",
+  "  - completed: finished successfully",
+  "  - cancelled: no longer needed",
+  "",
+  "Use this tool proactively for non-trivial work spanning 3+ steps.",
+  "Skip it for single-shot answers or trivial 1-2 step tasks."
+].join(`
+`);
+function createTodowriteTool() {
+  return {
+    name: "todowrite",
+    label: "Todos",
+    description: TOOL_DESCRIPTION,
+    parameters: TodowriteParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const todos = params.todos ?? [];
+      const completed = todos.filter((t) => t.status === "completed").length;
+      const active = todos.length - completed;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(todos, null, 2)
+          }
+        ],
+        details: {
+          todos,
+          title: `${active} todos`,
+          truncated: false
+        }
+      };
+    }
+  };
+}
+
 // src/tools/index.ts
 function registerMagicContextTools(pi, opts) {
   pi.registerTool(createCtxSearchTool({
@@ -166609,6 +166939,7 @@ function registerMagicContextTools(pi, opts) {
     dreamerEnabled: opts.dreamerEnabled ?? false
   }));
   pi.registerTool(createCtxExpandTool({ db: opts.db }));
+  pi.registerTool(createTodowriteTool());
   if (opts.ctxReduceEnabled === true) {
     pi.registerTool(createCtxReduceTool({
       db: opts.db,