@kodelyth/codex 2026.5.40 → 2026.5.42

package/src/app-server/native-subagent-task-mirror.test.ts

@@ -0,0 +1,573 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  codexNativeSubagentRunId,
+  CodexNativeSubagentTaskMirror,
+  type TaskLifecycleRuntime,
+} from "./native-subagent-task-mirror.js";
+
+function createRuntime() {
+  return {
+    createRunningTaskRun: vi.fn(),
+    recordTaskRunProgressByRunId: vi.fn(() => []),
+    finalizeTaskRunByRunId: vi.fn(() => []),
+  } as unknown as TaskLifecycleRuntime;
+}
+
+describe("CodexNativeSubagentTaskMirror", () => {
+  it("creates a silent task-registry task for a native Codex subagent thread", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+        agentId: "main",
+        now: () => 20_000,
+      },
+      runtime,
+    );
+
+    mirror.handleNotification({
+      method: "thread/started",
+      params: {
+        thread: {
+          id: "child-thread",
+          sessionId: "session-tree",
+          preview: "write the Madrid wine script",
+          createdAt: 10,
+          status: { type: "active", activeFlags: [] },
+          source: {
+            subAgent: {
+              thread_spawn: {
+                parent_thread_id: "parent-thread",
+                depth: 1,
+                agent_nickname: "Poincare",
+                agent_role: "worker",
+              },
+            },
+          },
+        },
+      },
+    });
+
+    expect(runtime.createRunningTaskRun).toHaveBeenCalledWith({
+      runtime: "subagent",
+      taskKind: "codex-native",
+      sourceId: "codex-thread:child-thread",
+      requesterSessionKey: "agent:main:main",
+      ownerKey: "agent:main:main",
+      scopeKind: "session",
+      agentId: "main",
+      runId: "codex-thread:child-thread",
+      label: "Poincare",
+      task: "write the Madrid wine script",
+      notifyPolicy: "silent",
+      deliveryStatus: "not_applicable",
+      preferMetadata: true,
+      startedAt: 10_000,
+      lastEventAt: 20_000,
+      progressSummary: "Codex native subagent started.",
+    });
+    expect(vi.mocked(runtime.createRunningTaskRun).mock.calls[0]?.[0]).not.toHaveProperty(
+      "childSessionKey",
+    );
+    expect(runtime.recordTaskRunProgressByRunId).toHaveBeenCalledWith({
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      lastEventAt: 20_000,
+      progressSummary: "Codex native subagent is active.",
+    });
+  });
+
+  it("ignores subagent threads spawned by a different parent thread", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+      },
+      runtime,
+    );
+
+    mirror.handleNotification({
+      method: "thread/started",
+      params: {
+        thread: {
+          id: "other-child",
+          source: {
+            subAgent: {
+              thread_spawn: {
+                parent_thread_id: "other-parent",
+                depth: 1,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    expect(runtime.createRunningTaskRun).not.toHaveBeenCalled();
+    expect(runtime.recordTaskRunProgressByRunId).not.toHaveBeenCalled();
+    expect(runtime.finalizeTaskRunByRunId).not.toHaveBeenCalled();
+  });
+
+  it("deduplicates repeated thread-started notifications for the same child thread", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+      },
+      runtime,
+    );
+    const notification = {
+      method: "thread/started",
+      params: {
+        thread: {
+          id: "child-thread",
+          source: {
+            subAgent: {
+              thread_spawn: {
+                parent_thread_id: "parent-thread",
+                depth: 1,
+              },
+            },
+          },
+        },
+      },
+    } as const;
+
+    mirror.handleNotification(notification);
+    mirror.handleNotification(notification);
+
+    expect(runtime.createRunningTaskRun).toHaveBeenCalledTimes(1);
+  });
+
+  it("maps Codex thread status changes onto the mirrored task run", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+        now: () => 30_000,
+      },
+      runtime,
+    );
+
+    mirror.handleNotification({
+      method: "thread/status/changed",
+      params: {
+        threadId: "child-thread",
+        status: { type: "idle" },
+      },
+    });
+    mirror.handleNotification({
+      method: "thread/status/changed",
+      params: {
+        threadId: "failed-child",
+        status: { type: "systemError" },
+      },
+    });
+
+    expect(runtime.finalizeTaskRunByRunId).toHaveBeenNthCalledWith(1, {
+      runId: codexNativeSubagentRunId("child-thread"),
+      runtime: "subagent",
+      status: "succeeded",
+      endedAt: 30_000,
+      lastEventAt: 30_000,
+      progressSummary: "Codex native subagent is idle.",
+      terminalSummary: "Codex native subagent finished.",
+    });
+    expect(runtime.finalizeTaskRunByRunId).toHaveBeenNthCalledWith(2, {
+      runId: codexNativeSubagentRunId("failed-child"),
+      runtime: "subagent",
+      status: "failed",
+      endedAt: 30_000,
+      lastEventAt: 30_000,
+      error: "Codex app-server reported a system error for the native subagent thread.",
+      progressSummary: "Codex native subagent hit a system error.",
+      terminalSummary: "Codex native subagent failed.",
+    });
+  });
+
+  it("creates and updates tasks from Codex collab agent item state", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+        now: () => 40_000,
+      },
+      runtime,
+    );
+
+    mirror.handleNotification({
+      method: "item/completed",
+      params: {
+        item: {
+          type: "collabAgentToolCall",
+          tool: "spawnAgent",
+          senderThreadId: "parent-thread",
+          receiverThreadIds: ["child-thread"],
+          prompt: "write the proof file",
+          agentsStates: {
+            "child-thread": {
+              status: "pendingInit",
+              message: null,
+            },
+          },
+        },
+      },
+    });
+    mirror.handleNotification({
+      method: "item/completed",
+      params: {
+        item: {
+          type: "collabAgentToolCall",
+          tool: "wait",
+          senderThreadId: "parent-thread",
+          receiverThreadIds: [],
+          agentsStates: {
+            "child-thread": {
+              status: "completed",
+              message: "done",
+            },
+          },
+        },
+      },
+    });
+
+    expect(runtime.createRunningTaskRun).toHaveBeenCalledWith({
+      runtime: "subagent",
+      taskKind: "codex-native",
+      sourceId: "codex-thread:child-thread",
+      requesterSessionKey: "agent:main:main",
+      ownerKey: "agent:main:main",
+      scopeKind: "session",
+      runId: "codex-thread:child-thread",
+      label: "Codex subagent",
+      task: "write the proof file",
+      notifyPolicy: "silent",
+      deliveryStatus: "not_applicable",
+      preferMetadata: true,
+      startedAt: 40_000,
+      lastEventAt: 40_000,
+      progressSummary: "Codex native subagent spawned.",
+    });
+    expect(vi.mocked(runtime.createRunningTaskRun).mock.calls[0]?.[0]).not.toHaveProperty(
+      "childSessionKey",
+    );
+    expect(runtime.recordTaskRunProgressByRunId).toHaveBeenCalledWith({
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      lastEventAt: 40_000,
+      progressSummary: "Codex native subagent is initializing.",
+    });
+    expect(runtime.finalizeTaskRunByRunId).toHaveBeenCalledWith({
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      status: "succeeded",
+      endedAt: 40_000,
+      lastEventAt: 40_000,
+      progressSummary: "done",
+      terminalSummary: "done",
+    });
+  });
+
+  it("finalizes stale collab agent state from the blocked tool call status", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+        now: () => 45_000,
+      },
+      runtime,
+    );
+
+    mirror.handleNotification({
+      method: "item/completed",
+      params: {
+        item: {
+          type: "collabAgentToolCall",
+          tool: "spawnAgent",
+          status: "blocked",
+          senderThreadId: "parent-thread",
+          receiverThreadIds: ["child-thread"],
+          prompt: "read cwd",
+          agentsStates: {
+            "child-thread": {
+              status: "pendingInit",
+              message: "Native hook relay unavailable",
+            },
+          },
+        },
+      },
+    });
+
+    expect(runtime.recordTaskRunProgressByRunId).not.toHaveBeenCalledWith({
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      lastEventAt: 45_000,
+      progressSummary: "Native hook relay unavailable",
+    });
+    expect(runtime.finalizeTaskRunByRunId).toHaveBeenCalledWith({
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      status: "succeeded",
+      endedAt: 45_000,
+      lastEventAt: 45_000,
+      progressSummary: "Native hook relay unavailable",
+      terminalSummary: "Native hook relay unavailable",
+      terminalOutcome: "blocked",
+    });
+  });
+
+  it("does not treat completed tool calls as completed subagents", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+        now: () => 46_000,
+      },
+      runtime,
+    );
+
+    mirror.handleNotification({
+      method: "item/completed",
+      params: {
+        item: {
+          type: "collabAgentToolCall",
+          tool: "spawnAgent",
+          status: "completed",
+          senderThreadId: "parent-thread",
+          receiverThreadIds: ["child-thread"],
+          prompt: "read cwd",
+          agentsStates: {
+            "child-thread": {
+              status: "pendingInit",
+              message: null,
+            },
+          },
+        },
+      },
+    });
+
+    expect(runtime.recordTaskRunProgressByRunId).toHaveBeenCalledWith({
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      lastEventAt: 46_000,
+      progressSummary: "Codex native subagent is initializing.",
+    });
+    expect(runtime.finalizeTaskRunByRunId).not.toHaveBeenCalled();
+  });
+
+  it("does not treat failed non-spawn tool calls as failed subagents", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+        now: () => 47_000,
+      },
+      runtime,
+    );
+
+    mirror.handleNotification({
+      method: "item/completed",
+      params: {
+        item: {
+          type: "collabAgentToolCall",
+          tool: "wait",
+          status: "failed",
+          senderThreadId: "parent-thread",
+          receiverThreadIds: [],
+          agentsStates: {
+            "child-thread": {
+              status: "running",
+              message: "wait timed out",
+            },
+          },
+        },
+      },
+    });
+
+    expect(runtime.recordTaskRunProgressByRunId).toHaveBeenCalledWith({
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      lastEventAt: 47_000,
+      progressSummary: "wait timed out",
+    });
+    expect(runtime.finalizeTaskRunByRunId).not.toHaveBeenCalled();
+  });
+
+  it("preserves a completed collab agent message when the thread later goes idle", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+        now: () => 50_000,
+      },
+      runtime,
+    );
+
+    mirror.handleNotification({
+      method: "item/completed",
+      params: {
+        item: {
+          type: "collabAgentToolCall",
+          tool: "spawnAgent",
+          senderThreadId: "parent-thread",
+          receiverThreadIds: ["child-thread"],
+          prompt: "write the proof file",
+          agentsStates: {
+            "child-thread": {
+              status: "completed",
+              message: "No user task is specified.",
+            },
+          },
+        },
+      },
+    });
+    mirror.handleNotification({
+      method: "thread/status/changed",
+      params: {
+        threadId: "child-thread",
+        status: { type: "idle" },
+      },
+    });
+
+    expect(runtime.finalizeTaskRunByRunId).toHaveBeenCalledTimes(1);
+    expect(runtime.finalizeTaskRunByRunId).toHaveBeenCalledWith({
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      status: "succeeded",
+      endedAt: 50_000,
+      lastEventAt: 50_000,
+      progressSummary: "No user task is specified.",
+      terminalSummary: "No user task is specified.",
+    });
+  });
+
+  it("lets terminal collab agent state correct an earlier idle thread status", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+        now: () => 55_000,
+      },
+      runtime,
+    );
+
+    mirror.handleNotification({
+      method: "thread/status/changed",
+      params: {
+        threadId: "child-thread",
+        status: { type: "idle" },
+      },
+    });
+    mirror.handleNotification({
+      method: "item/completed",
+      params: {
+        item: {
+          type: "collabAgentToolCall",
+          tool: "spawnAgent",
+          status: "failed",
+          senderThreadId: "parent-thread",
+          receiverThreadIds: ["child-thread"],
+          prompt: "read cwd",
+          agentsStates: {
+            "child-thread": {
+              status: "pendingInit",
+              message: "Native hook relay unavailable",
+            },
+          },
+        },
+      },
+    });
+
+    expect(runtime.finalizeTaskRunByRunId).toHaveBeenNthCalledWith(1, {
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      status: "succeeded",
+      endedAt: 55_000,
+      lastEventAt: 55_000,
+      progressSummary: "Codex native subagent is idle.",
+      terminalSummary: "Codex native subagent finished.",
+    });
+    expect(runtime.finalizeTaskRunByRunId).toHaveBeenNthCalledWith(2, {
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      status: "failed",
+      endedAt: 55_000,
+      lastEventAt: 55_000,
+      error: "Native hook relay unavailable",
+      progressSummary: "Native hook relay unavailable",
+      terminalSummary: "Native hook relay unavailable",
+    });
+  });
+
+  it("normalizes collab agent status spelling from alternate event surfaces", () => {
+    const runtime = createRuntime();
+    const mirror = new CodexNativeSubagentTaskMirror(
+      {
+        parentThreadId: "parent-thread",
+        requesterSessionKey: "agent:main:main",
+        now: () => 60_000,
+      },
+      runtime,
+    );
+
+    mirror.handleNotification({
+      method: "item/completed",
+      params: {
+        item: {
+          type: "collabAgentToolCall",
+          tool: "spawnAgent",
+          senderThreadId: "parent-thread",
+          receiverThreadIds: ["child-thread"],
+          agentsStates: {
+            "child-thread": {
+              status: "pending_init",
+              message: null,
+            },
+          },
+        },
+      },
+    });
+    mirror.handleNotification({
+      method: "item/completed",
+      params: {
+        item: {
+          type: "collabAgentToolCall",
+          tool: "wait",
+          senderThreadId: "parent-thread",
+          agentsStates: {
+            "child-thread": {
+              status: "success",
+              message: "done",
+            },
+          },
+        },
+      },
+    });
+
+    expect(runtime.recordTaskRunProgressByRunId).toHaveBeenCalledWith({
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      lastEventAt: 60_000,
+      progressSummary: "Codex native subagent is initializing.",
+    });
+    expect(runtime.finalizeTaskRunByRunId).toHaveBeenCalledWith({
+      runId: "codex-thread:child-thread",
+      runtime: "subagent",
+      status: "succeeded",
+      endedAt: 60_000,
+      lastEventAt: 60_000,
+      progressSummary: "done",
+      terminalSummary: "done",
+    });
+  });
+});