@autohq/cli 0.1.418 → 0.1.420

package/dist/agent-bridge.js

@@ -652,8 +652,8 @@ var require_common = __commonJS({
         }
         return debug12;
       }
-      function extend2(namespace, delimiter) {
-        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+      function extend2(namespace, delimiter2) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter2 === "undefined" ? ":" : delimiter2) + namespace);
         newDebug.log = this.log;
         return newDebug;
       }
@@ -13853,8 +13853,8 @@ function emoji() {
 }
 var 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])$/;
 var 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}|:))$/;
-var mac = (delimiter) => {
-  const escapedDelim = escapeRegex(delimiter ?? ":");
+var 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}$`);
 };
 var 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])$/;
@@ -30820,7 +30820,7 @@ Object.assign(lookup, {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.418",
+  version: "0.1.420",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"
@@ -34000,6 +34000,11 @@ var TRIGGER_BINDING_TARGET_TYPES = [
   "linear.issue",
   "auto.session"
 ];
+var OBSERVED_TARGET_EVENT_KEYS = [
+  "auto.session.binding.bound",
+  "auto.session.binding.updated",
+  "auto.session.binding.unbound"
+];
 var SESSION_BINDING_SOURCES = [
   "trigger_spawn",
   "agent_tool",
@@ -34022,6 +34027,7 @@ var BINDING_TRANSITION_CAUSES = [
   "manual_update",
   "attributed_event",
   "mention",
+  "observed_binding_event",
   "session_spawn",
   "trigger_spawn",
   "chat_send",
@@ -34284,6 +34290,17 @@ var TriggerReleaseSchema = external_exports.union([
   external_exports.literal(true).transform(() => ({ context: null })),
   external_exports.object({ context: JsonObjectSchema.nullable().default(null) }).strict()
 ]);
+var ObservedTargetActionSchema = external_exports.discriminatedUnion("action", [
+  external_exports.object({
+    action: external_exports.literal("bind"),
+    context: JsonObjectSchema.nullable().default(null),
+    eventContext: JsonObjectSchema.nullable().default(null)
+  }).strict(),
+  external_exports.object({
+    action: external_exports.literal("unbind"),
+    eventContext: JsonObjectSchema.nullable().default(null)
+  }).strict()
+]);
 var CanonicalTriggerRoutingSchema = external_exports.discriminatedUnion("kind", [
   external_exports.object({
     kind: external_exports.literal("spawn"),
@@ -34312,7 +34329,17 @@ var CanonicalTriggerRoutingSchema = external_exports.discriminatedUnion("kind",
     // routing completes. No-op when no active binding exists. `agent.singleton`
     // is rejected at apply time (singleton slots are pool-membership state
     // owned by the reconciler).
-    release: TriggerReleaseSchema.default(false)
+    release: TriggerReleaseSchema.default(false),
+    // Observed-target lifecycle action: after the router delivers a matching
+    // binding-transition event to the observer session this trigger's
+    // `auto.session` target resolved, the platform binds or unbinds that
+    // session to/from the target carried by the observed event. Apply-time
+    // validation restricts this to `target: auto.session` triggers on the
+    // `auto.session.binding.bound|updated|unbound` event keys; the target type
+    // is authorized at runtime against the observer agent's own bindable
+    // targets. Distinct from `release` above, which releases this route's own
+    // `auto.session` observation binding.
+    observedTarget: ObservedTargetActionSchema.optional()
   })
 ]);
 var LegacySingletonRouteBySchema = external_exports.object({
@@ -34812,6 +34839,7 @@ var AgentApplySpecSchema = AgentSpecFieldsSchema.extend({
   validateConcurrencyConfig(spec, context);
   validateBindingsConfig(spec, context);
   validateTriggerReleaseConfig(spec, context);
+  validateTriggerObservedTargetConfig(spec, context);
 });
 function validateConcurrencyConfig(spec, context) {
   if (spec.concurrency === void 0 && spec.replace !== void 0) {
@@ -34913,6 +34941,28 @@ function validateTriggerReleaseConfig(spec, context) {
     }
   }
 }
+function validateTriggerObservedTargetConfig(spec, context) {
+  const legalEvents = new Set(OBSERVED_TARGET_EVENT_KEYS);
+  for (const [index, trigger] of spec.triggers.entries()) {
+    if (trigger.routing.kind !== "bind" || !trigger.routing.observedTarget) {
+      continue;
+    }
+    if (trigger.routing.target !== "auto.session") {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["triggers", index, "routing", "observedTarget"],
+        message: "`observedTarget` requires `target: auto.session`: only the observed child-session relationship may drive an observed-target action"
+      });
+    }
+    if (!trigger.event || !legalEvents.has(trigger.event)) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["triggers", index, "routing", "observedTarget"],
+        message: `\`observedTarget\` requires an \`event\` in [${OBSERVED_TARGET_EVENT_KEYS.join(", ")}]: the binding lifecycle transitions are the events that carry the target to act on`
+      });
+    }
+  }
+}
 var AgentStatusSchema = external_exports.object({
   runCount: external_exports.number().int().nonnegative().default(0),
   lastActivityAt: external_exports.string().datetime().nullable().default(null)
@@ -61465,6 +61515,233 @@ function uiChunk(chunk) {
   };
 }
 
+// src/commands/agent-bridge/harness/claude-code/read-state.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname2 } from "path";
+
+// src/commands/agent-bridge/harness/claude-code/resume-store.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } 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(readFileSync(path2, "utf8"));
+      if (!record2 || record2.sessionId !== sessionId) {
+        return null;
+      }
+      return record2.agentId;
+    },
+    write(record2) {
+      mkdirSync(dirname(path2), { recursive: true });
+      writeFileSync(path2, `${JSON.stringify(record2)}
+`, "utf8");
+    }
+  };
+}
+function parseResumeRecord(raw) {
+  try {
+    const value2 = JSON.parse(raw);
+    if (value2 !== null && typeof value2 === "object" && "sessionId" in value2 && "agentId" in value2 && typeof value2.sessionId === "string" && typeof value2.agentId === "string" && value2.agentId.length > 0) {
+      return { sessionId: value2.sessionId, agentId: value2.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(readFileSync2(path2, "utf8"));
+      if (!record2 || record2.sessionId !== sessionId) {
+        return null;
+      }
+      return record2.entries;
+    },
+    write(record2) {
+      mkdirSync2(dirname2(path2), { recursive: true });
+      writeFileSync2(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 value2 = JSON.parse(raw);
+    if (value2 === null || typeof value2 !== "object" || !("sessionId" in value2) || !("entries" in value2) || typeof value2.sessionId !== "string" || !Array.isArray(value2.entries)) {
+      return null;
+    }
+    const entries = [];
+    for (const entry of value2.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: value2.sessionId, entries };
+  } catch {
+    return null;
+  }
+}
+
 // ../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as i_ } from "module";
 import { execFile as v6$ } from "child_process";
@@ -81236,6 +81513,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",
@@ -81452,6 +81730,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") {
@@ -81513,6 +81817,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();
       }
@@ -82117,7 +82422,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] : []
     );
   }
@@ -82135,11 +82440,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 [];
   }
@@ -82148,42 +82453,6 @@ function contentBlocks(content) {
   );
 }
 
-// src/commands/agent-bridge/harness/claude-code/resume-store.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname } 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 (!existsSync2(path2)) {
-        return null;
-      }
-      const record2 = parseResumeRecord(readFileSync2(path2, "utf8"));
-      if (!record2 || record2.sessionId !== sessionId) {
-        return null;
-      }
-      return record2.agentId;
-    },
-    write(record2) {
-      mkdirSync2(dirname(path2), { recursive: true });
-      writeFileSync(path2, `${JSON.stringify(record2)}
-`, "utf8");
-    }
-  };
-}
-function parseResumeRecord(raw) {
-  try {
-    const value2 = JSON.parse(raw);
-    if (value2 !== null && typeof value2 === "object" && "sessionId" in value2 && "agentId" in value2 && typeof value2.sessionId === "string" && typeof value2.agentId === "string" && value2.agentId.length > 0) {
-      return { sessionId: value2.sessionId, agentId: value2.agentId };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
 // src/commands/agent-bridge/harness/claude-code/index.ts
 function createClaudeCodeCommandHandler(input) {
   return new ClaudeCodeCommandHandler(input);
@@ -82193,6 +82462,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;
@@ -82214,6 +82484,7 @@ var ClaudeCodeCommandHandler = class {
   pendingQuestions = /* @__PURE__ */ new Map();
   outputBuffer;
   projector = new ClaudeCodeProjector();
+  readState;
   livenessTicker = null;
   // -----------------------------------------------------------------------------
   // Lifecycle (public API)
@@ -82590,6 +82861,7 @@ var ClaudeCodeCommandHandler = class {
       return;
     }
     this.persistAgentId(activeContext, message);
+    this.trackReadState(activeContext, message);
     let projections;
     try {
       projections = this.projector.project(message);
@@ -82653,6 +82925,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;
@@ -82682,10 +82979,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),
@@ -83098,25 +83403,25 @@ function normalizeChunk(chunk) {
 }
 
 // src/commands/agent-bridge/harness/codex/resume-store.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } 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 (!existsSync3(path2)) {
+      if (!existsSync4(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(dirname2(path2), { recursive: true });
-      writeFileSync2(path2, `${JSON.stringify(record2)}
+      mkdirSync4(dirname3(path2), { recursive: true });
+      writeFileSync3(path2, `${JSON.stringify(record2)}
 `, "utf8");
     }
   };
@@ -83135,8 +83440,26 @@ function parseResumeRecord2(raw) {
 
 // src/commands/agent-bridge/harness/codex/session.ts
 import { spawn } from "child_process";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join2 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join3 } from "path";
+
+// src/commands/agent-bridge/harness/codex/edit-capability.ts
+import { execFileSync } from "child_process";
+import {
+  constants,
+  accessSync,
+  existsSync as existsSync5,
+  lstatSync as lstatSync2,
+  mkdtempSync,
+  readFileSync as readFileSync5,
+  realpathSync as realpathSync2,
+  rmSync as rmSync2,
+  symlinkSync as symlinkSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { tmpdir } from "os";
+import { delimiter, dirname as dirname4, join as join2 } from "path";
 
 // src/commands/agent-bridge/harness/codex/options.ts
 import { join } from "path";
@@ -83278,6 +83601,172 @@ function tomlString(value2) {
   return `"${value2.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 = join2(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 = join2(dirname4(realpathSync2(wrapper)), "..");
+  const platformPackage = `@openai/codex-${platformPackageSuffix()}`;
+  const candidates = [
+    join2(packageRoot, "node_modules", platformPackage, "vendor", target),
+    join2(packageRoot, "vendor", target)
+  ];
+  for (const vendorDir of candidates) {
+    const binary = join2(vendorDir, "bin", "codex");
+    const codexPathDir = join2(vendorDir, "codex-path");
+    if (existsSync5(binary) && existsSync5(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 = join2(dir, command);
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function provisionApplyPatchAlias(layout) {
+  const alias = join2(layout.codexPathDir, CODEX_APPLY_PATCH_ALIAS);
+  if (aliasResolvesToBinary(alias, layout.binary)) {
+    return "present";
+  }
+  if (lstatExists(alias)) {
+    unlinkSync2(alias);
+  }
+  symlinkSync2(layout.binary, alias);
+  return "provisioned";
+}
+function aliasResolvesToBinary(alias, binary) {
+  try {
+    return realpathSync2(alias) === realpathSync2(binary);
+  } catch {
+    return false;
+  }
+}
+function lstatExists(path2) {
+  try {
+    lstatSync2(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function verifyApplyPatchAlias(alias) {
+  const scratch = mkdtempSync(join2(tmpdir(), "codex-edit-probe-"));
+  try {
+    const probeFile = join2(scratch, CODEX_EDIT_PROBE.fileName);
+    writeFileSync4(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;
@@ -83511,12 +84000,16 @@ var CodexAgentBridgeSessionImpl = class {
   }
   async start() {
     const options = codexLaunchOptions(this.input.codex);
-    mkdirSync4(options.codexHome, { recursive: true });
-    writeFileSync3(join2(options.codexHome, "config.toml"), options.configToml);
+    mkdirSync5(options.codexHome, { recursive: true });
+    writeFileSync5(join3(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 = spawn(options.command, options.args, {
       env: options.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -83916,12 +84409,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;
     }
@@ -84406,6 +84904,7 @@ function createHarnessCommandHandler(input) {
       return createClaudeCodeCommandHandler({
         ...base,
         claude,
+        readState: fileClaudeReadStateStore(),
         sessionResume: fileClaudeSessionResumeStore()
       });
     }
@@ -84627,7 +85126,7 @@ function bridgeUrlHost(bridgeUrl) {
 }
 
 // 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") {
@@ -84635,7 +85134,7 @@ function isCliEntrypoint(input) {
   }
   let resolvedEntrypoint;
   try {
-    resolvedEntrypoint = realpathSync2(input.entrypoint.path);
+    resolvedEntrypoint = realpathSync3(input.entrypoint.path);
   } catch {
     return false;
   }