@evalops/maestro 0.10.18 → 0.10.20

package/dist/cli/headless-protocol.js

@@ -1,13 +1,20 @@
 import { constants } from "node:fs";
 import { access, readFile, stat } from "node:fs/promises";
 import { basename } from "node:path";
-import { headlessProtocolVersion, } from "@evalops/contracts";
+import { headlessConnectionRoles, headlessProtocolVersion, headlessServerRequestTypes, headlessUtilityOperations, } from "@evalops/contracts";
 import { lookup as lookupMimeType } from "mime-types";
+import { CODEX_SUBAGENT_TOOL_PREFIX, CODEX_SUBAGENT_WORK_GRAPH_SCHEMA, codexSubagentActiveStatus, codexSubagentOperationName, codexSubagentTerminalSuccessStatus, } from "../codex/subagent-workgraph.js";
 import { appendHeadlessOutput } from "../headless/output-buffer.js";
 import { isSupportedImageFormat } from "../tools/image-processor.js";
 import { getCurrentBranch, isInsideGitRepository } from "../utils/git.js";
 import { normalizePath } from "../utils/path-validation.js";
 import { summarizeToolUse } from "../utils/tool-use-summary.js";
+export const HEADLESS_SERVER_CAPABILITIES = {
+    server_requests: [...headlessServerRequestTypes],
+    utility_operations: [...headlessUtilityOperations],
+    raw_agent_events: true,
+    connection_roles: [...headlessConnectionRoles],
+};
 export const HEADLESS_PROTOCOL_VERSION = headlessProtocolVersion;
 export function buildHeadlessRawAgentEventMessage(event) {
     return {
@@ -31,6 +38,7 @@ export function createHeadlessRuntimeState() {
         active_utility_commands: [],
         active_file_watches: [],
         tracked_tools: [],
+        codex_subagent_edges: [],
         is_ready: false,
         is_responding: false,
     };
@@ -45,6 +53,9 @@ function toUnifiedPendingRequestState(kind, request, sessionId) {
         ...(sessionId !== undefined ? { session_id: sessionId } : {}),
         tool_call_id: request.call_id,
         call_id: request.call_id,
+        ...(request.tool_execution_id
+            ? { tool_execution_id: request.tool_execution_id }
+            : {}),
         ...(request.request_id ? { request_id: request.request_id } : {}),
         tool_name: request.tool,
         tool: request.tool,
@@ -54,6 +65,9 @@ function toUnifiedPendingRequestState(kind, request, sessionId) {
             ? { action_description: request.action_description }
             : {}),
         args: request.args,
+        ...(request.started_at_ms !== undefined
+            ? { started_at_ms: request.started_at_ms }
+            : {}),
         source: "local",
     };
 }
@@ -68,6 +82,312 @@ export function syncHeadlessPendingRequests(state) {
     ];
     return state.pending_requests;
 }
+export { CODEX_SUBAGENT_TOOL_PREFIX, CODEX_SUBAGENT_WORK_GRAPH_SCHEMA };
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+export function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+export function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && item.length > 0)
+        : [];
+}
+export function codexSubagentOperation(tool) {
+    return codexSubagentOperationName(tool);
+}
+export function activeCodexSubagentStatus(operation) {
+    return codexSubagentActiveStatus(operation) ?? "waiting_for_restore";
+}
+export function codexSubagentStatusIsTerminal(status) {
+    switch ((status ?? "").toLowerCase().replace(/[-\s]+/g, "_")) {
+        case "closed":
+        case "explicitly_closed":
+        case "succeeded":
+        case "success":
+        case "completed":
+        case "complete":
+        case "done":
+        case "acknowledged":
+        case "failed":
+        case "failure":
+        case "error":
+        case "cancelled":
+        case "canceled":
+            return true;
+        default:
+            return false;
+    }
+}
+function terminalCodexSubagentStatus(operation, success) {
+    if (!success) {
+        return "failed";
+    }
+    return codexSubagentTerminalSuccessStatus(operation) ?? "completed";
+}
+export function collectCodexChildRuns(args) {
+    if (!isRecord(args)) {
+        return [];
+    }
+    const childRunIds = stringArray(args.childRunIds ?? args.child_run_ids);
+    const threadIds = stringArray(args.receiverThreadIds ?? args.receiver_thread_ids);
+    const graph = args.codexWorkGraph ?? args.codex_work_graph;
+    const graphRuns = [];
+    if (isRecord(graph)) {
+        const graphChildRuns = graph.childRuns ?? graph.child_runs;
+        for (const childRun of Array.isArray(graphChildRuns)
+            ? graphChildRuns
+            : []) {
+            if (!isRecord(childRun)) {
+                continue;
+            }
+            graphRuns.push({
+                child_run_id: nonEmptyString(childRun.childRunId ?? childRun.child_run_id),
+                thread_id: nonEmptyString(childRun.threadId ?? childRun.thread_id),
+                status: nonEmptyString(childRun.status ?? childRun.targetStatus ?? childRun.target_status),
+            });
+        }
+    }
+    const count = Math.max(childRunIds.length, threadIds.length, graphRuns.length, 1);
+    const runs = [];
+    for (let index = 0; index < count; index += 1) {
+        const threadId = threadIds[index] ?? graphRuns[index]?.thread_id;
+        const status = graphRuns[index]?.status ?? codexAgentStateStatus(args, threadId);
+        runs.push({
+            child_run_id: childRunIds[index] ?? graphRuns[index]?.child_run_id,
+            thread_id: threadId,
+            ...(status ? { status } : {}),
+        });
+    }
+    return runs.filter((run) => run.child_run_id || run.thread_id);
+}
+function codexAgentStateStatus(args, threadId) {
+    if (!threadId) {
+        return undefined;
+    }
+    const agentsStates = args.agentsStates ?? args.agents_states;
+    if (!isRecord(agentsStates)) {
+        return undefined;
+    }
+    const agentState = agentsStates[threadId];
+    if (!isRecord(agentState)) {
+        return undefined;
+    }
+    return nonEmptyString(agentState.status);
+}
+function hasCodexSubagentArgs(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (hasCodexWorkGraph(value) ||
+        stringArray(value.childRunIds ?? value.child_run_ids).length > 0 ||
+        stringArray(value.receiverThreadIds ?? value.receiver_thread_ids).length > 0);
+}
+function mergeRecordArgs(base, patch) {
+    return {
+        ...(isRecord(base) ? base : {}),
+        ...patch,
+    };
+}
+function codexSubagentToolEndArgs(sourceArgs, details) {
+    if (!isRecord(details)) {
+        return sourceArgs;
+    }
+    const wrappedArgs = details.args;
+    if (isRecord(wrappedArgs)) {
+        return mergeRecordArgs(sourceArgs, wrappedArgs);
+    }
+    if (hasCodexSubagentArgs(details)) {
+        return mergeRecordArgs(sourceArgs, details);
+    }
+    return sourceArgs;
+}
+const CODEX_SUBAGENT_DETAIL_KEYS = [
+    "codexTool",
+    "codex_tool",
+    "status",
+    "threadId",
+    "thread_id",
+    "turnId",
+    "turn_id",
+    "senderThreadId",
+    "sender_thread_id",
+    "receiverThreadIds",
+    "receiver_thread_ids",
+    "childRunIds",
+    "child_run_ids",
+    "codexWorkGraph",
+    "codex_work_graph",
+    "agentsStates",
+    "agents_states",
+];
+const CODEX_SUBAGENT_DETAIL_REDACTED_KEYS = new Set([
+    "prompt",
+    "model",
+    "reasoningEffort",
+    "reasoning_effort",
+]);
+function hasCodexWorkGraph(args) {
+    if (!isRecord(args)) {
+        return false;
+    }
+    const graph = args.codexWorkGraph ?? args.codex_work_graph;
+    return (isRecord(graph) &&
+        (graph.schemaVersion === CODEX_SUBAGENT_WORK_GRAPH_SCHEMA ||
+            graph.schema_version === CODEX_SUBAGENT_WORK_GRAPH_SCHEMA));
+}
+function sanitizeCodexSubagentDetailValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeCodexSubagentDetailValue(item));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (CODEX_SUBAGENT_DETAIL_REDACTED_KEYS.has(key)) {
+            continue;
+        }
+        out[key] = sanitizeCodexSubagentDetailValue(child);
+    }
+    return out;
+}
+function codexSubagentToolEndDetails(toolName, details) {
+    if (!toolName.startsWith(CODEX_SUBAGENT_TOOL_PREFIX) || !isRecord(details)) {
+        return undefined;
+    }
+    const out = {};
+    for (const key of CODEX_SUBAGENT_DETAIL_KEYS) {
+        if (details[key] !== undefined) {
+            out[key] = sanitizeCodexSubagentDetailValue(details[key]);
+        }
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+export function codexSubagentEdgeKey(edge) {
+    return [
+        edge.spawn_tool_call_id ?? "",
+        edge.wait_tool_call_id ?? "",
+        edge.child_run_id ?? "",
+        edge.thread_id ?? "",
+        edge.operation,
+    ].join("\u0000");
+}
+export function buildCodexSubagentContinuityEdges(input) {
+    const operation = codexSubagentOperation(input.tool);
+    if (!operation) {
+        return [];
+    }
+    const base = {
+        operation,
+        status: input.status,
+        ...(operation === "spawn_agent"
+            ? {
+                spawn_tool_call_id: input.call_id,
+                ...(input.tool_execution_id
+                    ? { spawn_tool_execution_id: input.tool_execution_id }
+                    : {}),
+            }
+            : {
+                wait_tool_call_id: input.call_id,
+                ...(input.tool_execution_id
+                    ? { wait_tool_execution_id: input.tool_execution_id }
+                    : {}),
+            }),
+    };
+    const childRuns = collectCodexChildRuns(input.args);
+    return childRuns.length > 0
+        ? childRuns.map((childRun) => ({
+            ...base,
+            ...(childRun.child_run_id
+                ? { child_run_id: childRun.child_run_id }
+                : {}),
+            ...(childRun.thread_id ? { thread_id: childRun.thread_id } : {}),
+            status: childRun.status ?? base.status,
+        }))
+        : [base];
+}
+function upsertCodexSubagentContinuityEdges(state, input) {
+    const operation = codexSubagentOperation(input.tool);
+    if (!operation ||
+        (!input.tool.startsWith(CODEX_SUBAGENT_TOOL_PREFIX) &&
+            !hasCodexWorkGraph(input.args))) {
+        return;
+    }
+    const edges = buildCodexSubagentContinuityEdges(input);
+    state.codex_subagent_edges ??= [];
+    const existing = new Map(state.codex_subagent_edges.map((edge) => [
+        codexSubagentEdgeKey(edge),
+        edge,
+    ]));
+    if (edges.some((edge) => edge.child_run_id || edge.thread_id)) {
+        for (const [key, edge] of existing) {
+            const sameToolCall = edge.spawn_tool_call_id === input.call_id ||
+                edge.wait_tool_call_id === input.call_id;
+            if (sameToolCall &&
+                edge.operation === operation &&
+                !edge.child_run_id &&
+                !edge.thread_id) {
+                existing.delete(key);
+            }
+        }
+    }
+    for (const edge of edges) {
+        existing.set(codexSubagentEdgeKey(edge), edge);
+    }
+    if ((input.status === "closed" || input.status === "completed") &&
+        (operation === "close_agent" || operation === "wait_agent")) {
+        const closedChildIds = new Set(edges.map((edge) => edge.child_run_id).filter(Boolean));
+        const closedThreadIds = new Set(edges.map((edge) => edge.thread_id).filter(Boolean));
+        for (const [key, edge] of existing) {
+            if (edge.operation === operation ||
+                codexSubagentStatusIsTerminal(edge.status)) {
+                continue;
+            }
+            const sameChild = (edge.child_run_id && closedChildIds.has(edge.child_run_id)) ||
+                (edge.thread_id && closedThreadIds.has(edge.thread_id));
+            if (sameChild) {
+                existing.set(key, { ...edge, status: "completed" });
+            }
+        }
+    }
+    state.codex_subagent_edges = [...existing.values()].sort((left, right) => codexSubagentEdgeKey(left).localeCompare(codexSubagentEdgeKey(right)));
+}
+function markCodexSubagentEdgesFailedForCall(state, callId) {
+    if (!callId) {
+        return;
+    }
+    state.codex_subagent_edges ??= [];
+    state.codex_subagent_edges = state.codex_subagent_edges
+        .map((edge) => {
+        const matches = edge.spawn_tool_call_id === callId || edge.wait_tool_call_id === callId;
+        if (!matches || codexSubagentStatusIsTerminal(edge.status)) {
+            return edge;
+        }
+        return { ...edge, status: "failed" };
+    })
+        .sort((left, right) => codexSubagentEdgeKey(left).localeCompare(codexSubagentEdgeKey(right)));
+}
+function failCodexSubagentContinuityEdge(state, callId) {
+    const source = state.tracked_tools.find((tool) => tool.call_id === callId) ??
+        state.pending_approvals.find((approval) => approval.call_id === callId) ??
+        state.pending_client_tools.find((request) => request.call_id === callId) ??
+        state.pending_mcp_elicitations.find((request) => request.call_id === callId) ??
+        state.pending_user_inputs.find((request) => request.call_id === callId) ??
+        state.pending_tool_retries.find((request) => request.call_id === callId);
+    const operation = source ? codexSubagentOperation(source.tool) : undefined;
+    if (source && operation) {
+        upsertCodexSubagentContinuityEdges(state, {
+            call_id: callId,
+            tool_execution_id: source.tool_execution_id,
+            tool: source.tool,
+            args: source.args,
+            status: terminalCodexSubagentStatus(operation, false),
+        });
+    }
+    markCodexSubagentEdgesFailedForCall(state, callId);
+}
 export function headlessViewerCanSend(msg) {
     switch (msg.type) {
         case "hello":
@@ -107,6 +427,9 @@ function getPendingRequestId(request) {
 function toPendingRequestState(params) {
     return {
         call_id: params.call_id,
+        ...(params.tool_execution_id
+            ? { tool_execution_id: params.tool_execution_id }
+            : {}),
         ...(params.request_id !== params.call_id
             ? { request_id: params.request_id }
             : {}),
@@ -117,6 +440,9 @@ function toPendingRequestState(params) {
             ? { action_description: params.action_description }
             : {}),
         args: params.args,
+        ...(params.started_at_ms !== undefined
+            ? { started_at_ms: params.started_at_ms }
+            : {}),
     };
 }
 const MAX_HEADLESS_ATTACHMENT_BYTES = Number.parseInt(process.env.MAESTRO_HEADLESS_MAX_ATTACHMENT_BYTES || "", 10) || 10 * 1024 * 1024;
@@ -320,6 +646,9 @@ export class HeadlessProtocolTranslator {
                     {
                         type: "tool_call",
                         call_id: event.toolCallId,
+                        ...(event.toolExecutionId
+                            ? { tool_execution_id: event.toolExecutionId }
+                            : {}),
                         tool: event.toolName,
                         args: event.args,
                         requires_approval: false,
@@ -342,13 +671,18 @@ export class HeadlessProtocolTranslator {
                     },
                 ];
             }
-            case "tool_execution_end":
+            case "tool_execution_end": {
                 this.noteToolExecution(event.toolName, undefined, event.summaryLabel, !event.isError);
+                const details = codexSubagentToolEndDetails(event.toolName, event.result.details);
                 return [
                     {
                         type: "tool_end",
                         call_id: event.toolCallId,
+                        ...(event.toolExecutionId
+                            ? { tool_execution_id: event.toolExecutionId }
+                            : {}),
                         success: !event.isError,
+                        ...(details ? { tool: event.toolName, details } : {}),
                         ...(event.errorCode ? { error_code: event.errorCode } : {}),
                         ...(event.approvalRequestId
                             ? { approval_request_id: event.approvalRequestId }
@@ -358,6 +692,7 @@ export class HeadlessProtocolTranslator {
                             : {}),
                     },
                 ];
+            }
             case "tool_batch_summary": {
                 const message = event.summary.trim();
                 if (!message) {
@@ -375,6 +710,9 @@ export class HeadlessProtocolTranslator {
                     {
                         type: "tool_call",
                         call_id: event.request.id,
+                        ...(event.request.platform?.toolExecutionId
+                            ? { tool_execution_id: event.request.platform.toolExecutionId }
+                            : {}),
                         tool: event.request.toolName,
                         args: event.request.args,
                         requires_approval: true,
@@ -384,6 +722,9 @@ export class HeadlessProtocolTranslator {
                         request_id: event.request.id,
                         request_type: "approval",
                         call_id: event.request.id,
+                        ...(event.request.platform?.toolExecutionId
+                            ? { tool_execution_id: event.request.platform.toolExecutionId }
+                            : {}),
                         tool: event.request.toolName,
                         ...(event.request.displayName
                             ? { display_name: event.request.displayName }
@@ -396,6 +737,9 @@ export class HeadlessProtocolTranslator {
                             : {}),
                         args: event.request.args,
                         reason: event.request.reason,
+                        ...(event.request.startedAtMs !== undefined
+                            ? { started_at_ms: event.request.startedAtMs }
+                            : {}),
                     },
                 ];
             case "error":
@@ -456,6 +800,12 @@ export class HeadlessProtocolTranslator {
                         resolution: event.decision.approved ? "approved" : "denied",
                         reason: event.decision.reason,
                         resolved_by: event.decision.resolvedBy,
+                        ...(event.request.startedAtMs !== undefined
+                            ? { started_at_ms: event.request.startedAtMs }
+                            : {}),
+                        ...(event.decision.resolvedAtMs !== undefined
+                            ? { resolved_at_ms: event.decision.resolvedAtMs }
+                            : {}),
                     },
                 ];
             default:
@@ -464,11 +814,13 @@ export class HeadlessProtocolTranslator {
     }
     buildReadyMessage(agent, sessionManager) {
         const model = agent.state.model;
+        const executorType = model.provider === "scripted-replay" ? "replay" : "live";
         return {
             type: "ready",
             protocol_version: HEADLESS_PROTOCOL_VERSION,
             model: model.id,
             provider: model.provider,
+            executor_type: executorType,
             session_id: sessionManager.getSessionId() ?? null,
         };
     }
@@ -491,6 +843,7 @@ export class HeadlessProtocolTranslator {
             client_protocol_version: metadata.client_protocol_version,
             client_info: metadata.client_info,
             capabilities: metadata.capabilities,
+            server_capabilities: metadata.server_capabilities ?? HEADLESS_SERVER_CAPABILITIES,
             opt_out_notifications: metadata.opt_out_notifications,
             role: metadata.role,
             controller_connection_id: metadata.controller_connection_id,
@@ -648,6 +1001,9 @@ function applyOutgoingHeadlessMessageInner(state, msg) {
             state.is_responding = true;
             return;
         case "tool_response":
+            if (!msg.approved) {
+                failCodexSubagentContinuityEdge(state, msg.call_id);
+            }
             state.pending_approvals = state.pending_approvals.filter((approval) => approval.call_id !== msg.call_id);
             if (!msg.approved) {
                 state.tracked_tools = state.tracked_tools.filter((tool) => tool.call_id !== msg.call_id);
@@ -668,9 +1024,14 @@ function applyOutgoingHeadlessMessageInner(state, msg) {
             return;
         case "server_request_response":
             if (msg.request_type === "approval") {
+                const pendingApproval = state.pending_approvals.find((approval) => getPendingRequestId(approval) === msg.request_id);
+                const callId = pendingApproval?.call_id ?? msg.request_id;
+                if (!msg.approved) {
+                    failCodexSubagentContinuityEdge(state, callId);
+                }
                 state.pending_approvals = state.pending_approvals.filter((approval) => getPendingRequestId(approval) !== msg.request_id);
                 if (!msg.approved) {
-                    state.tracked_tools = state.tracked_tools.filter((tool) => tool.call_id !== msg.request_id);
+                    state.tracked_tools = state.tracked_tools.filter((tool) => tool.call_id !== callId && tool.call_id !== msg.request_id);
                 }
             }
             else if (msg.request_type === "client_tool") {
@@ -730,6 +1091,7 @@ function applyIncomingHeadlessMessageInner(state, msg) {
             state.client_protocol_version = msg.client_protocol_version;
             state.client_info = msg.client_info;
             state.capabilities = msg.capabilities;
+            state.server_capabilities = msg.server_capabilities;
             state.opt_out_notifications = msg.opt_out_notifications;
             state.connection_role = msg.role;
             state.controller_connection_id = msg.controller_connection_id;
@@ -738,6 +1100,7 @@ function applyIncomingHeadlessMessageInner(state, msg) {
             state.protocol_version = msg.protocol_version;
             state.model = msg.model;
             state.provider = msg.provider;
+            state.executor_type = msg.executor_type ?? "live";
             state.session_id = msg.session_id;
             state.is_ready = true;
             return;
@@ -785,10 +1148,18 @@ function applyIncomingHeadlessMessageInner(state, msg) {
             state.is_responding = false;
             return;
         case "tool_call":
+            upsertCodexSubagentContinuityEdges(state, {
+                call_id: msg.call_id,
+                tool_execution_id: msg.tool_execution_id,
+                tool: msg.tool,
+                args: msg.args,
+                status: activeCodexSubagentStatus(codexSubagentOperation(msg.tool) ?? ""),
+            });
             state.tracked_tools = [
                 ...state.tracked_tools.filter((tool) => tool.call_id !== msg.call_id),
                 {
                     call_id: msg.call_id,
+                    tool_execution_id: msg.tool_execution_id,
                     tool: msg.tool,
                     args: msg.args,
                 },
@@ -798,6 +1169,7 @@ function applyIncomingHeadlessMessageInner(state, msg) {
                     ...state.pending_approvals.filter((approval) => approval.call_id !== msg.call_id),
                     {
                         call_id: msg.call_id,
+                        tool_execution_id: msg.tool_execution_id,
                         tool: msg.tool,
                         args: msg.args,
                     },
@@ -832,7 +1204,25 @@ function applyIncomingHeadlessMessageInner(state, msg) {
                 ? { ...tool, output: `${tool.output}${msg.content}` }
                 : tool);
             return;
-        case "tool_end":
+        case "tool_end": {
+            const source = state.tracked_tools.find((tool) => tool.call_id === msg.call_id) ??
+                state.pending_approvals.find((approval) => approval.call_id === msg.call_id) ??
+                state.pending_client_tools.find((request) => request.call_id === msg.call_id) ??
+                state.pending_mcp_elicitations.find((request) => request.call_id === msg.call_id) ??
+                state.pending_user_inputs.find((request) => request.call_id === msg.call_id) ??
+                state.pending_tool_retries.find((request) => request.call_id === msg.call_id);
+            const active = state.active_tools.find((tool) => tool.call_id === msg.call_id);
+            const tool = msg.tool ?? source?.tool ?? active?.tool;
+            const operation = tool ? codexSubagentOperation(tool) : undefined;
+            if (tool && operation) {
+                upsertCodexSubagentContinuityEdges(state, {
+                    call_id: msg.call_id,
+                    tool_execution_id: msg.tool_execution_id ?? source?.tool_execution_id,
+                    tool,
+                    args: codexSubagentToolEndArgs(source?.args, msg.details),
+                    status: terminalCodexSubagentStatus(operation, msg.success),
+                });
+            }
             state.active_tools = state.active_tools.filter((tool) => tool.call_id !== msg.call_id);
             state.pending_approvals = state.pending_approvals.filter((approval) => approval.call_id !== msg.call_id);
             state.pending_client_tools = state.pending_client_tools.filter((request) => request.call_id !== msg.call_id);
@@ -841,20 +1231,30 @@ function applyIncomingHeadlessMessageInner(state, msg) {
             state.pending_tool_retries = state.pending_tool_retries.filter((request) => request.call_id !== msg.call_id);
             state.tracked_tools = state.tracked_tools.filter((tool) => tool.call_id !== msg.call_id);
             return;
+        }
         case "client_tool_request":
             state.tracked_tools = [
                 ...state.tracked_tools.filter((tool) => tool.call_id !== msg.call_id),
                 {
                     call_id: msg.call_id,
+                    tool_execution_id: msg.tool_execution_id,
                     tool: msg.tool,
                     args: msg.args,
                 },
             ];
+            upsertCodexSubagentContinuityEdges(state, {
+                call_id: msg.call_id,
+                tool_execution_id: msg.tool_execution_id,
+                tool: msg.tool,
+                args: msg.args,
+                status: activeCodexSubagentStatus(codexSubagentOperation(msg.tool) ?? ""),
+            });
             if (msg.tool === "ask_user") {
                 state.pending_user_inputs = [
                     ...state.pending_user_inputs.filter((request) => request.call_id !== msg.call_id),
                     {
                         call_id: msg.call_id,
+                        tool_execution_id: msg.tool_execution_id,
                         tool: msg.tool,
                         args: msg.args,
                     },
@@ -865,35 +1265,50 @@ function applyIncomingHeadlessMessageInner(state, msg) {
                     ...state.pending_client_tools.filter((request) => request.call_id !== msg.call_id),
                     {
                         call_id: msg.call_id,
+                        tool_execution_id: msg.tool_execution_id,
                         tool: msg.tool,
                         args: msg.args,
                     },
                 ];
             }
             return;
-        case "server_request":
-            if (msg.request_type !== "tool_retry" ||
-                !state.tracked_tools.some((tool) => tool.call_id === msg.call_id)) {
+        case "server_request": {
+            const trackedTool = state.tracked_tools.find((tool) => tool.call_id === msg.call_id);
+            const toolExecutionId = msg.tool_execution_id ?? trackedTool?.tool_execution_id;
+            const shouldTrackRequest = msg.request_type !== "tool_retry" ||
+                !trackedTool ||
+                trackedTool.tool_execution_id !== toolExecutionId;
+            if (shouldTrackRequest) {
                 state.tracked_tools = [
                     ...state.tracked_tools.filter((tool) => tool.call_id !== msg.call_id),
                     {
                         call_id: msg.call_id,
+                        tool_execution_id: toolExecutionId,
                         tool: msg.tool,
                         args: msg.args,
                     },
                 ];
             }
+            upsertCodexSubagentContinuityEdges(state, {
+                call_id: msg.call_id,
+                tool_execution_id: toolExecutionId,
+                tool: msg.tool,
+                args: msg.args,
+                status: activeCodexSubagentStatus(codexSubagentOperation(msg.tool) ?? ""),
+            });
             if (msg.request_type === "approval") {
                 state.pending_approvals = [
                     ...state.pending_approvals.filter((approval) => approval.call_id !== msg.call_id),
                     toPendingRequestState({
                         call_id: msg.call_id,
+                        tool_execution_id: toolExecutionId,
                         request_id: msg.request_id,
                         tool: msg.tool,
                         display_name: msg.display_name,
                         summary_label: msg.summary_label,
                         action_description: msg.action_description,
                         args: msg.args,
+                        started_at_ms: msg.started_at_ms,
                     }),
                 ];
             }
@@ -902,9 +1317,11 @@ function applyIncomingHeadlessMessageInner(state, msg) {
                     ...state.pending_client_tools.filter((request) => request.call_id !== msg.call_id),
                     toPendingRequestState({
                         call_id: msg.call_id,
+                        tool_execution_id: toolExecutionId,
                         request_id: msg.request_id,
                         tool: msg.tool,
                         args: msg.args,
+                        started_at_ms: msg.started_at_ms,
                     }),
                 ];
             }
@@ -913,9 +1330,11 @@ function applyIncomingHeadlessMessageInner(state, msg) {
                     ...state.pending_mcp_elicitations.filter((request) => request.call_id !== msg.call_id),
                     toPendingRequestState({
                         call_id: msg.call_id,
+                        tool_execution_id: toolExecutionId,
                         request_id: msg.request_id,
                         tool: msg.tool,
                         args: msg.args,
+                        started_at_ms: msg.started_at_ms,
                     }),
                 ];
             }
@@ -924,9 +1343,11 @@ function applyIncomingHeadlessMessageInner(state, msg) {
                     ...state.pending_user_inputs.filter((request) => request.call_id !== msg.call_id),
                     toPendingRequestState({
                         call_id: msg.call_id,
+                        tool_execution_id: toolExecutionId,
                         request_id: msg.request_id,
                         tool: msg.tool,
                         args: msg.args,
+                        started_at_ms: msg.started_at_ms,
                     }),
                 ];
             }
@@ -935,23 +1356,28 @@ function applyIncomingHeadlessMessageInner(state, msg) {
                     ...state.pending_tool_retries.filter((request) => request.call_id !== msg.call_id),
                     toPendingRequestState({
                         call_id: msg.call_id,
+                        tool_execution_id: toolExecutionId,
                         request_id: msg.request_id,
                         tool: msg.tool,
                         args: msg.args,
+                        started_at_ms: msg.started_at_ms,
                     }),
                 ];
             }
             return;
+        }
         case "server_request_resolved":
             if (msg.request_type === "approval") {
                 state.pending_approvals = state.pending_approvals.filter((approval) => getPendingRequestId(approval) !== msg.request_id);
                 if (msg.resolution !== "approved") {
+                    failCodexSubagentContinuityEdge(state, msg.call_id);
                     state.tracked_tools = state.tracked_tools.filter((tool) => tool.call_id !== msg.call_id);
                 }
             }
             else if (msg.request_type === "client_tool") {
                 state.pending_client_tools = state.pending_client_tools.filter((request) => getPendingRequestId(request) !== msg.request_id);
                 if (msg.resolution === "cancelled") {
+                    failCodexSubagentContinuityEdge(state, msg.call_id);
                     state.tracked_tools = state.tracked_tools.filter((tool) => tool.call_id !== msg.call_id);
                 }
             }
@@ -961,6 +1387,7 @@ function applyIncomingHeadlessMessageInner(state, msg) {
             else if (msg.request_type === "user_input") {
                 state.pending_user_inputs = state.pending_user_inputs.filter((request) => getPendingRequestId(request) !== msg.request_id);
                 if (msg.resolution !== "answered") {
+                    failCodexSubagentContinuityEdge(state, msg.call_id);
                     state.tracked_tools = state.tracked_tools.filter((tool) => tool.call_id !== msg.call_id);
                 }
             }
@@ -1038,6 +1465,13 @@ function applyIncomingHeadlessMessageInner(state, msg) {
     }
 }
 export function buildHeadlessServerRequestCancellationMessages(state, reason) {
+    const resolvedAtMs = Date.now();
+    const lifecycleTiming = (request) => ({
+        ...(request.started_at_ms !== undefined
+            ? { started_at_ms: request.started_at_ms }
+            : {}),
+        resolved_at_ms: resolvedAtMs,
+    });
     return [
         ...state.pending_approvals.map((approval) => ({
             type: "server_request_resolved",
@@ -1047,6 +1481,7 @@ export function buildHeadlessServerRequestCancellationMessages(state, reason) {
             resolution: "cancelled",
             reason,
             resolved_by: "runtime",
+            ...lifecycleTiming(approval),
         })),
         ...state.pending_client_tools.map((request) => ({
             type: "server_request_resolved",
@@ -1056,6 +1491,7 @@ export function buildHeadlessServerRequestCancellationMessages(state, reason) {
             resolution: "cancelled",
             reason,
             resolved_by: "runtime",
+            ...lifecycleTiming(request),
         })),
         ...state.pending_mcp_elicitations.map((request) => ({
             type: "server_request_resolved",
@@ -1065,6 +1501,7 @@ export function buildHeadlessServerRequestCancellationMessages(state, reason) {
             resolution: "cancelled",
             reason,
             resolved_by: "runtime",
+            ...lifecycleTiming(request),
         })),
         ...state.pending_user_inputs.map((request) => ({
             type: "server_request_resolved",
@@ -1074,6 +1511,7 @@ export function buildHeadlessServerRequestCancellationMessages(state, reason) {
             resolution: "cancelled",
             reason,
             resolved_by: "runtime",
+            ...lifecycleTiming(request),
         })),
         ...state.pending_tool_retries.map((request) => ({
             type: "server_request_resolved",
@@ -1083,6 +1521,7 @@ export function buildHeadlessServerRequestCancellationMessages(state, reason) {
             resolution: "cancelled",
             reason,
             resolved_by: "runtime",
+            ...lifecycleTiming(request),
         })),
     ];
 }