@nyssance/codex-acp-v2 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.7.5 — 2026-10-08
+
+### Added
+
+- Chat branches and fork lineage under `_meta.codex`: `forkAtTurn` and `sessionLineage` capabilities;
+  `session/fork` and `session/resume` responses carry `nativeSessionId` and `forkedFromId`; session
+  messages carry `turnId` and `turnStartedAt` so a client can tell which turn a message came from.
+
+### Changed
+
+- `@agentclientprotocol/sdk` ^1.7.0 (schema v2.0.0-alpha.7). The protocol now lets `session/new` and
+  `session/resume` responses carry `availableCommands` and `configOptions`; the adapter does not fill
+  them yet and still announces commands through `available_commands_update`. The 1.7.0 types reject a
+  hand-built update with an unknown tag (no `_` prefix) or a malformed known variant at compile time;
+  runtime validation is unchanged.
+
+### Fixed
+
+- `AppServerClient` wrote a raw NUL byte into a template literal as the turn-key separator, so `file`
+  and `grep` treated the source as binary. It is the `\0` escape now.
+
 ## 0.7.4 — 2026-09-30
 
 ### Added

package/dist/index.js

@@ -3406,7 +3406,7 @@ var require_main = __commonJS(function(exports) {
   exports.createMessageConnection = createMessageConnection;
   var ril_1 = __importDefault(require_ril());
   ril_1.default.install();
-  var path8 = __importStar(__require("path"));
+  var path9 = __importStar(__require("path"));
   var os3 = __importStar(__require("os"));
   var fs7 = __importStar(__require("fs"));
   var crypto_1 = __require("crypto");
@@ -3564,7 +3564,7 @@ var require_main = __commonJS(function(exports) {
       throw new Error(`Unable to generate a random pipe name with ${randomLength} characters.`);
     }
     const randomSuffix = (0, crypto_1.randomBytes)(Math.floor(randomLength / 2)).toString("hex");
-    return path8.join(tmpDir, `lsp-${randomSuffix}.sock`);
+    return path9.join(tmpDir, `lsp-${randomSuffix}.sock`);
   }
   function createClientPipeTransport(pipeName, encoding = "utf-8") {
     let connectResolve;
@@ -3681,9 +3681,7 @@ var AGENT_METHODS = {
 var CLIENT_METHODS = {
   session_request_permission: "session/request_permission",
   session_update: "session/update",
-  mcp_connect: "mcp/connect",
   mcp_message: "mcp/message",
-  mcp_disconnect: "mcp/disconnect",
   elicitation_create: "elicitation/create",
   elicitation_complete: "elicitation/complete"
 };
@@ -15345,27 +15343,16 @@ var zCreateElicitationRequest = preserveCustomPayload(intersection(union([
   })
 })), "mode", ["form", "url"]);
 var zMcpServerAcpId = string2();
-var zConnectMcpRequest = object({
-  serverId: zMcpServerAcpId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMcpConnectionId = string2();
+var zMcpRequestId = string2();
 var zMessageMcpRequest = object({
-  connectionId: zMcpConnectionId,
+  serverId: zMcpServerAcpId,
+  requestId: zMcpRequestId,
   method: string2(),
   params: record(string2(), unknown()).nullish(),
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
     return;
   })
 });
-var zDisconnectMcpRequest = object({
-  connectionId: zMcpConnectionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
 var zExtRequest = unknown();
 var zAgentRequest = object({
   id: zRequestId,
@@ -15373,9 +15360,7 @@ var zAgentRequest = object({
   params: union([
     zRequestPermissionRequest,
     zCreateElicitationRequest,
-    zConnectMcpRequest,
     zMessageMcpRequest,
-    zDisconnectMcpRequest,
     zExtRequest
   ]).nullish()
 });
@@ -15826,9 +15811,34 @@ var zSessionConfigOption = preserveCustomPayload(intersection(union([
     return;
   })
 })), "type", ["boolean", "select"]);
+var zTextCommandInput = object({
+  hint: string2(),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAvailableCommandInput = preserveCustomPayload(union([
+  zTextCommandInput.and(object({
+    type: literal("text")
+  })),
+  excludeKnownTags(object({
+    type: string2()
+  }), "type", ["text"])
+]), "type", ["text"]);
+var zAvailableCommand = object({
+  name: string2(),
+  description: string2(),
+  input: defaultOnError(zAvailableCommandInput.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
 var zNewSessionResponse = object({
   sessionId: zSessionId,
   configOptions: defaultOnError(vecSkipError(zSessionConfigOption).optional(), () => []),
+  availableCommands: defaultOnError(vecSkipError(zAvailableCommand).optional(), () => []),
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
     return;
   })
@@ -15865,12 +15875,14 @@ var zDeleteSessionResponse = object({
 var zForkSessionResponse = object({
   sessionId: zSessionId,
   configOptions: defaultOnError(vecSkipError(zSessionConfigOption).optional(), () => []),
+  availableCommands: defaultOnError(vecSkipError(zAvailableCommand).optional(), () => []),
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
     return;
   })
 });
 var zResumeSessionResponse = object({
   configOptions: defaultOnError(vecSkipError(zSessionConfigOption).optional(), () => []),
+  availableCommands: defaultOnError(vecSkipError(zAvailableCommand).optional(), () => []),
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
     return;
   })
@@ -15993,7 +16005,6 @@ var zCloseNesResponse = object({
   })
 });
 var zExtResponse = unknown();
-var zMessageMcpResponse = unknown();
 var zErrorCode = union([
   literal(-32700),
   literal(-32600),
@@ -16037,8 +16048,7 @@ var zAgentResponse = union([
       zStartNesResponse,
       zSuggestNesResponse,
       zCloseNesResponse,
-      zExtResponse,
-      zMessageMcpResponse
+      zExtResponse
     ])
   }),
   object({
@@ -16126,6 +16136,11 @@ var zRequiresActionStateUpdate = object({
     return;
   })
 });
+var zUnknownStateUpdate = object({
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
 var zStateUpdate = preserveCustomPayload(union([
   zRunningStateUpdate.and(object({
     state: literal("running")
@@ -16136,10 +16151,13 @@ var zStateUpdate = preserveCustomPayload(union([
   zRequiresActionStateUpdate.and(object({
     state: literal("requires_action")
   })),
+  zUnknownStateUpdate.and(object({
+    state: literal("unknown")
+  })),
   excludeKnownTags(object({
     state: string2()
-  }), "state", ["idle", "requires_action", "running"])
-]), "state", ["idle", "requires_action", "running"]);
+  }), "state", ["idle", "requires_action", "running", "unknown"])
+]), "state", ["idle", "requires_action", "running", "unknown"]);
 var zToolCallContentChunk = object({
   toolCallId: zToolCallId,
   content: zToolCallContent,
@@ -16261,30 +16279,6 @@ var zPlanRemoved = object({
     return;
   })
 });
-var zTextCommandInput = object({
-  hint: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAvailableCommandInput = preserveCustomPayload(union([
-  zTextCommandInput.and(object({
-    type: literal("text")
-  })),
-  excludeKnownTags(object({
-    type: string2()
-  }), "type", ["text"])
-]), "type", ["text"]);
-var zAvailableCommand = object({
-  name: string2(),
-  description: string2(),
-  input: defaultOnError(zAvailableCommandInput.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
 var zAvailableCommandsUpdate = object({
   availableCommands: requiredDefaultOnError(vecSkipError(zAvailableCommand), () => []),
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
@@ -16369,6 +16363,65 @@ var zCompactionSummaryChunk = object({
     return;
   })
 });
+var zSessionCancelCapabilities = object({
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSubagentSessionCapabilities = object({
+  cancel: defaultOnError(zSessionCancelCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSubagentUpdate = object({
+  sessionId: zSessionId,
+  title: defaultOnError(string2().nullish(), () => {
+    return;
+  }),
+  description: defaultOnError(string2().nullish(), () => {
+    return;
+  }),
+  capabilities: defaultOnError(zSubagentSessionCapabilities.nullish(), () => {
+    return;
+  }),
+  state: defaultOnError(zStateUpdate.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionMessage = object({
+  messageId: zMessageId,
+  senderSessionId: defaultOnError(zSessionId.nullish(), () => {
+    return;
+  }),
+  recipientSessionId: defaultOnError(zSessionId.nullish(), () => {
+    return;
+  }),
+  content: defaultOnError(vecSkipError(zContentBlock).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionMessageChunk = object({
+  messageId: zMessageId,
+  senderSessionId: defaultOnError(zSessionId.nullish(), () => {
+    return;
+  }),
+  recipientSessionId: defaultOnError(zSessionId.nullish(), () => {
+    return;
+  }),
+  content: zContentBlock,
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
 var zSessionUpdate = preserveCustomPayload(union([
   zContentChunk.and(object({
     sessionUpdate: literal("user_message_chunk")
@@ -16430,6 +16483,15 @@ var zSessionUpdate = preserveCustomPayload(union([
   zCompactionSummaryChunk.and(object({
     sessionUpdate: literal("compaction_summary_chunk")
   })),
+  zSubagentUpdate.and(object({
+    sessionUpdate: literal("subagent_update")
+  })),
+  zSessionMessage.and(object({
+    sessionUpdate: literal("session_message")
+  })),
+  zSessionMessageChunk.and(object({
+    sessionUpdate: literal("session_message_chunk")
+  })),
   excludeKnownTags(object({
     sessionUpdate: string2()
   }), "sessionUpdate", [
@@ -16445,7 +16507,10 @@ var zSessionUpdate = preserveCustomPayload(union([
     "plan_removed",
     "plan_update",
     "session_info_update",
+    "session_message",
+    "session_message_chunk",
     "state_update",
+    "subagent_update",
     "terminal_output_chunk",
     "terminal_update",
     "tool_call_content_chunk",
@@ -16467,7 +16532,10 @@ var zSessionUpdate = preserveCustomPayload(union([
   "plan_removed",
   "plan_update",
   "session_info_update",
+  "session_message",
+  "session_message_chunk",
   "state_update",
+  "subagent_update",
   "terminal_output_chunk",
   "terminal_update",
   "tool_call_content_chunk",
@@ -16489,23 +16557,12 @@ var zCompleteElicitationNotification = object({
     return;
   })
 });
-var zMessageMcpNotification = object({
-  connectionId: zMcpConnectionId,
-  method: string2(),
-  params: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
 var zExtNotification = unknown();
 var zAgentNotification = object({
   method: string2(),
   params: union([
     zUpdateSessionNotification,
     zCompleteElicitationNotification,
-    zMessageMcpNotification,
     zExtNotification
   ]).nullish()
 });
@@ -16917,7 +16974,6 @@ var zClientRequest = object({
     zStartNesRequest,
     zSuggestNesRequest,
     zCloseNesRequest,
-    zMessageMcpRequest,
     zExtRequest
   ]).nullish()
 });
@@ -16972,25 +17028,35 @@ var zCreateElicitationResponse = preserveCustomPayload(intersection(union([
     return;
   })
 })), "action", ["accept", "cancel", "decline"]);
-var zConnectMcpResponse = object({
-  connectionId: zMcpConnectionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
+var zMcpError = looseObject({
+  code: int().min(-2147483648, {
+    error: "Invalid value: Expected int32 to be >= -2147483648"
+  }).max(2147483647, {
+    error: "Invalid value: Expected int32 to be <= 2147483647"
+  }),
+  message: string2(),
+  data: unknown().optional()
 });
-var zDisconnectMcpResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
+var zMessageMcpResponse = union([
+  object({
+    result: unknown(),
+    _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+      return;
+    })
+  }),
+  object({
+    error: zMcpError,
+    _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+      return;
+    })
   })
-});
+]);
 var zClientResponse = union([
   object({
     id: zRequestId,
     result: union([
       zRequestPermissionResponse,
       zCreateElicitationResponse,
-      zConnectMcpResponse,
-      zDisconnectMcpResponse,
       zMessageMcpResponse,
       zExtResponse
     ])
@@ -17080,6 +17146,15 @@ var zRejectNesNotification = object({
     return;
   })
 });
+var zMessageMcpNotification = object({
+  serverId: zMcpServerAcpId,
+  requestId: zMcpRequestId,
+  method: string2(),
+  params: record(string2(), unknown()).nullish(),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
 var zClientNotification = object({
   method: string2(),
   params: union([
@@ -17146,6 +17221,7 @@ var zGuardSessionConfigOptionCustom = object({
   configId: zSessionConfigId,
   name: string2()
 });
+var zGuardAvailableCommandInputText = zTextCommandInput.and(object({ type: literal("text") }));
 var zGuardNesSuggestionEdit = zNesEditSuggestion.and(object({ kind: literal("edit") }));
 var zGuardNesSuggestionJump = zNesJumpSuggestion.and(object({ kind: literal("jump") }));
 var zGuardNesSuggestionRename = zNesRenameSuggestion.and(object({ kind: literal("rename") }));
@@ -17173,14 +17249,17 @@ var zGuardSessionUpdateUsageUpdate = zUsageUpdate.and(object({ sessionUpdate: li
 var zGuardSessionUpdateNotice = zNotice.and(object({ sessionUpdate: literal("notice") }));
 var zGuardSessionUpdateCompactionUpdate = zCompactionUpdate.and(object({ sessionUpdate: literal("compaction_update") }));
 var zGuardSessionUpdateCompactionSummaryChunk = zCompactionSummaryChunk.and(object({ sessionUpdate: literal("compaction_summary_chunk") }));
+var zGuardSessionUpdateSubagentUpdate = zSubagentUpdate.and(object({ sessionUpdate: literal("subagent_update") }));
+var zGuardSessionUpdateSessionMessage = zSessionMessage.and(object({ sessionUpdate: literal("session_message") }));
+var zGuardSessionUpdateSessionMessageChunk = zSessionMessageChunk.and(object({ sessionUpdate: literal("session_message_chunk") }));
 var zGuardStateUpdateRunning = zRunningStateUpdate.and(object({ state: literal("running") }));
 var zGuardStateUpdateIdle = zIdleStateUpdate.and(object({ state: literal("idle") }));
 var zGuardStateUpdateRequiresAction = zRequiresActionStateUpdate.and(object({ state: literal("requires_action") }));
+var zGuardStateUpdateUnknown = zUnknownStateUpdate.and(object({ state: literal("unknown") }));
 var zGuardPlanUpdateContentItems = zPlanItems.and(object({ type: literal("items") }));
 var zGuardPlanUpdateContentFile = zPlanFile.and(object({ type: literal("file") }));
 var zGuardPlanUpdateContentMarkdown = zPlanMarkdown.and(object({ type: literal("markdown") }));
 var zGuardPlanUpdateContentCustom = object({ planId: zPlanId });
-var zGuardAvailableCommandInputText = zTextCommandInput.and(object({ type: literal("text") }));
 var zGuardMcpServerHttp = zMcpServerHttp.and(object({ type: literal("http") }));
 var zGuardMcpServerAcp = zMcpServerAcp.and(object({ type: literal("acp") }));
 var zGuardMcpServerStdio = zMcpServerStdio.and(object({ type: literal("stdio") }));
@@ -17290,6 +17369,15 @@ var SessionUpdate = {
   isCompactionSummaryChunk(value) {
     return tagOf(value, "sessionUpdate") === "compaction_summary_chunk" && zGuardSessionUpdateCompactionSummaryChunk.safeParse(value).success;
   },
+  isSubagentUpdate(value) {
+    return tagOf(value, "sessionUpdate") === "subagent_update" && zGuardSessionUpdateSubagentUpdate.safeParse(value).success;
+  },
+  isSessionMessage(value) {
+    return tagOf(value, "sessionUpdate") === "session_message" && zGuardSessionUpdateSessionMessage.safeParse(value).success;
+  },
+  isSessionMessageChunk(value) {
+    return tagOf(value, "sessionUpdate") === "session_message_chunk" && zGuardSessionUpdateSessionMessageChunk.safeParse(value).success;
+  },
   isCustom(value) {
     const tag = tagOf(value, "sessionUpdate");
     return typeof tag === "string" && ![
@@ -17305,7 +17393,10 @@ var SessionUpdate = {
       "plan_removed",
       "plan_update",
       "session_info_update",
+      "session_message",
+      "session_message_chunk",
       "state_update",
+      "subagent_update",
       "terminal_output_chunk",
       "terminal_update",
       "tool_call_content_chunk",
@@ -17326,9 +17417,12 @@ var StateUpdate = {
   isRequiresAction(value) {
     return tagOf(value, "state") === "requires_action" && zGuardStateUpdateRequiresAction.safeParse(value).success;
   },
+  isUnknown(value) {
+    return tagOf(value, "state") === "unknown" && zGuardStateUpdateUnknown.safeParse(value).success;
+  },
   isCustom(value) {
     const tag = tagOf(value, "state");
-    return typeof tag === "string" && !["idle", "requires_action", "running"].includes(tag);
+    return typeof tag === "string" && !["idle", "requires_action", "running", "unknown"].includes(tag);
   }
 };
 var McpServer = {
@@ -18857,27 +18951,16 @@ var zCreateElicitationRequest2 = preserveCustomPayload(intersection(union([
   })
 })), "mode", ["form", "url"]);
 var zMcpServerAcpId2 = string2();
-var zConnectMcpRequest2 = object({
-  serverId: zMcpServerAcpId2,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMcpConnectionId2 = string2();
+var zMcpRequestId2 = string2();
 var zMessageMcpRequest2 = object({
-  connectionId: zMcpConnectionId2,
+  serverId: zMcpServerAcpId2,
+  requestId: zMcpRequestId2,
   method: string2(),
   params: record(string2(), unknown()).nullish(),
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
     return;
   })
 });
-var zDisconnectMcpRequest2 = object({
-  connectionId: zMcpConnectionId2,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
 var zExtRequest2 = unknown();
 var zAgentRequest2 = object({
   id: zRequestId2,
@@ -18892,9 +18975,7 @@ var zAgentRequest2 = object({
     zWaitForTerminalExitRequest,
     zKillTerminalRequest,
     zCreateElicitationRequest2,
-    zConnectMcpRequest2,
     zMessageMcpRequest2,
-    zDisconnectMcpRequest2,
     zExtRequest2
   ]).nullish()
 });
@@ -19590,7 +19671,6 @@ var zCloseNesResponse2 = object({
   })
 });
 var zExtResponse2 = unknown();
-var zMessageMcpResponse2 = unknown();
 var zErrorCode2 = union([
   literal(-32700),
   literal(-32600),
@@ -19636,8 +19716,7 @@ var zAgentResponse2 = union([
       zStartNesResponse2,
       zSuggestNesResponse2,
       zCloseNesResponse2,
-      zExtResponse2,
-      zMessageMcpResponse2
+      zExtResponse2
     ])
   }),
   object({
@@ -19855,6 +19934,108 @@ var zCompactionSummaryChunk2 = object({
     return;
   })
 });
+var zSessionCancelCapabilities2 = object({
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSubagentSessionCapabilities2 = object({
+  cancel: defaultOnError(zSessionCancelCapabilities2.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zRunningStateUpdate2 = object({
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zIdleStateUpdate2 = object({
+  stopReason: defaultOnError(zStopReason2.nullish(), () => {
+    return;
+  }),
+  usage: defaultOnError(zUsage2.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zRequiresActionStateUpdate2 = object({
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zUnknownStateUpdate2 = object({
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zStateUpdate2 = preserveCustomPayload(union([
+  zRunningStateUpdate2.and(object({
+    state: literal("running")
+  })),
+  zIdleStateUpdate2.and(object({
+    state: literal("idle")
+  })),
+  zRequiresActionStateUpdate2.and(object({
+    state: literal("requires_action")
+  })),
+  zUnknownStateUpdate2.and(object({
+    state: literal("unknown")
+  })),
+  excludeKnownTags(object({
+    state: string2()
+  }), "state", ["idle", "requires_action", "running", "unknown"])
+]), "state", ["idle", "requires_action", "running", "unknown"]);
+var zSubagentUpdate2 = object({
+  sessionId: zSessionId2,
+  title: defaultOnError(string2().nullish(), () => {
+    return;
+  }),
+  description: defaultOnError(string2().nullish(), () => {
+    return;
+  }),
+  capabilities: defaultOnError(zSubagentSessionCapabilities2.nullish(), () => {
+    return;
+  }),
+  state: defaultOnError(zStateUpdate2.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionMessage2 = object({
+  messageId: zMessageId2,
+  senderSessionId: defaultOnError(zSessionId2.nullish(), () => {
+    return;
+  }),
+  recipientSessionId: defaultOnError(zSessionId2.nullish(), () => {
+    return;
+  }),
+  content: defaultOnError(vecSkipError(zContentBlock2).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionMessageChunk2 = object({
+  messageId: zMessageId2,
+  senderSessionId: defaultOnError(zSessionId2.nullish(), () => {
+    return;
+  }),
+  recipientSessionId: defaultOnError(zSessionId2.nullish(), () => {
+    return;
+  }),
+  content: zContentBlock2,
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
 var zSessionUpdate2 = union([
   zContentChunk2.and(object({
     sessionUpdate: literal("user_message_chunk")
@@ -19903,6 +20084,15 @@ var zSessionUpdate2 = union([
   })),
   zCompactionSummaryChunk2.and(object({
     sessionUpdate: literal("compaction_summary_chunk")
+  })),
+  zSubagentUpdate2.and(object({
+    sessionUpdate: literal("subagent_update")
+  })),
+  zSessionMessage2.and(object({
+    sessionUpdate: literal("session_message")
+  })),
+  zSessionMessageChunk2.and(object({
+    sessionUpdate: literal("session_message_chunk")
   }))
 ]);
 var zSessionNotification = object({
@@ -19918,23 +20108,12 @@ var zCompleteElicitationNotification2 = object({
     return;
   })
 });
-var zMessageMcpNotification2 = object({
-  connectionId: zMcpConnectionId2,
-  method: string2(),
-  params: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
 var zExtNotification2 = unknown();
 var zAgentNotification2 = object({
   method: string2(),
   params: union([
     zSessionNotification,
     zCompleteElicitationNotification2,
-    zMessageMcpNotification2,
     zExtNotification2
   ]).nullish()
 });
@@ -19974,6 +20153,11 @@ var zClientSessionCapabilities = object({
     return;
   })
 });
+var zSubagentCapabilities = object({
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
 var zPlanCapabilities = object({
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
     return;
@@ -20041,6 +20225,9 @@ var zClientCapabilities2 = object({
   session: defaultOnError(zClientSessionCapabilities.nullish(), () => {
     return;
   }),
+  subagents: defaultOnError(zSubagentCapabilities.nullish(), () => {
+    return;
+  }),
   plan: defaultOnError(zPlanCapabilities.nullish(), () => {
     return;
   }),
@@ -20394,7 +20581,6 @@ var zClientRequest2 = object({
     zStartNesRequest2,
     zSuggestNesRequest2,
     zCloseNesRequest2,
-    zMessageMcpRequest2,
     zExtRequest2
   ]).nullish()
 });
@@ -20509,17 +20695,29 @@ var zCreateElicitationResponse2 = preserveCustomPayload(intersection(union([
     return;
   })
 })), "action", ["accept", "cancel", "decline"]);
-var zConnectMcpResponse2 = object({
-  connectionId: zMcpConnectionId2,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
+var zMcpError2 = looseObject({
+  code: int().min(-2147483648, {
+    error: "Invalid value: Expected int32 to be >= -2147483648"
+  }).max(2147483647, {
+    error: "Invalid value: Expected int32 to be <= 2147483647"
+  }),
+  message: string2(),
+  data: unknown().optional()
 });
-var zDisconnectMcpResponse2 = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
+var zMessageMcpResponse2 = union([
+  object({
+    result: unknown(),
+    _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+      return;
+    })
+  }),
+  object({
+    error: zMcpError2,
+    _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+      return;
+    })
   })
-});
+]);
 var zClientResponse2 = union([
   object({
     id: zRequestId2,
@@ -20533,8 +20731,6 @@ var zClientResponse2 = union([
       zWaitForTerminalExitResponse,
       zKillTerminalResponse,
       zCreateElicitationResponse2,
-      zConnectMcpResponse2,
-      zDisconnectMcpResponse2,
       zMessageMcpResponse2,
       zExtResponse2
     ])
@@ -20623,6 +20819,15 @@ var zRejectNesNotification2 = object({
     return;
   })
 });
+var zMessageMcpNotification2 = object({
+  serverId: zMcpServerAcpId2,
+  requestId: zMcpRequestId2,
+  method: string2(),
+  params: record(string2(), unknown()).nullish(),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
+    return;
+  })
+});
 var zClientNotification2 = object({
   method: string2(),
   params: union([
@@ -20675,7 +20880,7 @@ function assertV2BatchMethods(entries, requestMethods, notificationMethods) {
   }
 }
 function parseV2InitializeRequest(params) {
-  const request = zInitializeRequest.parse(params);
+  const request = received(zInitializeRequest).parse(params);
   if (request.protocolVersion !== PROTOCOL_VERSION) {
     throw RequestError.invalidParams({
       expectedProtocolVersion: PROTOCOL_VERSION,
@@ -20692,7 +20897,7 @@ function normalizeOutgoingV2InitializeRequest(params) {
   });
 }
 function mapV2InitializeResponse(response) {
-  const parsed = zInitializeResponse.parse(response);
+  const parsed = received(zInitializeResponse).parse(response);
   if (parsed.protocolVersion !== PROTOCOL_VERSION) {
     throw RequestError.invalidRequest({
       expectedProtocolVersion: PROTOCOL_VERSION,
@@ -20937,9 +21142,7 @@ var methods = {
       update: CLIENT_METHODS.session_update
     },
     mcp: {
-      connect: CLIENT_METHODS.mcp_connect,
-      message: CLIENT_METHODS.mcp_message,
-      disconnect: CLIENT_METHODS.mcp_disconnect
+      message: CLIENT_METHODS.mcp_message
     },
     elicitation: {
       create: CLIENT_METHODS.elicitation_create,
@@ -21453,6 +21656,9 @@ function parseParams(parser, params) {
   }
   return parser.parse(params);
 }
+function received(validator) {
+  return validator;
+}
 function requestSpec(method, params, response, serializeResponse) {
   return { method, params, response, serializeResponse };
 }
@@ -21488,18 +21694,17 @@ var agentRequestSpecs = {
   unstable_listProviders: requestSpec(AGENT_METHODS.providers_list, zListProvidersRequest, zListProvidersResponse),
   unstable_setProvider: requestSpec(AGENT_METHODS.providers_set, zSetProviderRequest, zSetProviderResponse, emptyObjectResponse),
   unstable_disableProvider: requestSpec(AGENT_METHODS.providers_disable, zDisableProviderRequest, zDisableProviderResponse, emptyObjectResponse),
-  newSession: requestSpec(AGENT_METHODS.session_new, zNewSessionRequest, zNewSessionResponse),
-  setSessionConfigOption: requestSpec(AGENT_METHODS.session_set_config_option, zSetSessionConfigOptionRequest, zSetSessionConfigOptionResponse),
-  prompt: requestSpec(AGENT_METHODS.session_prompt, zPromptRequest, zPromptResponse),
-  unstable_messageMcp: requestSpec(AGENT_METHODS.mcp_message, zMessageMcpRequest, zMessageMcpResponse),
+  newSession: requestSpec(AGENT_METHODS.session_new, received(zNewSessionRequest), received(zNewSessionResponse)),
+  setSessionConfigOption: requestSpec(AGENT_METHODS.session_set_config_option, received(zSetSessionConfigOptionRequest), received(zSetSessionConfigOptionResponse)),
+  prompt: requestSpec(AGENT_METHODS.session_prompt, received(zPromptRequest), received(zPromptResponse)),
   listSessions: requestSpec(AGENT_METHODS.session_list, zListSessionsRequest, zListSessionsResponse),
   deleteSession: requestSpec(AGENT_METHODS.session_delete, zDeleteSessionRequest, zDeleteSessionResponse, emptyObjectResponse),
-  unstable_forkSession: requestSpec(AGENT_METHODS.session_fork, zForkSessionRequest, zForkSessionResponse),
-  resumeSession: requestSpec(AGENT_METHODS.session_resume, zResumeSessionRequest, zResumeSessionResponse),
+  unstable_forkSession: requestSpec(AGENT_METHODS.session_fork, received(zForkSessionRequest), received(zForkSessionResponse)),
+  resumeSession: requestSpec(AGENT_METHODS.session_resume, received(zResumeSessionRequest), received(zResumeSessionResponse)),
   closeSession: requestSpec(AGENT_METHODS.session_close, zCloseSessionRequest, zCloseSessionResponse, emptyObjectResponse),
   logoutAuth: requestSpec(AGENT_METHODS.auth_logout, zLogoutAuthRequest, zLogoutAuthResponse, emptyObjectResponse),
   unstable_startNes: requestSpec(AGENT_METHODS.nes_start, zStartNesRequest, zStartNesResponse),
-  unstable_suggestNes: requestSpec(AGENT_METHODS.nes_suggest, zSuggestNesRequest, zSuggestNesResponse),
+  unstable_suggestNes: requestSpec(AGENT_METHODS.nes_suggest, received(zSuggestNesRequest), received(zSuggestNesResponse)),
   unstable_closeNes: requestSpec(AGENT_METHODS.nes_close, zCloseNesRequest, zCloseNesResponse, emptyObjectResponse)
 };
 var agentNotificationSpecs = {
@@ -21514,15 +21719,12 @@ var agentNotificationSpecs = {
   unstable_rejectNes: notificationSpec(AGENT_METHODS.nes_reject, zRejectNesNotification)
 };
 var clientRequestSpecs = {
-  requestPermission: requestSpec(CLIENT_METHODS.session_request_permission, zRequestPermissionRequest, zRequestPermissionResponse),
-  unstable_connectMcp: requestSpec(CLIENT_METHODS.mcp_connect, zConnectMcpRequest, zConnectMcpResponse),
+  requestPermission: requestSpec(CLIENT_METHODS.session_request_permission, received(zRequestPermissionRequest), received(zRequestPermissionResponse)),
   unstable_messageMcp: requestSpec(CLIENT_METHODS.mcp_message, zMessageMcpRequest, zMessageMcpResponse),
-  unstable_disconnectMcp: requestSpec(CLIENT_METHODS.mcp_disconnect, zDisconnectMcpRequest, zDisconnectMcpResponse, emptyObjectResponse),
-  createElicitation: requestSpec(CLIENT_METHODS.elicitation_create, zCreateElicitationRequest, zCreateElicitationResponse)
+  createElicitation: requestSpec(CLIENT_METHODS.elicitation_create, received(zCreateElicitationRequest), received(zCreateElicitationResponse))
 };
 var clientNotificationSpecs = {
-  sessionUpdate: notificationSpec(CLIENT_METHODS.session_update, zUpdateSessionNotification),
-  unstable_messageMcp: notificationSpec(CLIENT_METHODS.mcp_message, zMessageMcpNotification),
+  sessionUpdate: notificationSpec(CLIENT_METHODS.session_update, received(zUpdateSessionNotification)),
   completeElicitation: notificationSpec(CLIENT_METHODS.elicitation_complete, zCompleteElicitationNotification)
 };
 var agentRequestSpecsByMethod = specsByMethod(agentRequestSpecs);
@@ -21566,7 +21768,7 @@ class SessionUpdateRouter {
     if (message.kind !== "notification" || message.method !== CLIENT_METHODS.session_update) {
       return Handled.no(message);
     }
-    const notification = zUpdateSessionNotification.parse(message.params);
+    const notification = received(zUpdateSessionNotification).parse(message.params);
     const { update } = notification;
     const isIdle = SessionUpdate.isStateUpdate(update) && StateUpdate.isIdle(update);
     const activeSessions = this.activeSessions.get(notification.sessionId);
@@ -21844,7 +22046,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "0.7.4",
+  version: "0.7.5",
   description: "Native ACP v2 agent for the OpenAI Codex app-server",
   packageManager: "bun@1.4.0",
   engines: {
@@ -21910,7 +22112,7 @@ var package_default = {
     vitest: "^4.1.11"
   },
   dependencies: {
-    "@agentclientprotocol/sdk": "^1.5.1",
+    "@agentclientprotocol/sdk": "^1.7.0",
     diff: "^9.0.0",
     open: "^11.0.2",
     "vscode-jsonrpc": "^9.0.2"
@@ -22104,7 +22306,7 @@ function classifyTurnError(info) {
 }
 
 // src/agent/CodexAgent.ts
-import path7 from "path";
+import path8 from "path";
 
 // src/util/logger.ts
 import fs from "fs";
@@ -23664,6 +23866,21 @@ function itemSnapshot(item) {
   }
 }
 
+// src/bridge/turnMetadata.ts
+function withTurnId(update, turnId, startedAt) {
+  switch (update.sessionUpdate) {
+    case "user_message":
+    case "agent_message":
+    case "agent_message_chunk": {
+      const meta = update._meta;
+      const codex = meta?.["codex"];
+      return { ...update, _meta: { ...meta, codex: { ...codex, turnId, ...startedAt == null ? {} : { turnStartedAt: startedAt * 1000 } } } };
+    }
+    default:
+      return update;
+  }
+}
+
 // src/bridge/EventBridge.ts
 var TURN_PLAN_ID = "codex-turn-plan";
 var PLAN_STREAM_INTERVAL_MS = 150;
@@ -23675,6 +23892,7 @@ class EventBridge {
   lastError = null;
   completedPlan = null;
   noticeSequence = 0;
+  turnTime = null;
   openToolCalls = new Set;
   announcedTools = new Set;
   messagePhases = new Map;
@@ -23717,17 +23935,21 @@ class EventBridge {
     this.completedPlan = null;
     return plan;
   }
-  async restore(items) {
+  async restore(items, turnId) {
     for (const item of items) {
       if (item.type === "commandExecution" && item.status === "inProgress" && usesTerminal(item))
         this.terminalItems.add(item.id);
       for (const update of itemSnapshot(item)) {
         this.trackToolCall(update);
-        await this.client.update(update);
+        await this.client.update(withTurnId(update, turnId));
       }
     }
   }
   async handle(notification) {
+    if (notification.method === "turn/started" || notification.method === "turn/completed") {
+      const { id, startedAt } = notification.params.turn;
+      this.turnTime = { id, startedAt };
+    }
     let updates = await this.translate(notification);
     if (notification.method === "item/completed") {
       const snapshots = itemSnapshot(notification.params.item);
@@ -23738,7 +23960,8 @@ class EventBridge {
     }
     for (const update of updates) {
       this.trackToolCall(update);
-      await this.client.update(update);
+      const turnId = "turnId" in notification.params ? notification.params.turnId : null;
+      await this.client.update(typeof turnId === "string" ? withTurnId(update, turnId, this.turnTime?.id === turnId ? this.turnTime.startedAt : null) : update);
     }
   }
   async finishOpenToolCalls(status) {
@@ -26630,7 +26853,7 @@ function historyUpdates(turns) {
   const updates = [];
   for (const turn of turns) {
     for (const item of turn.items) {
-      updates.push(...itemSnapshot(item));
+      updates.push(...itemSnapshot(item).map((update) => withTurnId(update, turn.id, turn.startedAt)));
     }
   }
   return updates;
@@ -26656,6 +26879,93 @@ function firstLine(text2) {
   return line.length > 120 ? `${line.slice(0, 117)}...` : line;
 }
 
+// src/agent/forkIndex.ts
+import { createReadStream } from "fs";
+import { readdir, realpath } from "fs/promises";
+import path7 from "path";
+import { createInterface } from "readline";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var SOURCES = new Set(["cli", "vscode", "exec", "appServer", "unknown"]);
+var missing = (error40) => error40?.code === "ENOENT";
+async function nativeForks(codexHome, archived, cwd, read) {
+  const root = path7.join(codexHome, archived ? "archived_sessions" : "sessions");
+  const wantedCwd = cwd === null ? null : await realpath(cwd).catch((error40) => {
+    if (missing(error40))
+      return cwd;
+    throw error40;
+  });
+  const result = [];
+  for await (const file2 of rolloutFiles(root)) {
+    const header = await firstLine2(file2);
+    if (header === null)
+      continue;
+    let value;
+    try {
+      value = JSON.parse(header);
+    } catch {
+      continue;
+    }
+    if (!value || typeof value !== "object" || !("type" in value) || value.type !== "session_meta" || !("payload" in value))
+      continue;
+    const meta = value.payload;
+    if (!meta || typeof meta["id"] !== "string" || !UUID.test(meta["id"]) || typeof meta["forked_from_id"] !== "string" || !UUID.test(meta["forked_from_id"]) || typeof meta["source"] !== "string" || !SOURCES.has(meta["source"]) || wantedCwd !== null && meta["cwd"] !== wantedCwd && meta["cwd"] !== cwd)
+      continue;
+    const thread = await read(meta["id"]).catch(async (error40) => {
+      try {
+        await realpath(file2);
+      } catch (statError) {
+        if (missing(statError))
+          return null;
+      }
+      throw error40;
+    });
+    if (thread && thread.forkedFromId !== null) {
+      try {
+        await realpath(file2);
+      } catch (error40) {
+        if (missing(error40))
+          continue;
+        throw error40;
+      }
+      result.push(cwd === null ? thread : { ...thread, cwd });
+    }
+  }
+  return result;
+}
+async function* rolloutFiles(directory) {
+  let entries;
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error40) {
+    if (missing(error40))
+      return;
+    throw error40;
+  }
+  for (const entry of entries) {
+    const file2 = path7.join(directory, entry.name);
+    if (entry.isDirectory())
+      yield* rolloutFiles(file2);
+    else if (entry.isFile() && /^rollout-.*\.jsonl$/.test(entry.name))
+      yield file2;
+  }
+}
+async function firstLine2(file2) {
+  const stream = createReadStream(file2, { encoding: "utf8" });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of lines)
+      return line;
+    return null;
+  } catch (error40) {
+    if (missing(error40))
+      return null;
+    throw error40;
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+
 // src/agent/session.ts
 function createActiveTurn(threadId, clientUserMessageId = null) {
   let resolveStarted = () => {};
@@ -26723,6 +27033,7 @@ class CodexAgent {
   sessions = new Map;
   capabilities = null;
   codexInitialized = false;
+  codexHome = null;
   initializing = null;
   terminalTurns = new WeakSet;
   completedTurns = new WeakMap;
@@ -26773,10 +27084,11 @@ class CodexAgent {
     };
     if (!this.codexInitialized) {
       this.initializing ??= this.withCodex(async () => {
-        await this.codex.initialize({
+        const initialized = await this.codex.initialize({
           clientInfo: { name: params.info.name, title: params.info.title ?? null, version: params.info.version },
           capabilities: { experimentalApi: true, requestAttestation: false }
         });
+        this.codexHome = initialized.codexHome;
         this.codexInitialized = true;
       }).finally(() => {
         this.initializing = null;
@@ -26796,7 +27108,7 @@ class CodexAgent {
           additionalDirectories: {}
         },
         providers: {},
-        _meta: { alwith: { tools: { version: 1 }, turns: { version: 2 } }, codex: { archive: true, seedHistory: true, skills: true, plugins: true, providerCatalog: true, rename: true, account: true, fuzzyFileSearch: true } }
+        _meta: { alwith: { tools: { version: 1 }, turns: { version: 2 } }, codex: { forkAtTurn: true, sessionLineage: true, archive: true, seedHistory: true, skills: true, plugins: true, providerCatalog: true, rename: true, account: true, fuzzyFileSearch: true } }
       },
       authMethods: authMethods(this.capabilities, this.env)
     };
@@ -26971,16 +27283,16 @@ class CodexAgent {
   }
   async newSession(params, signal) {
     const runtime = await this.openSession({ kind: "new", request: params }, signal);
-    return { sessionId: runtime.session.id, configOptions: sessionConfigOptions(runtime.session) };
+    return { sessionId: runtime.session.id, configOptions: sessionConfigOptions(runtime.session), _meta: { codex: runtime.lineage } };
   }
   async resumeSession(params, signal) {
     const runtime = await this.openSession({ kind: "resume", request: params }, signal);
     const configOptions = sessionConfigOptions(runtime.session);
-    return runtime.readOnly ? { configOptions, _meta: { codex: { readOnly: true, reason: "active_writer" } } } : { configOptions };
+    return { configOptions, _meta: { codex: { ...runtime.lineage, ...runtime.readOnly ? { readOnly: true, reason: "active_writer" } : {} } } };
   }
   async forkSession(params, signal) {
     const runtime = await this.openSession({ kind: "fork", request: params }, signal);
-    return { sessionId: runtime.session.id, configOptions: sessionConfigOptions(runtime.session) };
+    return { sessionId: runtime.session.id, configOptions: sessionConfigOptions(runtime.session), _meta: { codex: runtime.lineage } };
   }
   async openSession(open2, signal) {
     if (signal?.aborted)
@@ -27012,7 +27324,8 @@ class CodexAgent {
     if (open2.kind !== "new")
       this.assertUnsubscribeSettled(open2.request.sessionId);
     const { request } = open2;
-    if (typeof request.cwd !== "string" || !path7.isAbsolute(request.cwd)) {
+    const lastTurnId = open2.kind === "fork" ? forkTurnId(request._meta) : undefined;
+    if (typeof request.cwd !== "string" || !path8.isAbsolute(request.cwd)) {
       throw RequestError.invalidParams({ cwd: request.cwd }, "cwd must be an absolute path");
     }
     if (open2.kind === "resume" && open2.request.replayFrom != null && open2.request.replayFrom.type !== "start") {
@@ -27077,7 +27390,7 @@ class CodexAgent {
             return readOnlyThread((await this.codex.threadRead({ threadId: open2.request.sessionId, includeTurns: false })).thread, request.cwd);
           }
         case "fork":
-          return await this.codex.threadFork({ ...hostThreadOptions, threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
+          return await this.codex.threadFork({ ...hostThreadOptions, ...lastTurnId === undefined ? {} : { lastTurnId }, threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, model: startModel, excludeTurns: true });
       }
     }) }));
     const sessionId = thread.thread.id;
@@ -27127,7 +27440,7 @@ class CodexAgent {
         contextWindow: null,
         closed: false
       };
-      const runtime = this.installRuntime(session, capabilities, config2, gatewayId ?? thread.modelProvider, readOnly);
+      const runtime = this.installRuntime(session, capabilities, config2, gatewayId ?? thread.modelProvider, threadLineage(thread.thread), readOnly);
       const cancelOpening = () => {
         runtime.session.closed = true;
         runtime.lifetime.abort();
@@ -27174,7 +27487,7 @@ class CodexAgent {
       stopObservingOpen();
     }
   }
-  installRuntime(session, capabilities, config2, modelProvider, readOnly = false) {
+  installRuntime(session, capabilities, config2, modelProvider, lineage, readOnly = false) {
     const client = new ClientSession(session.id, this.link, capabilities);
     const bridge = new EventBridge(client, session);
     const turnContext = new TurnContext(session.id);
@@ -27184,7 +27497,7 @@ class CodexAgent {
     };
     const approval = new CodexApprovalHandler(client, turnContext, signal);
     const elicitation = new CodexElicitationHandler(client, turnContext, signal);
-    const runtime = { config: config2, modelProvider, stale: false, readOnly, session, client, bridge, turnContext, elicitation, lifetime: new AbortController, queue: Promise.resolve() };
+    const runtime = { lineage, config: config2, modelProvider, stale: false, readOnly, session, client, bridge, turnContext, elicitation, lifetime: new AbortController, queue: Promise.resolve() };
     const tools = new ClientTools(session, client, AbortSignal.any([runtime.lifetime.signal, this.codex.disconnectSignal]));
     const drained = (operation) => async (params) => {
       await abortable(this.drain(runtime), this.codex.disconnectSignal);
@@ -27271,10 +27584,31 @@ class CodexAgent {
       await publishTitle(firstPage.data);
       return;
     }
+    const parentTurns = new Set;
+    if (thread.forkedFromId !== null) {
+      let parentCursor = null;
+      const seen = new Set;
+      do {
+        const page = await this.withCodex(() => this.codex.threadTurnsList({ threadId: thread.forkedFromId, cursor: parentCursor, limit: HISTORY_PAGE_SIZE, sortDirection: "asc", itemsView: "summary" }));
+        for (const turn of page.data)
+          parentTurns.add(turn.id);
+        parentCursor = page.nextCursor;
+        if (parentCursor !== null) {
+          if (seen.has(parentCursor))
+            throw RequestError.internalError(undefined, "Codex parent history repeated a cursor");
+          seen.add(parentCursor);
+        }
+      } while (parentCursor !== null && !session.closed);
+      runtime.lineage.forkedAtTurnId = null;
+    }
     const cursors = new Set;
     let cursor = null;
     do {
       const page = await this.turnPage(session.id, cursor);
+      for (const turn of page.data) {
+        if (parentTurns.has(turn.id))
+          runtime.lineage.forkedAtTurnId = turn.id;
+      }
       await publishTitle(page.data);
       await client.updateAll(historyUpdates(page.data));
       cursor = page.nextCursor;
@@ -27322,19 +27656,43 @@ class CodexAgent {
     this.requireInitialized("session/list");
     const cwd = params.cwd?.trim() || null;
     const archived = archivedFilter(params._meta);
-    const response = await this.withCodex(() => this.codex.threadList({
-      cursor: params.cursor ?? null,
+    const list = (cursor) => this.withCodex(() => this.codex.threadList({
+      cursor,
       ...cwd ? { cwd } : {},
       sourceKinds: ["cli", "vscode", "exec", "appServer", "unknown"],
       ...archived ? { archived: true } : {}
     }));
+    const response = await list(params.cursor ?? null);
+    const home = this.codexHome;
+    if (home === null)
+      throw RequestError.internalError(undefined, "Codex home is unavailable after initialize");
+    const forks = await this.withCodex(() => nativeForks(home, archived, cwd, async (id) => (await this.codex.threadRead({ threadId: id, includeTurns: false })).thread));
+    const byId = new Map(forks.map((thread) => [thread.id, thread]));
+    response.data = response.data.map((thread) => byId.get(thread.id) ?? thread);
+    if (!params.cursor) {
+      const missing2 = new Map(byId);
+      for (const thread of response.data)
+        missing2.delete(thread.id);
+      let cursor = response.nextCursor;
+      const cursors = new Set;
+      while (missing2.size > 0 && cursor !== null) {
+        if (cursors.has(cursor))
+          throw RequestError.internalError(undefined, "Codex thread list repeated a cursor");
+        cursors.add(cursor);
+        const page = await list(cursor);
+        for (const thread of page.data)
+          missing2.delete(thread.id);
+        cursor = page.nextCursor;
+      }
+      response.data.push(...missing2.values());
+    }
     return {
       sessions: response.data.map((thread) => ({
         sessionId: thread.id,
         cwd: thread.cwd,
         title: thread.name?.trim() || thread.preview.trim() || null,
         updatedAt: new Date(thread.updatedAt * 1000).toISOString(),
-        _meta: { codex: { archived } }
+        _meta: { codex: { archived, ...threadLineage(thread) } }
       })),
       nextCursor: response.nextCursor
     };
@@ -27600,8 +27958,12 @@ class CodexAgent {
   async runPrompt(runtime, turn, params, observed, items = []) {
     const { session, bridge } = runtime;
     bridge.beginTurn();
-    if (items.length)
-      runtime.queue = runtime.queue.then(() => bridge.restore(items));
+    if (items.length) {
+      const turnId = turn.turnId;
+      if (turnId === null)
+        throw RequestError.internalError(undefined, "Cannot restore items without their turn id");
+      runtime.queue = runtime.queue.then(() => bridge.restore(items, turnId));
+    }
     try {
       const command = parseCommand(params.prompt);
       const outcome = command ? resolveCommand(command, session) : { kind: "prompt" };
@@ -27861,7 +28223,7 @@ ${error40.additionalDetails}` : error40.message;
   }
   withSkillsContext(cwd, additionalDirectories, operation) {
     const run = async () => {
-      const roots = additionalDirectories.map((root) => path7.join(root, ".agents", "skills"));
+      const roots = additionalDirectories.map((root) => path8.join(root, ".agents", "skills"));
       if (roots.length !== this.skillRoots.length || roots.some((root, index) => root !== this.skillRoots[index])) {
         this.changingSkillRoots = true;
         try {
@@ -27895,7 +28257,7 @@ ${error40.additionalDetails}` : error40.message;
   }
   async refreshAvailableCommands(runtime) {
     const run = async () => {
-      const roots = runtime.session.additionalDirectories.map((root) => path7.join(root, ".agents", "skills"));
+      const roots = runtime.session.additionalDirectories.map((root) => path8.join(root, ".agents", "skills"));
       if (runtime.session.closed || roots.length !== this.skillRoots.length || roots.some((root, i) => root !== this.skillRoots[i]))
         return;
       return await this.loadSkills(runtime.session.cwd, runtime.session.additionalDirectories);
@@ -28130,6 +28492,18 @@ async function within(operation, ms) {
     clearTimeout(timer);
   }
 }
+function threadLineage(thread) {
+  return { nativeSessionId: thread.sessionId, forkedFromId: thread.forkedFromId };
+}
+function forkTurnId(meta) {
+  const value = meta?.codex?.lastTurnId;
+  if (value === undefined)
+    return;
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw RequestError.invalidParams(undefined, "lastTurnId must be a non-empty Codex turn id");
+  }
+  return value;
+}
 
 // src/agent/createAgent.ts
 function createAgentApp(options) {
@@ -28608,7 +28982,7 @@ function threadIdOf(notification) {
 // src/codex/process.ts
 import { existsSync, mkdtempSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import os3 from "os";
-import path8 from "path";
+import path9 from "path";
 import { spawn, spawnSync } from "child_process";
 import { createRequire } from "module";
 
@@ -28901,11 +29275,11 @@ function resolveCodexLauncher(codexPath) {
     const target = targets[platform2];
     if (!target)
       throw new Error(`Unsupported Codex platform: ${platform2}`);
-    let vendor = path8.resolve(path8.dirname(launcher), "..", "vendor");
+    let vendor = path9.resolve(path9.dirname(launcher), "..", "vendor");
     try {
-      vendor = path8.join(path8.dirname(platformRequire.resolve(`@openai/codex-${platform2}/package.json`)), "vendor");
+      vendor = path9.join(path9.dirname(platformRequire.resolve(`@openai/codex-${platform2}/package.json`)), "vendor");
     } catch {}
-    const command = path8.join(vendor, target, "bin", process.platform === "win32" ? "codex.exe" : "codex");
+    const command = path9.join(vendor, target, "bin", process.platform === "win32" ? "codex.exe" : "codex");
     if (!existsSync(command))
       throw new Error(`Missing Codex platform binary: ${command}`);
     return { command, prefixArgs: [], shell: false };
@@ -28951,7 +29325,7 @@ function mergedModelCatalog(launcher, env) {
   const raw = env[EXTRA_MODEL_CATALOGS_ENV];
   if (raw === undefined || raw.trim() === "")
     return null;
-  const files = raw.split(path8.delimiter).filter((file2) => file2.length > 0);
+  const files = raw.split(path9.delimiter).filter((file2) => file2.length > 0);
   const dump = spawnSync(launcher.command, [...launcher.prefixArgs, "debug", "models"], {
     shell: launcher.shell,
     env,
@@ -28979,8 +29353,8 @@ function mergedModelCatalog(launcher, env) {
       models.push({ ...entry, visibility: "hide" });
     }
   }
-  const directory = mkdtempSync(path8.join(os3.tmpdir(), "codex-acp-v2-catalog-"));
-  const target = path8.join(directory, "models.json");
+  const directory = mkdtempSync(path9.join(os3.tmpdir(), "codex-acp-v2-catalog-"));
+  const target = path9.join(directory, "models.json");
   writeFileSync(target, JSON.stringify({ ...base, models }));
   return target;
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Native ACP v2 agent for the OpenAI Codex app-server",
   "packageManager": "bun@1.4.0",
   "engines": {
@@ -69,7 +69,7 @@
     "vitest": "^4.1.11"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "^1.5.1",
+    "@agentclientprotocol/sdk": "^1.7.0",
     "diff": "^9.0.0",
     "open": "^11.0.2",
     "vscode-jsonrpc": "^9.0.2"