@autohq/cli 0.1.418 → 0.1.419

package/dist/index.js

@@ -1159,8 +1159,8 @@ var init_regexes = __esm({
     _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
     ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
     ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-    mac = (delimiter) => {
-      const escapedDelim = escapeRegex(delimiter ?? ":");
+    mac = (delimiter2) => {
+      const escapedDelim = escapeRegex(delimiter2 ?? ":");
       return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
     };
     cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
@@ -36173,15 +36173,15 @@ async function* readSseEvents(body) {
         break;
       }
       buffer += decoder.decode(value, { stream: true });
-      let delimiter = buffer.indexOf("\n\n");
-      while (delimiter !== -1) {
-        const rawEvent = buffer.slice(0, delimiter);
-        buffer = buffer.slice(delimiter + 2);
+      let delimiter2 = buffer.indexOf("\n\n");
+      while (delimiter2 !== -1) {
+        const rawEvent = buffer.slice(0, delimiter2);
+        buffer = buffer.slice(delimiter2 + 2);
         const event2 = parseSseEvent(rawEvent);
         if (event2) {
           yield event2;
         }
-        delimiter = buffer.indexOf("\n\n");
+        delimiter2 = buffer.indexOf("\n\n");
       }
     }
     buffer += decoder.decode();
@@ -38670,7 +38670,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.418",
+      version: "0.1.419",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -38735,13 +38735,13 @@ var init_version = __esm({
 });
 
 // src/commands/agents/authoring.ts
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync } from "fs";
+import { readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import {
   basename as basename2,
-  dirname as dirname5,
+  dirname as dirname7,
   extname,
   isAbsolute,
-  join as join5,
+  join as join6,
   resolve
 } from "path";
 import { parseAllDocuments as parseYamlDocuments, stringify } from "yaml";
@@ -38793,8 +38793,8 @@ function renderAgentExplain(result) {
   return lines.join("\n");
 }
 function readLocalAgentAuthoringStatuses(input) {
-  const agentsDirectory = join5(
-    input?.directory ?? join5(process.cwd(), ".auto"),
+  const agentsDirectory = join6(
+    input?.directory ?? join6(process.cwd(), ".auto"),
     "agents"
   );
   const paths = agentAuthoringFiles(agentsDirectory);
@@ -38833,7 +38833,7 @@ function agentAuthoringFiles(directory) {
   }
   const files = [];
   for (const entry of entries) {
-    const path2 = join5(directory, entry.name);
+    const path2 = join6(directory, entry.name);
     if (entry.isDirectory()) {
       files.push(...agentAuthoringFiles(path2));
       continue;
@@ -38853,12 +38853,12 @@ function resolveAgentAuthoringPath(input) {
   if (isAgentFile(candidate)) {
     return candidate;
   }
-  const agentsDirectory = join5(
-    input.directory ?? join5(process.cwd(), ".auto"),
+  const agentsDirectory = join6(
+    input.directory ?? join6(process.cwd(), ".auto"),
     "agents"
   );
   for (const extension of AGENT_FILE_EXTENSIONS) {
-    const path2 = join5(agentsDirectory, `${input.agent}${extension}`);
+    const path2 = join6(agentsDirectory, `${input.agent}${extension}`);
     if (isAgentFile(path2)) {
       return path2;
     }
@@ -38916,7 +38916,7 @@ function readSingleDocument(path2) {
   return documents[0];
 }
 function readDocuments(path2) {
-  const source = readFileSync4(path2, "utf8");
+  const source = readFileSync6(path2, "utf8");
   const documents = parseYamlDocuments(source);
   const parseError = documents.flatMap((document) => document.errors).at(0);
   if (parseError) {
@@ -38941,7 +38941,7 @@ function resolveImportPath(importPath, importerPath) {
   if (isAbsolute(importPath) || /^[A-Za-z]+:\/\//.test(importPath)) {
     throw new Error(`Agent import must be a relative path: ${importPath}`);
   }
-  const resolved = resolve(dirname5(importerPath), importPath);
+  const resolved = resolve(dirname7(importerPath), importPath);
   if (!isAgentFile(resolved)) {
     throw new Error(
       `Agent import not found: ${importPath} from ${importerPath}`
@@ -39116,7 +39116,7 @@ function resolveFileBackedString(value, input) {
       `Invalid agent authoring file ${input.path}: ${input.field}.file must be a relative path`
     );
   }
-  return readFileSync4(resolve(dirname5(input.path), filePath), "utf8");
+  return readFileSync6(resolve(dirname7(input.path), filePath), "utf8");
 }
 function removalDirectives(document, path2) {
   const raw = isRecord(document.remove) ? document.remove : {};
@@ -39267,7 +39267,7 @@ function importedEdgeCount(graph) {
 }
 function isAgentFile(path2) {
   try {
-    return statSync(path2).isFile();
+    return statSync2(path2).isFile();
   } catch {
     return false;
   }
@@ -41625,18 +41625,18 @@ var init_project_apply_files2 = __esm({
 
 // src/commands/apply/files.ts
 import {
-  existsSync as existsSync4,
-  readFileSync as readFileSync5,
+  existsSync as existsSync6,
+  readFileSync as readFileSync7,
   readdirSync as readdirSync3,
-  realpathSync,
-  statSync as statSync2
+  realpathSync as realpathSync2,
+  statSync as statSync3
 } from "fs";
 import {
   basename as basename3,
-  dirname as dirname6,
+  dirname as dirname8,
   extname as extname3,
   isAbsolute as isAbsolute2,
-  join as join7,
+  join as join8,
   relative,
   resolve as resolve2
 } from "path";
@@ -41667,7 +41667,7 @@ function readProjectApplyBundleInput(options) {
       }
     };
   }
-  const directory = resolve2(options.directory ?? join7(process.cwd(), ".auto"));
+  const directory = resolve2(options.directory ?? join8(process.cwd(), ".auto"));
   const projectRoot = applyProjectRoot(directory);
   const files = withManagedTemplateFiles(sourceFiles(directory, projectRoot));
   const resourceRoot = sourcePathRelative(projectRoot, directory);
@@ -41704,7 +41704,7 @@ function sourceFiles(root, projectRoot) {
     return [];
   }
   return entries.flatMap((entry) => {
-    const path2 = join7(root, entry.name);
+    const path2 = join8(root, entry.name);
     if (entry.isDirectory()) {
       return sourceFiles(path2, projectRoot);
     }
@@ -41717,7 +41717,7 @@ function sourceFiles(root, projectRoot) {
 function sourceFile(path2, projectRoot) {
   return {
     path: sourcePathRelative(projectRoot, path2),
-    contentBase64: readFileSync5(path2).toString("base64")
+    contentBase64: readFileSync7(path2).toString("base64")
   };
 }
 function applyBundle(files) {
@@ -41758,24 +41758,24 @@ function filesystemAssetReader(projectRoot) {
     }
     return {
       path: path2,
-      bytes: readFileSync5(path2)
+      bytes: readFileSync7(path2)
     };
   };
 }
 function applyProjectRoot(directory) {
   const resolved = resolve2(directory);
-  return basename3(resolved) === ".auto" ? dirname6(resolved) : resolved;
+  return basename3(resolved) === ".auto" ? dirname8(resolved) : resolved;
 }
 function applyFileProjectRoot(file2) {
-  let dir = dirname6(resolve2(file2));
+  let dir = dirname8(resolve2(file2));
   while (true) {
     if (basename3(dir) === ".auto") {
-      return dirname6(dir);
+      return dirname8(dir);
     }
     if (directoryHasAutoRoot(dir)) {
       return dir;
     }
-    const parent = dirname6(dir);
+    const parent = dirname8(dir);
     if (parent === dir) {
       return process.cwd();
     }
@@ -41784,14 +41784,14 @@ function applyFileProjectRoot(file2) {
 }
 function applyFileSourceRoot(file2, projectRoot) {
   const autoRoot = resolve2(projectRoot, ".auto");
-  return file2 === autoRoot || isInside(file2, autoRoot) ? autoRoot : dirname6(file2);
+  return file2 === autoRoot || isInside(file2, autoRoot) ? autoRoot : dirname8(file2);
 }
 function directoryHasAutoRoot(directory) {
   const autoRoot = resolve2(directory, ".auto");
-  if (!existsSync4(autoRoot)) {
+  if (!existsSync6(autoRoot)) {
     return false;
   }
-  return statSync2(autoRoot).isDirectory();
+  return statSync3(autoRoot).isDirectory();
 }
 function displayResourceRoot(directory) {
   return basename3(directory) === ".auto" ? ".auto" : directory;
@@ -41814,11 +41814,11 @@ function validateAgentAvatarAsset(input) {
       `Invalid identity avatar asset for "${input.resourceName}": asset path must be under .auto/assets`
     );
   }
-  const projectRoot = realpathSync(input.projectRoot);
+  const projectRoot = realpathSync2(input.projectRoot);
   const assetPath = resolve2(projectRoot, input.asset);
   let assetsRoot;
   try {
-    assetsRoot = realpathSync(resolve2(projectRoot, ".auto", "assets"));
+    assetsRoot = realpathSync2(resolve2(projectRoot, ".auto", "assets"));
   } catch {
     if (input.allowMissing) {
       return null;
@@ -41830,8 +41830,8 @@ function validateAgentAvatarAsset(input) {
   let resolvedAssetPath;
   let stat;
   try {
-    resolvedAssetPath = realpathSync(assetPath);
-    stat = statSync2(resolvedAssetPath);
+    resolvedAssetPath = realpathSync2(assetPath);
+    stat = statSync3(resolvedAssetPath);
   } catch {
     if (input.allowMissing) {
       return null;
@@ -42396,14 +42396,14 @@ var init_resources3 = __esm({
 // src/commands/edit/actions.ts
 import { spawn as spawn3 } from "child_process";
 import {
-  mkdirSync as mkdirSync5,
-  mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync6,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync6
+  mkdirSync as mkdirSync6,
+  mkdtempSync as mkdtempSync3,
+  readFileSync as readFileSync8,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync8
 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join8 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join9 } from "path";
 import { parseAllDocuments as parseYamlDocuments3, stringify as stringify4 } from "yaml";
 async function editResource(input) {
   const reference = parseProjectResourceReference(input.resource);
@@ -42423,15 +42423,15 @@ async function editResource(input) {
   const document = editableAgentFacade(current);
   const source = `${stringify4(document).trimEnd()}
 `;
-  const tempRoot = mkdtempSync2(join8(tmpdir2(), "auto-edit-"));
-  const agentsDir = join8(tempRoot, ".auto", "agents");
-  mkdirSync5(agentsDir, { recursive: true });
-  const filePath = join8(agentsDir, `${reference.name}.yaml`);
-  writeFileSync6(filePath, source, "utf8");
+  const tempRoot = mkdtempSync3(join9(tmpdir3(), "auto-edit-"));
+  const agentsDir = join9(tempRoot, ".auto", "agents");
+  mkdirSync6(agentsDir, { recursive: true });
+  const filePath = join9(agentsDir, `${reference.name}.yaml`);
+  writeFileSync8(filePath, source, "utf8");
   let removeTempFile = false;
   try {
     await runEditor(editor, filePath);
-    const editedSource = readFileSync6(filePath, "utf8");
+    const editedSource = readFileSync8(filePath, "utf8");
     if (editedSource === source) {
       input.writeOutput("No changes; skipped apply.");
       removeTempFile = true;
@@ -42458,7 +42458,7 @@ async function editResource(input) {
 Edited file retained at ${filePath}`);
   } finally {
     if (removeTempFile) {
-      rmSync2(tempRoot, { recursive: true, force: true });
+      rmSync3(tempRoot, { recursive: true, force: true });
     }
   }
 }
@@ -42497,7 +42497,7 @@ async function runEditor(editor, filePath) {
   });
 }
 function assertEditedResourceIdentity(filePath, expected) {
-  const source = readFileSync6(filePath, "utf8");
+  const source = readFileSync8(filePath, "utf8");
   let parsedDocuments;
   try {
     parsedDocuments = parseYamlDocuments3(source);
@@ -47986,8 +47986,8 @@ __export(launcher_exports, {
   launch: () => launch
 });
 import { spawnSync } from "child_process";
-import { existsSync as existsSync6 } from "fs";
-import { dirname as dirname7, resolve as resolve3 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { dirname as dirname9, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 import {
   QueryClient,
@@ -48167,7 +48167,7 @@ function resolveSplashVersion() {
   return resolveLatestReleaseVersionFromCheckout() ?? cliVersion;
 }
 function resolveLatestReleaseVersionFromCheckout() {
-  const repoRoot = findRepoRoot(dirname7(fileURLToPath(import.meta.url)));
+  const repoRoot = findRepoRoot(dirname9(fileURLToPath(import.meta.url)));
   if (!repoRoot) {
     return null;
   }
@@ -48184,10 +48184,10 @@ function resolveLatestReleaseVersionFromCheckout() {
 function findRepoRoot(startDirectory) {
   let directory = startDirectory;
   while (true) {
-    if (existsSync6(resolve3(directory, ".git")) && existsSync6(resolve3(directory, "apps/cli/package.json"))) {
+    if (existsSync8(resolve3(directory, ".git")) && existsSync8(resolve3(directory, "apps/cli/package.json"))) {
       return directory;
     }
-    const parent = dirname7(directory);
+    const parent = dirname9(directory);
     if (parent === directory) {
       return null;
     }
@@ -51999,6 +51999,233 @@ function uiChunk(chunk) {
   };
 }
 
+// src/commands/agent-bridge/harness/claude-code/read-state.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  statSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { dirname as dirname4 } from "path";
+
+// src/commands/agent-bridge/harness/claude-code/resume-store.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3 } from "path";
+var AGENT_BRIDGE_RUNTIME_DIR = "/tmp/auto-bridge-runtime";
+var CLAUDE_SESSION_RESUME_PATH = `${AGENT_BRIDGE_RUNTIME_DIR}/claude-session-id`;
+function fileClaudeSessionResumeStore(path2 = CLAUDE_SESSION_RESUME_PATH) {
+  return {
+    read(sessionId) {
+      if (!existsSync(path2)) {
+        return null;
+      }
+      const record2 = parseResumeRecord(readFileSync2(path2, "utf8"));
+      if (!record2 || record2.sessionId !== sessionId) {
+        return null;
+      }
+      return record2.agentId;
+    },
+    write(record2) {
+      mkdirSync2(dirname3(path2), { recursive: true });
+      writeFileSync2(path2, `${JSON.stringify(record2)}
+`, "utf8");
+    }
+  };
+}
+function parseResumeRecord(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (value !== null && typeof value === "object" && "sessionId" in value && "agentId" in value && typeof value.sessionId === "string" && typeof value.agentId === "string" && value.agentId.length > 0) {
+      return { sessionId: value.sessionId, agentId: value.agentId };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/agent-bridge/harness/claude-code/read-state.ts
+var CLAUDE_READ_STATE_PATH = `${AGENT_BRIDGE_RUNTIME_DIR}/claude-read-state`;
+var CLAUDE_READ_STATE_MAX_ENTRIES = 256;
+var ClaudeReadStateTracker = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  // Most-recently-observed entries last (Map preserves insertion order, and
+  // touches re-insert), so eviction drops the stalest observation first.
+  entriesByPath = /* @__PURE__ */ new Map();
+  // tool_use ids of in-flight file-tool calls, mapped to the file they target.
+  // Cleared at each turn's terminal result so interrupted calls cannot leak.
+  pendingFileToolUses = /* @__PURE__ */ new Map();
+  loadedForSessionId = null;
+  // Feed every live SDK message through here. Successful Read/Write/Edit
+  // results commit a path+mtime observation; everything else is ignored.
+  observe(sessionId, message) {
+    this.ensureLoaded(sessionId);
+    if (message.type === "result") {
+      this.pendingFileToolUses.clear();
+      return;
+    }
+    if (message.type === "assistant" && message.parent_tool_use_id === null) {
+      for (const block of contentBlocks(message.message.content)) {
+        const use = fileToolUse(block);
+        if (use) {
+          this.pendingFileToolUses.set(use.toolUseId, use.path);
+        }
+      }
+      return;
+    }
+    if (message.type !== "user" || message.parent_tool_use_id !== null) {
+      return;
+    }
+    if ("isReplay" in message && message.isReplay === true) {
+      return;
+    }
+    for (const block of contentBlocks(message.message.content)) {
+      if (block.type !== "tool_result") {
+        continue;
+      }
+      const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : null;
+      if (toolUseId === null) {
+        continue;
+      }
+      const path2 = this.pendingFileToolUses.get(toolUseId);
+      this.pendingFileToolUses.delete(toolUseId);
+      if (path2 !== void 0 && block.is_error !== true) {
+        this.commit(sessionId, path2);
+      }
+    }
+  }
+  // The seeds to replay into a fresh CLI process, stalest observation first so
+  // the most recent reads survive any CLI-side eviction.
+  seeds(sessionId) {
+    this.ensureLoaded(sessionId);
+    return [...this.entriesByPath].map(([path2, mtime]) => ({ path: path2, mtime }));
+  }
+  // A conversation-lineage break: the next CLI session starts with no prior
+  // context, so nothing the model "remembers reading" exists anymore.
+  clear(sessionId) {
+    this.ensureLoaded(sessionId);
+    if (this.entriesByPath.size === 0) {
+      return;
+    }
+    this.entriesByPath.clear();
+    this.persist(sessionId);
+  }
+  ensureLoaded(sessionId) {
+    if (this.loadedForSessionId === sessionId) {
+      return;
+    }
+    this.loadedForSessionId = sessionId;
+    this.entriesByPath.clear();
+    this.pendingFileToolUses.clear();
+    for (const entry of this.store.read(sessionId) ?? []) {
+      this.entriesByPath.set(entry.path, entry.mtime);
+    }
+  }
+  commit(sessionId, path2) {
+    let mtime;
+    try {
+      mtime = Math.floor(statSync(path2).mtimeMs);
+    } catch {
+      if (this.entriesByPath.delete(path2)) {
+        this.persist(sessionId);
+      }
+      return;
+    }
+    this.entriesByPath.delete(path2);
+    this.entriesByPath.set(path2, mtime);
+    while (this.entriesByPath.size > CLAUDE_READ_STATE_MAX_ENTRIES) {
+      const oldest = this.entriesByPath.keys().next().value;
+      if (oldest === void 0) {
+        break;
+      }
+      this.entriesByPath.delete(oldest);
+    }
+    this.persist(sessionId);
+  }
+  persist(sessionId) {
+    this.store.write({ sessionId, entries: this.seeds(sessionId) });
+  }
+};
+function fileClaudeReadStateStore(path2 = CLAUDE_READ_STATE_PATH) {
+  return {
+    read(sessionId) {
+      if (!existsSync2(path2)) {
+        return null;
+      }
+      const record2 = parseReadStateRecord(readFileSync3(path2, "utf8"));
+      if (!record2 || record2.sessionId !== sessionId) {
+        return null;
+      }
+      return record2.entries;
+    },
+    write(record2) {
+      mkdirSync3(dirname4(path2), { recursive: true });
+      writeFileSync3(path2, `${JSON.stringify(record2)}
+`, "utf8");
+    }
+  };
+}
+function fileToolUse(block) {
+  if (block.type !== "tool_use" || typeof block.id !== "string") {
+    return null;
+  }
+  const input = block.input;
+  if (typeof input !== "object" || input === null) {
+    return null;
+  }
+  const filePath = input.file_path;
+  if (typeof filePath !== "string" || filePath.length === 0) {
+    return null;
+  }
+  switch (block.name) {
+    case "Read": {
+      const { offset, limit } = input;
+      if (offset !== void 0 || limit !== void 0) {
+        return null;
+      }
+      return { toolUseId: block.id, path: filePath };
+    }
+    case "Write":
+    case "Edit":
+      return { toolUseId: block.id, path: filePath };
+    default:
+      return null;
+  }
+}
+function contentBlocks(content) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.filter(
+    (block) => typeof block === "object" && block !== null
+  );
+}
+function parseReadStateRecord(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (value === null || typeof value !== "object" || !("sessionId" in value) || !("entries" in value) || typeof value.sessionId !== "string" || !Array.isArray(value.entries)) {
+      return null;
+    }
+    const entries = [];
+    for (const entry of value.entries) {
+      if (entry === null || typeof entry !== "object" || typeof entry.path !== "string" || typeof entry.mtime !== "number") {
+        return null;
+      }
+      entries.push({
+        path: entry.path,
+        mtime: entry.mtime
+      });
+    }
+    return { sessionId: value.sessionId, entries };
+  } catch {
+    return null;
+  }
+}
+
 // src/commands/agent-bridge/harness/claude-code/session.ts
 import {
   startup as startupClaudeAgent
@@ -52198,6 +52425,7 @@ var CLAUDE_INTERRUPT_SETTLE_TIMEOUT_MS = 1e4;
 var CLAUDE_INTERRUPT_ACK_TIMEOUT_MS = 1e4;
 var CLAUDE_MCP_REGISTRATION_TIMEOUT_MS = 3e3;
 var CLAUDE_MCP_REGISTRATION_POLL_INTERVAL_MS = 100;
+var CLAUDE_READ_STATE_SEED_FAILURE_LIMIT = 3;
 var CLAUDE_STARTUP_PROFILE_HOOK_EVENTS = [
   "Setup",
   "SessionStart",
@@ -52414,6 +52642,32 @@ var ClaudeAgentBridgeSessionImpl = class {
       }
     );
   }
+  async seedReadState(seeds) {
+    if (seeds.length === 0 || this.state.kind !== "running") {
+      return;
+    }
+    const query = this.state.query;
+    const startedAt = Date.now();
+    let seeded = 0;
+    let failed = 0;
+    for (const seed of seeds) {
+      try {
+        await query.seedReadState(seed.path, seed.mtime);
+        seeded += 1;
+      } catch (error51) {
+        failed += 1;
+        this.input.writeOutput?.(
+          `agent_bridge_claude_read_state_seed_failed path=${seed.path} error=${error51 instanceof Error ? error51.message : String(error51)}`
+        );
+        if (failed >= CLAUDE_READ_STATE_SEED_FAILURE_LIMIT) {
+          break;
+        }
+      }
+    }
+    this.input.writeOutput?.(
+      `agent_bridge_claude_read_state_seeded seeded=${seeded} total=${seeds.length} duration_ms=${Date.now() - startedAt}`
+    );
+  }
   close() {
     const previousState = this.state;
     if (previousState.kind === "closed") {
@@ -52475,6 +52729,7 @@ var ClaudeAgentBridgeSessionImpl = class {
         this.input.writeOutput?.(
           `agent_bridge_claude_resume_fallback session_id=${resume}`
         );
+        this.input.onResumeFallback?.();
         this.state = { kind: "idle" };
         return this.startSdkSession();
       }
@@ -53079,7 +53334,7 @@ function isClaudeAgentTurnResult(message) {
 }
 function toolUseIds(message) {
   if (message.type === "assistant") {
-    return contentBlocks(message.message.content).flatMap(
+    return contentBlocks2(message.message.content).flatMap(
       (block2) => block2.type === "tool_use" && typeof block2.id === "string" ? [block2.id] : []
     );
   }
@@ -53097,11 +53352,11 @@ function toolResultIds(message) {
   if (message.type !== "user") {
     return [];
   }
-  return contentBlocks(message.message.content).flatMap(
+  return contentBlocks2(message.message.content).flatMap(
     (block) => block.type === "tool_result" && typeof block.tool_use_id === "string" ? [block.tool_use_id] : []
   );
 }
-function contentBlocks(content) {
+function contentBlocks2(content) {
   if (!Array.isArray(content)) {
     return [];
   }
@@ -53110,42 +53365,6 @@ function contentBlocks(content) {
   );
 }
 
-// src/commands/agent-bridge/harness/claude-code/resume-store.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3 } from "path";
-var AGENT_BRIDGE_RUNTIME_DIR = "/tmp/auto-bridge-runtime";
-var CLAUDE_SESSION_RESUME_PATH = `${AGENT_BRIDGE_RUNTIME_DIR}/claude-session-id`;
-function fileClaudeSessionResumeStore(path2 = CLAUDE_SESSION_RESUME_PATH) {
-  return {
-    read(sessionId) {
-      if (!existsSync(path2)) {
-        return null;
-      }
-      const record2 = parseResumeRecord(readFileSync2(path2, "utf8"));
-      if (!record2 || record2.sessionId !== sessionId) {
-        return null;
-      }
-      return record2.agentId;
-    },
-    write(record2) {
-      mkdirSync2(dirname3(path2), { recursive: true });
-      writeFileSync2(path2, `${JSON.stringify(record2)}
-`, "utf8");
-    }
-  };
-}
-function parseResumeRecord(raw) {
-  try {
-    const value = JSON.parse(raw);
-    if (value !== null && typeof value === "object" && "sessionId" in value && "agentId" in value && typeof value.sessionId === "string" && typeof value.agentId === "string" && value.agentId.length > 0) {
-      return { sessionId: value.sessionId, agentId: value.agentId };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
 // src/commands/agent-bridge/harness/claude-code/index.ts
 function createClaudeCodeCommandHandler(input) {
   return new ClaudeCodeCommandHandler(input);
@@ -53155,6 +53374,7 @@ var ClaudeCodeCommandHandler = class {
     this.input = input;
     this.claudeConfig = input.claude;
     this.outputBuffer = new AgentBridgeOutputBuffer(input);
+    this.readState = input.readState ? new ClaudeReadStateTracker(input.readState) : null;
   }
   input;
   context = null;
@@ -53176,6 +53396,7 @@ var ClaudeCodeCommandHandler = class {
   pendingQuestions = /* @__PURE__ */ new Map();
   outputBuffer;
   projector = new ClaudeCodeProjector();
+  readState;
   livenessTicker = null;
   // -----------------------------------------------------------------------------
   // Lifecycle (public API)
@@ -53552,6 +53773,7 @@ var ClaudeCodeCommandHandler = class {
       return;
     }
     this.persistAgentId(activeContext, message);
+    this.trackReadState(activeContext, message);
     let projections;
     try {
       projections = this.projector.project(message);
@@ -53615,6 +53837,31 @@ var ClaudeCodeCommandHandler = class {
       );
     }
   }
+  // Observes file-tool results into the read-state tracker and replays the
+  // tracked seeds whenever a fresh CLI cache appears: a new process's `init`
+  // (runtime restart, selection change, CLI-internal fork — all resume the
+  // conversation but start with an empty readFileState) and compaction
+  // boundaries (which can evict prior reads). Seeding is fire-and-forget:
+  // a failed seed degrades to today's behavior, a fresh Read before writing.
+  trackReadState(activeContext, message) {
+    const tracker = this.readState;
+    if (!tracker) {
+      return;
+    }
+    if (message.type === "system" && (message.subtype === "init" || message.subtype === "compact_boundary")) {
+      const seeds = tracker.seeds(activeContext.sessionId);
+      if (seeds.length === 0) {
+        return;
+      }
+      this.agentSession?.seedReadState(seeds).catch((error51) => {
+        this.input.writeOutput?.(
+          `agent_bridge_claude_read_state_seed_failed error=${error51 instanceof Error ? error51.message : String(error51)}`
+        );
+      });
+      return;
+    }
+    tracker.observe(activeContext.sessionId, message);
+  }
   storedResumeAgentId() {
     const store = this.input.sessionResume;
     const activeContext = this.context;
@@ -53644,10 +53891,18 @@ var ClaudeCodeCommandHandler = class {
         "Cannot restart Claude Code for a model/effort selection change without a session id to resume"
       );
     }
+    if (!resumeAgentId && this.context) {
+      this.readState?.clear(this.context.sessionId);
+    }
     const session = claudeAgentBridgeRuntime.start({
       claude: this.claudeConfig,
       resumeAgentId,
       ...resumeRequired ? { allowResumeFallback: false } : {},
+      onResumeFallback: () => {
+        if (this.context) {
+          this.readState?.clear(this.context.sessionId);
+        }
+      },
       canUseTool: this.canUseTool,
       onMessage: (message, meta3) => this.handleAgentMessage(message, meta3),
       onError: (error51) => this.handleAgentError(error51),
@@ -54064,25 +54319,25 @@ function normalizeChunk(chunk) {
 }
 
 // src/commands/agent-bridge/harness/codex/resume-store.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname5 } from "path";
 var AGENT_BRIDGE_RUNTIME_DIR2 = "/tmp/auto-bridge-runtime";
 var CODEX_THREAD_RESUME_PATH = `${AGENT_BRIDGE_RUNTIME_DIR2}/codex-thread-id`;
 function fileCodexThreadResumeStore(path2 = CODEX_THREAD_RESUME_PATH) {
   return {
     read(sessionId) {
-      if (!existsSync2(path2)) {
+      if (!existsSync3(path2)) {
         return null;
       }
-      const record2 = parseResumeRecord2(readFileSync3(path2, "utf8"));
+      const record2 = parseResumeRecord2(readFileSync4(path2, "utf8"));
       if (!record2 || record2.sessionId !== sessionId) {
         return null;
       }
       return record2.threadId;
     },
     write(record2) {
-      mkdirSync3(dirname4(path2), { recursive: true });
-      writeFileSync3(path2, `${JSON.stringify(record2)}
+      mkdirSync4(dirname5(path2), { recursive: true });
+      writeFileSync4(path2, `${JSON.stringify(record2)}
 `, "utf8");
     }
   };
@@ -54102,8 +54357,26 @@ function parseResumeRecord2(raw) {
 // src/commands/agent-bridge/harness/codex/session.ts
 init_src();
 import { spawn as spawn2 } from "child_process";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join5 } from "path";
+
+// src/commands/agent-bridge/harness/codex/edit-capability.ts
+import { execFileSync } from "child_process";
+import {
+  constants,
+  accessSync,
+  existsSync as existsSync4,
+  lstatSync,
+  mkdtempSync,
+  readFileSync as readFileSync5,
+  realpathSync,
+  rmSync as rmSync2,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { tmpdir } from "os";
+import { delimiter, dirname as dirname6, join as join4 } from "path";
 
 // src/commands/agent-bridge/harness/codex/options.ts
 import { join as join3 } from "path";
@@ -54245,6 +54518,172 @@ function tomlString(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 
+// src/commands/agent-bridge/harness/codex/edit-capability.ts
+var CODEX_APPLY_PATCH_ALIAS = "apply_patch";
+var CODEX_EDIT_PROBE = {
+  fileName: "probe.txt",
+  before: "codex-edit-probe\n",
+  after: "codex-edit-probe-ok\n",
+  patch: [
+    "*** Begin Patch",
+    "*** Update File: probe.txt",
+    "@@",
+    "-codex-edit-probe",
+    "+codex-edit-probe-ok",
+    "*** End Patch"
+  ].join("\n")
+};
+var PROBE_TIMEOUT_MS = 15e3;
+var MAX_EVIDENCE_LENGTH = 300;
+var CODEX_PLATFORM_VENDOR_TARGETS = {
+  linux: {
+    x64: "x86_64-unknown-linux-musl",
+    arm64: "aarch64-unknown-linux-musl"
+  },
+  darwin: {
+    x64: "x86_64-apple-darwin",
+    arm64: "aarch64-apple-darwin"
+  }
+};
+function ensureCodexEditCapability(input) {
+  if (input.command !== CODEX_EXECUTABLE_PATH) {
+    input.writeOutput?.(
+      "agent_bridge_codex_edit_capability status=skipped reason=command_override"
+    );
+    return;
+  }
+  const startedAt = Date.now();
+  const layout = runStep(input, "resolve", () => resolveCodexVendorLayout());
+  const status = runStep(
+    input,
+    "provision",
+    () => provisionApplyPatchAlias(layout)
+  );
+  const alias = join4(layout.codexPathDir, CODEX_APPLY_PATCH_ALIAS);
+  runStep(input, "verify", () => verifyApplyPatchAlias(alias));
+  input.writeOutput?.(
+    `agent_bridge_codex_edit_capability status=${status} alias=${alias} duration_ms=${Date.now() - startedAt}`
+  );
+}
+function codexEditFallthroughMarker(item) {
+  if (item.type !== "commandExecution" || item.exitCode !== 127) {
+    return null;
+  }
+  const output = item.aggregatedOutput ?? "";
+  if (!/apply_patch: (command )?not found/.test(output)) {
+    return null;
+  }
+  return `agent_bridge_codex_edit_fallthrough item_id=${item.id} exit_code=127`;
+}
+function resolveCodexVendorLayout() {
+  const wrapper = whichOnPath(CODEX_EXECUTABLE_PATH);
+  if (!wrapper) {
+    throw new Error("codex executable not found on PATH");
+  }
+  const target = CODEX_PLATFORM_VENDOR_TARGETS[process.platform]?.[process.arch];
+  if (!target) {
+    throw new Error(
+      `unsupported platform for codex vendor layout: ${process.platform}/${process.arch}`
+    );
+  }
+  const packageRoot = join4(dirname6(realpathSync(wrapper)), "..");
+  const platformPackage = `@openai/codex-${platformPackageSuffix()}`;
+  const candidates = [
+    join4(packageRoot, "node_modules", platformPackage, "vendor", target),
+    join4(packageRoot, "vendor", target)
+  ];
+  for (const vendorDir of candidates) {
+    const binary = join4(vendorDir, "bin", "codex");
+    const codexPathDir = join4(vendorDir, "codex-path");
+    if (existsSync4(binary) && existsSync4(codexPathDir)) {
+      return { binary, codexPathDir };
+    }
+  }
+  throw new Error(
+    `codex vendor layout not found (wrapper=${wrapper} candidates=${candidates.join(",")})`
+  );
+}
+function platformPackageSuffix() {
+  const os = process.platform === "darwin" ? "darwin" : "linux";
+  return `${os}-${process.arch}`;
+}
+function whichOnPath(command) {
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) {
+      continue;
+    }
+    const candidate = join4(dir, command);
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function provisionApplyPatchAlias(layout) {
+  const alias = join4(layout.codexPathDir, CODEX_APPLY_PATCH_ALIAS);
+  if (aliasResolvesToBinary(alias, layout.binary)) {
+    return "present";
+  }
+  if (lstatExists(alias)) {
+    unlinkSync(alias);
+  }
+  symlinkSync(layout.binary, alias);
+  return "provisioned";
+}
+function aliasResolvesToBinary(alias, binary) {
+  try {
+    return realpathSync(alias) === realpathSync(binary);
+  } catch {
+    return false;
+  }
+}
+function lstatExists(path2) {
+  try {
+    lstatSync(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function verifyApplyPatchAlias(alias) {
+  const scratch = mkdtempSync(join4(tmpdir(), "codex-edit-probe-"));
+  try {
+    const probeFile = join4(scratch, CODEX_EDIT_PROBE.fileName);
+    writeFileSync5(probeFile, CODEX_EDIT_PROBE.before);
+    execFileSync(alias, [CODEX_EDIT_PROBE.patch], {
+      cwd: scratch,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: PROBE_TIMEOUT_MS
+    });
+    const applied = readFileSync5(probeFile, "utf8");
+    if (applied !== CODEX_EDIT_PROBE.after) {
+      throw new Error("probe patch did not apply the expected content");
+    }
+  } finally {
+    rmSync2(scratch, { recursive: true, force: true });
+  }
+}
+function runStep(input, step, action) {
+  try {
+    return action();
+  } catch (error51) {
+    const detail = boundedEvidence(error51);
+    input.writeOutput?.(
+      `agent_bridge_codex_edit_capability status=failed step=${step} error=${detail}`
+    );
+    throw new Error(
+      `Codex edit capability unavailable at ${step}: ${detail}. Codex 0.141.0 declares no apply_patch tool; without the codex-path alias, exec invocations the interceptor does not recognize fail with command-not-found (codex-runtime-tool-loss-diagnostics).`
+    );
+  }
+}
+function boundedEvidence(error51) {
+  const message = error51 instanceof Error ? error51.message : String(error51);
+  const flattened = message.replace(/\s+/g, " ").trim();
+  return flattened.length > MAX_EVIDENCE_LENGTH ? `${flattened.slice(0, MAX_EVIDENCE_LENGTH)}\u2026` : flattened;
+}
+
 // src/commands/agent-bridge/harness/codex/turn-retry.ts
 var MAX_CODEX_TURN_RETRY_ATTEMPTS = 3;
 var MAX_CODEX_TURN_RETRY_TOTAL_DELAY_MS = 3e4;
@@ -54478,12 +54917,16 @@ var CodexAgentBridgeSessionImpl = class {
   }
   async start() {
     const options = codexLaunchOptions(this.input.codex);
-    mkdirSync4(options.codexHome, { recursive: true });
-    writeFileSync4(join4(options.codexHome, "config.toml"), options.configToml);
+    mkdirSync5(options.codexHome, { recursive: true });
+    writeFileSync6(join5(options.codexHome, "config.toml"), options.configToml);
     const startedAt = Date.now();
     this.input.writeOutput?.(
       `agent_bridge_codex_startup_started codex_home=${options.codexHome}`
     );
+    ensureCodexEditCapability({
+      command: options.command,
+      ...this.input.writeOutput ? { writeOutput: this.input.writeOutput } : {}
+    });
     const proc = spawn2(options.command, options.args, {
       env: options.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -54883,12 +55326,17 @@ var CodexAgentBridgeSessionImpl = class {
           this.pendingToolItemIds.add(notification.item.id);
         }
         return;
-      case "itemCompleted":
+      case "itemCompleted": {
+        const fallthrough = codexEditFallthroughMarker(notification.item);
+        if (fallthrough) {
+          this.input.writeOutput?.(fallthrough);
+        }
         this.pendingToolItemIds.delete(notification.item.id);
         if (this.pendingToolItemIds.size === 0) {
           this.resolveSettlement();
         }
         return;
+      }
       default:
         return;
     }
@@ -55373,6 +55821,7 @@ function createHarnessCommandHandler(input) {
       return createClaudeCodeCommandHandler({
         ...base,
         claude,
+        readState: fileClaudeReadStateStore(),
         sessionResume: fileClaudeSessionResumeStore()
       });
     }
@@ -55672,9 +56121,9 @@ function statusAgents(input) {
 // src/commands/agents/connect.ts
 init_resources2();
 init_browser();
-import { existsSync as existsSync3, mkdtempSync, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir3, tmpdir } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
+import { join as join7 } from "path";
 
 // src/lib/stdio/secret.ts
 async function questionSecret(context, prompt) {
@@ -55865,7 +56314,7 @@ async function promptForIconUploads(input, options) {
   }
 }
 function stagedLocationLabel(stagedPath) {
-  return stagedPath.startsWith(`${join6(homedir3(), "Downloads")}/`) ? "Downloads" : "the printed path";
+  return stagedPath.startsWith(`${join7(homedir3(), "Downloads")}/`) ? "Downloads" : "the printed path";
 }
 async function stageAvatarImage(input) {
   try {
@@ -55877,10 +56326,10 @@ async function stageAvatarImage(input) {
     }
     const contentType = response.headers.get("content-type") ?? "";
     const extension = contentType.includes("jpeg") ? ".jpg" : ".png";
-    const downloads = join6(homedir3(), "Downloads");
-    const directory = existsSync3(downloads) ? downloads : mkdtempSync(join6(tmpdir(), "auto-avatar-"));
-    const path2 = join6(directory, `${input.agent}-avatar${extension}`);
-    writeFileSync5(path2, Buffer.from(await response.arrayBuffer()));
+    const downloads = join7(homedir3(), "Downloads");
+    const directory = existsSync5(downloads) ? downloads : mkdtempSync2(join7(tmpdir2(), "auto-avatar-"));
+    const path2 = join7(directory, `${input.agent}-avatar${extension}`);
+    writeFileSync7(path2, Buffer.from(await response.arrayBuffer()));
     return path2;
   } catch {
     return void 0;
@@ -57379,19 +57828,19 @@ init_src();
 // src/commands/logs/actions.ts
 import {
   closeSync,
-  existsSync as existsSync5,
+  existsSync as existsSync7,
   openSync,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync9,
   readSync,
-  statSync as statSync3
+  statSync as statSync4
 } from "fs";
 var DEFAULT_POLL_INTERVAL_MS = 1e3;
 async function tailRuntimeLog(input) {
-  if (!existsSync5(input.path)) {
+  if (!existsSync7(input.path)) {
     input.writeError(`No runtime log at ${input.path}`);
     return;
   }
-  const content = readFileSync7(input.path, "utf8");
+  const content = readFileSync9(input.path, "utf8");
   for (const line of selectLastLines(content, input.lines)) {
     input.writeOutput(line);
   }
@@ -57418,7 +57867,7 @@ async function followRuntimeLog(input) {
     }
     let size;
     try {
-      size = statSync3(input.path).size;
+      size = statSync4(input.path).size;
     } catch {
       continue;
     }
@@ -60503,7 +60952,7 @@ function createProgram(options = {}) {
 }
 
 // src/lib/entrypoint.ts
-import { realpathSync as realpathSync2 } from "fs";
+import { realpathSync as realpathSync3 } from "fs";
 import { pathToFileURL } from "url";
 function isCliEntrypoint(input) {
   if (input.entrypoint.kind === "missing") {
@@ -60511,7 +60960,7 @@ function isCliEntrypoint(input) {
   }
   let resolvedEntrypoint;
   try {
-    resolvedEntrypoint = realpathSync2(input.entrypoint.path);
+    resolvedEntrypoint = realpathSync3(input.entrypoint.path);
   } catch {
     return false;
   }