// SPEC: PJ2026-0104010803 Workbench唯一投影 draft-2026-06-20-p2-terminal-outbox-recovery; PJ2026-01060505 Workbench Performance draft-2026-06-17-p0.
// Responsibility: Cloud API AgentRun read lifecycle, Codex fallback, inspect, and cancel regression tests.

import assert from "node:assert/strict";
import { createServer as createHttpServer } from "node:http";
import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { test } from "bun:test";

import { createCloudApiServer } from "./server.ts";
import { createCloudRuntimeStore } from "../db/runtime-store.ts";
import { validateCodeAgentChatSchema } from "./code-agent-chat.ts";
import { createCodexStdioSessionManager } from "./codex-stdio-session.ts";
import { createCodeAgentTraceStore } from "./code-agent-trace-store.ts";
import { submitAgentRunChatTurn } from "./code-agent-agentrun-adapter.ts";
import {
  codexStdioChatFixture,
  codexStdioReadyFixture,
  createFakeAppServerClient,
  createFakeCodexCommand,
  createManualAgentSession,
  delay,
  ensureTestAgentAuth,
  pollAgentResult,
  postAgent,
  postAgentRaw,
  prepareFakeCodexHome
} from "./server-test-helpers.ts";

const TEST_AGENT_ACTOR = { id: "usr_agent_owner", username: "agent-owner", displayName: "Agent Owner", role: "user", status: "active" };
const TEST_AUTH_SESSION = { id: "auth_ses_agent_owner" };

function testAgentSessionRecord(input = {}) {
  const sessionId = input.sessionId ?? input.id;
  return {
    id: sessionId,
    sessionId,
    projectId: input.projectId ?? "pikasTech/HWLAB",
    agentId: input.agentId ?? "hwlab-code-agent",
    status: input.status ?? "idle",
    ownerUserId: input.ownerUserId ?? TEST_AGENT_ACTOR.id,
    ownerRole: input.ownerRole ?? TEST_AGENT_ACTOR.role,
    conversationId: input.conversationId ?? null,
    threadId: input.threadId ?? null,
    lastTraceId: input.traceId ?? input.lastTraceId ?? null,
    session: input.session ?? {},
    updatedAt: input.updatedAt ?? "2026-06-03T00:00:00.000Z"
  };
}

test("cloud api trace skips AgentRun refresh when terminal snapshot is already complete (#1422)", async () => {
  const calls = [];
  const traceId = "trc_issue1422_trace_terminal_snapshot";
  const runId = "run_issue1422_trace_terminal_snapshot";
  const commandId = "cmd_issue1422_trace_terminal_snapshot";
  const finalText = "trace endpoint should reuse the local terminal snapshot.";
  const agentRunServer = createHttpServer(async (request, response) => {
    const url = new URL(request.url || "/", "http://127.0.0.1");
    calls.push({ method: request.method, path: url.pathname, search: url.search });
    response.writeHead(500, { "content-type": "application/json" });
    response.end(`${JSON.stringify({ ok: false, message: `unexpected refresh ${request.method} ${url.pathname}` })}\n`);
  });
  await new Promise((resolve) => agentRunServer.listen(0, "127.0.0.1", resolve));

  const agentRunPort = agentRunServer.address().port;
  const traceStore = createCodeAgentTraceStore();
  traceStore.append(traceId, {
    type: "backend",
    status: "running",
    label: "agentrun:backend:runner-job-created",
    source: "agentrun",
    sourceSeq: 1,
    runId,
    commandId,
    valuesPrinted: false
  });
  traceStore.append(traceId, {
    type: "result",
    status: "completed",
    label: "agentrun:terminal:completed",
    source: "agentrun",
    sourceSeq: 3,
    runId,
    commandId,
    terminal: true,
    valuesPrinted: false
  });
  const codeAgentChatResults = new Map([[traceId, {
    accepted: true,
    status: "completed",
    shortConnection: true,
    traceId,
    conversationId: "cnv_issue1422_trace_terminal_snapshot",
    sessionId: "ses_issue1422_trace_terminal_snapshot",
    threadId: "thread-issue1422-trace-terminal-snapshot",
    ownerUserId: TEST_AGENT_ACTOR.id,
    ownerRole: TEST_AGENT_ACTOR.role,
    finalResponse: { text: finalText, textChars: finalText.length, role: "assistant", status: "completed", traceId, valuesPrinted: false },
    traceSummary: {
      traceId,
      source: "agentrun-command-result",
      sourceEventCount: 3,
      terminalStatus: "completed",
      agentRun: { runId, commandId, lastSeq: 3, valuesPrinted: false },
      valuesPrinted: false
    },
    agentRun: {
      adapter: "agentrun-v01",
      managerUrl: `http://127.0.0.1:${agentRunPort}`,
      runId,
      commandId,
      traceId,
      lastSeq: 3,
      status: "completed",
      commandState: "completed",
      terminalStatus: "completed",
      providerTrace: { traceId, runId, commandId, terminalStatus: "completed", valuesPrinted: false },
      valuesPrinted: false
    },
    providerTrace: { traceId, runId, commandId, terminalStatus: "completed", valuesPrinted: false },
    valuesPrinted: false
  }]]);
  const server = createCloudApiServer({
    traceStore,
    codeAgentChatResults,
    env: {
      HWLAB_CODE_AGENT_ADAPTER: "agentrun-v01",
      AGENTRUN_MGR_URL: `http://127.0.0.1:${agentRunPort}`,
      HWLAB_CODE_AGENT_AGENTRUN_ALLOW_NON_K3S_URL: "1",
      HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID: "D601",
      HWLAB_ENVIRONMENT: "v02",
      HWLAB_GITOPS_PROFILE: "v02"
    },
    accessController: {
      required: false,
      async authenticate() {
        return { ok: true, actor: TEST_AGENT_ACTOR, session: TEST_AUTH_SESSION };
      }
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/traces/${traceId}?limit=1`, {
      headers: { cookie: "hwlab_session=test-stub-session" }
    });
    assert.equal(response.status, 200);
    const body = await response.json();
    assert.equal(body.status, "completed");
    assert.equal(body.eventCount, 2);
    assert.equal(body.agentRun.commandId, commandId);
    assert.equal(body.finalResponse.text, finalText);
    assert.deepEqual(calls, []);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
    await new Promise((resolve, reject) => {
      agentRunServer.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api trace does not schedule terminal side effects from GET reads (#1519)", async () => {
  const ownerCalls = [];
  const factCalls = [];
  let releaseOwnerWrite;
  let ownerWriteReleased = false;
  const ownerWrite = new Promise((resolve) => {
    releaseOwnerWrite = () => {
      if (ownerWriteReleased) return;
      ownerWriteReleased = true;
      resolve();
    };
  });
  const traceId = "trc_issue1422_trace_effects_async";
  const runId = "run_issue1422_trace_effects_async";
  const commandId = "cmd_issue1422_trace_effects_async";
  const finalText = "trace reads should not wait for terminal side effects.";
  const traceStore = createCodeAgentTraceStore();
  traceStore.append(traceId, {
    type: "backend",
    status: "running",
    label: "agentrun:backend:run-created",
    source: "agentrun",
    sourceSeq: 1,
    runId,
    commandId,
    valuesPrinted: false
  });
  traceStore.append(traceId, {
    type: "result",
    status: "completed",
    label: "agentrun:terminal:completed",
    source: "agentrun",
    sourceSeq: 3,
    runId,
    commandId,
    terminal: true,
    valuesPrinted: false
  });
  const codeAgentChatResults = new Map([[traceId, {
    accepted: true,
    status: "completed",
    shortConnection: true,
    traceId,
    conversationId: "cnv_issue1422_trace_effects_async",
    sessionId: "ses_issue1422_trace_effects_async",
    threadId: "thread-issue1422-trace-effects-async",
    ownerUserId: TEST_AGENT_ACTOR.id,
    ownerRole: TEST_AGENT_ACTOR.role,
    finalResponse: { text: finalText, textChars: finalText.length, role: "assistant", status: "completed", traceId, valuesPrinted: false },
    traceSummary: {
      traceId,
      source: "agentrun-command-result",
      sourceEventCount: 3,
      terminalStatus: "completed",
      finalAssistantRow: { role: "assistant", status: "completed", textChars: finalText.length, textPreview: finalText, messageId: `msg_${traceId.slice(4)}`, valuesPrinted: false },
      agentRun: { runId, commandId, lastSeq: 3, valuesPrinted: false },
      valuesPrinted: false
    },
    agentRun: {
      adapter: "agentrun-v01",
      managerUrl: "http://127.0.0.1:1",
      runId,
      commandId,
      traceId,
      lastSeq: 3,
      status: "completed",
      commandState: "completed",
      terminalStatus: "completed",
      providerTrace: { traceId, runId, commandId, terminalStatus: "completed", valuesPrinted: false },
      valuesPrinted: false
    },
    providerTrace: { traceId, runId, commandId, terminalStatus: "completed", valuesPrinted: false },
    valuesPrinted: false
  }]]);
  const server = createCloudApiServer({
    traceStore,
    codeAgentChatResults,
    env: {
      HWLAB_CODE_AGENT_ADAPTER: "agentrun-v01",
      HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID: "D601",
      HWLAB_ENVIRONMENT: "v02",
      HWLAB_GITOPS_PROFILE: "v02"
    },
    sessionRegistry: {
      recordFact(conversationId, fact) {
        factCalls.push({ conversationId, fact });
        return { ok: true };
      }
    },
    accessController: {
      required: false,
      async authenticate() {
        return { ok: true, actor: TEST_AGENT_ACTOR, session: TEST_AUTH_SESSION };
      },
      async recordAgentSessionOwner(input) {
        ownerCalls.push(input);
        await ownerWrite;
        return { ok: true, sessionId: input.sessionId };
      }
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const fetchTrace = async () => {
      const response = await Promise.race([
        fetch(`http://127.0.0.1:${port}/v1/agent/traces/${traceId}?limit=1`, {
          headers: { cookie: "hwlab_session=test-stub-session" }
        }),
        delay(250).then(() => null)
      ]);
      assert.ok(response, "trace read should not wait for terminal side effects to finish");
      assert.equal(response.status, 200);
      const body = await response.json();
      assert.equal(body.status, "completed");
      assert.equal(body.eventCount, 2);
      assert.equal(body.finalResponse.text, finalText);
    };
    for (let i = 0; i < 2; i += 1) {
      await fetchTrace();
    }
    for (let i = 0; i < 20 && ownerCalls.length < 1; i += 1) await delay(10);
    assert.equal(ownerCalls.length, 0);
    assert.equal(factCalls.length, 0);
    assert.equal(codeAgentChatResults.get(traceId).turnStatusTerminalEffects, undefined);
    releaseOwnerWrite();
    assert.equal(codeAgentChatResults.get(traceId).turnStatusTerminalEffects, undefined);
  } finally {
    releaseOwnerWrite?.();
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api turn status skips AgentRun refresh for complete terminal evidence (#1422)", async () => {
  const calls = [];
  const traceId = "trc_issue1422_terminal_fast_path";
  const runId = "run_issue1422_terminal_fast_path";
  const commandId = "cmd_issue1422_terminal_fast_path";
  const finalText = "终态结果已经由 AgentRun command result 投影完成。";
  const agentRunServer = createHttpServer(async (request, response) => {
    const url = new URL(request.url || "/", "http://127.0.0.1");
    calls.push({ method: request.method, path: url.pathname, search: url.search });
    response.writeHead(500, { "content-type": "application/json" });
    response.end(`${JSON.stringify({ ok: false, message: `unexpected refresh ${request.method} ${url.pathname}` })}\n`);
  });
  await new Promise((resolve) => agentRunServer.listen(0, "127.0.0.1", resolve));

  const agentRunPort = agentRunServer.address().port;
  const codeAgentChatResults = new Map([[traceId, {
    accepted: true,
    status: "completed",
    shortConnection: true,
    traceId,
    conversationId: "cnv_issue1422_terminal_fast_path",
    sessionId: "ses_issue1422_terminal_fast_path",
    threadId: "thread-issue1422-terminal-fast-path",
    ownerUserId: TEST_AGENT_ACTOR.id,
    ownerRole: TEST_AGENT_ACTOR.role,
    finalResponse: { text: finalText, textChars: finalText.length, role: "assistant", status: "completed", traceId, valuesPrinted: false },
    traceSummary: {
      traceId,
      source: "agentrun-command-result",
      sourceEventCount: 3,
      terminalStatus: "completed",
      finalAssistantRow: { role: "assistant", status: "completed", textChars: finalText.length, textPreview: finalText, messageId: `msg_${traceId.slice(4)}`, valuesPrinted: false },
      agentRun: { runId, commandId, lastSeq: 3, valuesPrinted: false },
      valuesPrinted: false
    },
    agentRun: {
      adapter: "agentrun-v01",
      managerUrl: `http://127.0.0.1:${agentRunPort}`,
      runId,
      commandId,
      traceId,
      lastSeq: 3,
      status: "completed",
      commandState: "completed",
      terminalStatus: "completed",
      providerTrace: { traceId, runId, commandId, terminalStatus: "completed", valuesPrinted: false },
      valuesPrinted: false
    },
    providerTrace: { traceId, runId, commandId, terminalStatus: "completed", valuesPrinted: false },
    valuesPrinted: false
  }]]);
  const server = createCloudApiServer({
    traceStore: createCodeAgentTraceStore(),
    codeAgentChatResults,
    env: {
      HWLAB_CODE_AGENT_ADAPTER: "agentrun-v01",
      AGENTRUN_MGR_URL: `http://127.0.0.1:${agentRunPort}`,
      HWLAB_CODE_AGENT_AGENTRUN_ALLOW_NON_K3S_URL: "1",
      HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID: "D601",
      HWLAB_ENVIRONMENT: "v02",
      HWLAB_GITOPS_PROFILE: "v02"
    },
    accessController: {
      required: false,
      async authenticate() {
        return { ok: true, actor: TEST_AGENT_ACTOR, session: TEST_AUTH_SESSION };
      }
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/turns/${traceId}`, {
      headers: { cookie: "hwlab_session=test-stub-session" }
    });
    assert.equal(response.status, 200);
    const body = await response.json();
    assert.equal(body.status, "completed");
    assert.equal(body.terminal, true);
    assert.equal(body.finalResponse.text, finalText);
    assert.equal(body.traceSummary.agentRun.commandId, commandId);
    assert.deepEqual(calls, []);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
    await new Promise((resolve, reject) => {
      agentRunServer.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api turn status does not record terminal side effects from GET reads (#1519)", async () => {
  const ownerCalls = [];
  const factCalls = [];
  let releaseOwnerWrite;
  let ownerWriteReleased = false;
  const ownerWrite = new Promise((resolve) => {
    releaseOwnerWrite = () => {
      if (ownerWriteReleased) return;
      ownerWriteReleased = true;
      resolve();
    };
  });
  const traceId = "trc_issue1422_terminal_effects_once";
  const runId = "run_issue1422_terminal_effects_once";
  const commandId = "cmd_issue1422_terminal_effects_once";
  const finalText = "终态副作用只需要收敛一次。";
  const codeAgentChatResults = new Map([[traceId, {
    accepted: true,
    status: "completed",
    shortConnection: true,
    traceId,
    conversationId: "cnv_issue1422_terminal_effects_once",
    sessionId: "ses_issue1422_terminal_effects_once",
    threadId: "thread-issue1422-terminal-effects-once",
    ownerUserId: TEST_AGENT_ACTOR.id,
    ownerRole: TEST_AGENT_ACTOR.role,
    finalResponse: { text: finalText, textChars: finalText.length, role: "assistant", status: "completed", traceId, valuesPrinted: false },
    traceSummary: {
      traceId,
      source: "agentrun-command-result",
      sourceEventCount: 3,
      terminalStatus: "completed",
      finalAssistantRow: { role: "assistant", status: "completed", textChars: finalText.length, textPreview: finalText, messageId: `msg_${traceId.slice(4)}`, valuesPrinted: false },
      agentRun: { runId, commandId, lastSeq: 3, valuesPrinted: false },
      valuesPrinted: false
    },
    agentRun: {
      adapter: "agentrun-v01",
      managerUrl: "http://127.0.0.1:1",
      runId,
      commandId,
      traceId,
      lastSeq: 3,
      status: "completed",
      commandState: "completed",
      terminalStatus: "completed",
      providerTrace: { traceId, runId, commandId, terminalStatus: "completed", valuesPrinted: false },
      valuesPrinted: false
    },
    providerTrace: { traceId, runId, commandId, terminalStatus: "completed", valuesPrinted: false },
    valuesPrinted: false
  }]]);
  const server = createCloudApiServer({
    traceStore: createCodeAgentTraceStore(),
    codeAgentChatResults,
    env: {
      HWLAB_CODE_AGENT_ADAPTER: "agentrun-v01",
      HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID: "D601",
      HWLAB_ENVIRONMENT: "v02",
      HWLAB_GITOPS_PROFILE: "v02"
    },
    sessionRegistry: {
      recordFact(conversationId, fact) {
        factCalls.push({ conversationId, fact });
        return { ok: true };
      }
    },
    accessController: {
      required: false,
      async authenticate() {
        return { ok: true, actor: TEST_AGENT_ACTOR, session: TEST_AUTH_SESSION };
      },
      async recordAgentSessionOwner(input) {
        ownerCalls.push(input);
        await ownerWrite;
        return { ok: true, sessionId: input.sessionId };
      }
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const fetchTurnStatus = async () => {
      const response = await Promise.race([
        fetch(`http://127.0.0.1:${port}/v1/agent/turns/${traceId}`, {
          headers: { cookie: "hwlab_session=test-stub-session" }
        }),
        delay(250).then(() => null)
      ]);
      assert.ok(response, "turn status should not wait for terminal side effects to finish");
      assert.equal(response.status, 200);
      const body = await response.json();
      assert.equal(body.status, "completed");
      assert.equal(body.finalResponse.text, finalText);
    };
    for (let i = 0; i < 2; i += 1) {
      await fetchTurnStatus();
    }
    for (let i = 0; i < 20 && ownerCalls.length < 1; i += 1) await delay(10);
    assert.equal(ownerCalls.length, 0);
    assert.equal(factCalls.length, 0);
    assert.equal(codeAgentChatResults.get(traceId).turnStatusTerminalEffects, undefined);
    releaseOwnerWrite();
    assert.equal(codeAgentChatResults.get(traceId).turnStatusTerminalEffects, undefined);
  } finally {
    releaseOwnerWrite?.();
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api legacy trace read does not repair historical AgentRun trace after lastTraceId advances (#1519)", async () => {
  const calls = [];
  const ownerSessions = new Map();
  const runId = "run_issue955_historical";
  const firstTraceId = "trc_issue955_historical_first";
  const secondTraceId = "trc_issue955_historical_second";
  const firstCommandId = "cmd_issue955_historical_first";
  const secondCommandId = "cmd_issue955_historical_second";
  const firstFinalText = "目前只有一个 HWPOD 可用：\n\n- d601-f103-v2 (board: D601-F103-V2 / STM32F103)\n\nAPI 返回 count=1, availableCount=1。";
  const secondFinalText = "编译成功！hwpod build completed。";
  const events = [
    { id: "evt_issue955_hist_first_created", runId, seq: 1, type: "command_created", payload: { commandId: firstCommandId }, createdAt: "2026-06-06T01:43:23.000Z" },
    { id: "evt_issue955_hist_first_tool", runId, seq: 25, type: "tool_call", payload: { method: "item/completed", type: "commandExecution", toolName: "commandExecution", itemId: "call_issue955_hwpod_list", command: "/bin/sh -lc 'hwpod list --available'", status: "completed", exitCode: 0, outputSummary: '{\"count\":1,\"availableCount\":1}', commandId: firstCommandId }, createdAt: "2026-06-06T01:43:46.000Z" },
    { id: "evt_issue955_hist_first_message", runId, seq: 34, type: "assistant_message", payload: { commandId: firstCommandId, itemId: "msg_issue955_first", text: firstFinalText }, createdAt: "2026-06-06T01:46:19.000Z" },
    { id: "evt_issue955_hist_first_done", runId, seq: 35, type: "terminal_status", payload: { commandId: firstCommandId, terminalStatus: "completed" }, createdAt: "2026-06-06T01:46:19.000Z" },
    { id: "evt_issue955_hist_second_created", runId, seq: 36, type: "command_created", payload: { commandId: secondCommandId }, createdAt: "2026-06-06T01:46:11.000Z" },
    { id: "evt_issue955_hist_second_message", runId, seq: 58, type: "assistant_message", payload: { commandId: secondCommandId, itemId: "msg_issue955_second", text: secondFinalText }, createdAt: "2026-06-06T01:46:28.000Z" },
    { id: "evt_issue955_hist_second_done", runId, seq: 67, type: "terminal_status", payload: { commandId: secondCommandId, terminalStatus: "completed" }, createdAt: "2026-06-06T01:46:28.000Z" }
  ];
  const agentRunServer = createHttpServer(async (request, response) => {
    const url = new URL(request.url || "/", "http://127.0.0.1");
    calls.push({ method: request.method, path: url.pathname, search: url.search });
    const send = (data) => {
      response.writeHead(200, { "content-type": "application/json" });
      response.end(`${JSON.stringify({ ok: true, data, traceId: "trc_fake_issue955_historical" })}\n`);
    };
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/commands`) {
      return send({ items: [
        { id: firstCommandId, runId, state: "completed", idempotencyKey: firstTraceId, createdAt: "2026-06-06T01:43:30.040Z", updatedAt: "2026-06-06T01:43:46.360Z", payload: { traceId: firstTraceId, conversationId: "cnv_issue955_historical", hwlabSessionId: "ses_issue955_historical", threadId: "thread-issue955-historical", providerProfile: "deepseek" } },
        { id: secondCommandId, runId, state: "completed", idempotencyKey: secondTraceId, createdAt: "2026-06-06T01:46:11.000Z", updatedAt: "2026-06-06T01:46:28.000Z", payload: { traceId: secondTraceId, conversationId: "cnv_issue955_historical", hwlabSessionId: "ses_issue955_historical", threadId: "thread-issue955-historical", providerProfile: "deepseek" } }
      ] });
    }
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/commands/${firstCommandId}/result`) {
      return send({ runId, commandId: firstCommandId, status: "completed", runStatus: "completed", commandState: "completed", terminalStatus: "completed", completed: true, reply: firstFinalText, lastSeq: 35, eventCount: 35, sessionRef: { sessionId: "ses_agentrun_deepseek_issue955", conversationId: "cnv_issue955_historical", threadId: "thread-issue955-historical" } });
    }
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/commands/${secondCommandId}/result`) {
      return send({ runId, commandId: secondCommandId, status: "completed", runStatus: "completed", commandState: "completed", terminalStatus: "completed", completed: true, reply: secondFinalText, lastSeq: 67, eventCount: 67, sessionRef: { sessionId: "ses_agentrun_deepseek_issue955", conversationId: "cnv_issue955_historical", threadId: "thread-issue955-historical" } });
    }
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/events`) {
      return send({ items: events });
    }
    response.writeHead(404, { "content-type": "application/json" });
    response.end(`${JSON.stringify({ ok: false, message: `unexpected ${request.method} ${url.pathname}` })}\n`);
  });
  await new Promise((resolve) => agentRunServer.listen(0, "127.0.0.1", resolve));

  const agentRunPort = agentRunServer.address().port;
  ownerSessions.set("ses_issue955_historical", testAgentSessionRecord({
    sessionId: "ses_issue955_historical",
    projectId: "prj_v02_code_agent",
    conversationId: "cnv_issue955_historical",
    threadId: "thread-issue955-historical",
    lastTraceId: secondTraceId,
    status: "active",
    session: {
      messages: [
        { id: "msg_issue955_user_first", role: "user", text: "看看有几个hwpod可用", traceId: firstTraceId, status: "submitted" },
        { id: "msg_issue955_user_second", role: "user", text: "试一下编译 d601-f103-v2", traceId: secondTraceId, status: "submitted" },
        { id: "msg_issue955_second", role: "agent", text: firstFinalText, traceId: secondTraceId, status: "idle" }
      ],
      agentRun: { adapter: "agentrun-v01", managerUrl: `http://127.0.0.1:${agentRunPort}`, runId, commandId: firstCommandId, backendProfile: "deepseek", terminalStatus: "completed", lastSeq: 35, valuesPrinted: false },
      finalResponse: { text: firstFinalText, textChars: firstFinalText.length, role: "assistant", status: "completed", traceId: secondTraceId, valuesPrinted: false },
      traceSummary: { traceId: secondTraceId, source: "code-agent-derived-session-evidence", sourceEventCount: 36, terminalStatus: "completed", agentRun: { runId, commandId: firstCommandId, lastSeq: 35, valuesPrinted: false }, valuesPrinted: false },
      traceResults: {
        [secondTraceId]: {
          traceId: secondTraceId,
          status: "completed",
          conversationId: "cnv_issue955_historical",
          sessionId: "ses_issue955_historical",
          threadId: "thread-issue955-historical",
          finalResponse: { text: firstFinalText, textChars: firstFinalText.length, role: "assistant", status: "completed", traceId: secondTraceId, valuesPrinted: false },
          traceSummary: { traceId: secondTraceId, source: "agent-session-trace-repair", sourceEventCount: 4, terminalStatus: "completed", agentRun: { runId, commandId: firstCommandId, lastSeq: 35, valuesPrinted: false }, valuesPrinted: false },
          agentRun: { adapter: "agentrun-v01", managerUrl: `http://127.0.0.1:${agentRunPort}`, runId, commandId: firstCommandId, backendProfile: "deepseek", terminalStatus: "completed", lastSeq: 35, valuesPrinted: false },
          valuesRedacted: true
        }
      },
      valuesRedacted: true
    }
  }));

  const server = createCloudApiServer({
    traceStore: createCodeAgentTraceStore(),
    env: {
      HWLAB_CODE_AGENT_ADAPTER: "agentrun-v01",
      AGENTRUN_MGR_URL: `http://127.0.0.1:${agentRunPort}`,
      HWLAB_CODE_AGENT_AGENTRUN_ALLOW_NON_K3S_URL: "1",
      HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID: "D601",
      HWLAB_ENVIRONMENT: "v02",
      HWLAB_GITOPS_PROFILE: "v02"
    },
    accessController: {
      required: false,
      async authenticate() {
        return { ok: true, actor: TEST_AGENT_ACTOR, session: TEST_AUTH_SESSION };
      },
      async getAgentSessionByTraceId(traceId) {
        return [...ownerSessions.values()].find((session) => session.lastTraceId === traceId || session.session?.messages?.some((message) => message.traceId === traceId)) ?? null;
      },
      async recordAgentSessionOwner(input) {
        const existing = ownerSessions.get(input.sessionId) ?? testAgentSessionRecord(input);
        const nextSession = { ...(existing.session ?? {}), ...(input.session ?? {}) };
        nextSession.traceResults = { ...(existing.session?.traceResults ?? {}), ...(input.session?.traceResults ?? {}) };
        const record = testAgentSessionRecord({ ...existing, ...input, session: nextSession });
        ownerSessions.set(record.id, record);
        return record;
      }
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/traces/${firstTraceId}`, {
      headers: { cookie: "hwlab_session=test-stub-session" }
    });
    assert.equal(response.status, 200);
    const body = await response.json();
    assert.equal(body.traceId, firstTraceId);
    assert.equal(body.status, "missing");
    assert.equal(body.projectionStatus, "unknown");
    assert.equal(body.eventCount, 0);
    assert.deepEqual(calls, []);
    assert.equal(ownerSessions.get("ses_issue955_historical").session.traceResults[firstTraceId], undefined);

    const secondResultResponse = await fetch(`http://127.0.0.1:${port}/v1/agent/chat/result/${secondTraceId}`, {
      headers: { cookie: "hwlab_session=test-stub-session" }
    });
    assert.equal(secondResultResponse.status, 200);
    const secondResult = await secondResultResponse.json();
    assert.equal(secondResult.traceId, secondTraceId);
    assert.equal(secondResult.projectionStatus, "caught-up");
    assert.equal(secondResult.agentRun.commandId, firstCommandId);
    assert.deepEqual(calls, []);
    assert.equal(ownerSessions.get("ses_issue955_historical").session.traceResults[secondTraceId].agentRun.commandId, firstCommandId);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
    await new Promise((resolve, reject) => {
      agentRunServer.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api result polling does not repair polluted completed AgentRun memory cache (#1519)", async () => {
  const calls = [];
  const runId = "run_issue955_live_cache";
  const firstTraceId = "trc_issue955_live_cache_first";
  const secondTraceId = "trc_issue955_live_cache_second";
  const firstCommandId = "cmd_issue955_live_cache_first";
  const secondCommandId = "cmd_issue955_live_cache_second";
  const firstFinalText = "目前只有一个 HWPOD 可用：d601-f103-v2。";
  const secondFinalText = "编译成功！hwpod build completed，Keil MDK USART atk_f103.hex queued。";
  const events = [
    { id: "evt_issue955_live_first_message", runId, seq: 10, type: "assistant_message", payload: { commandId: firstCommandId, itemId: "msg_issue955_live_first", text: firstFinalText }, createdAt: "2026-06-06T01:46:19.000Z" },
    { id: "evt_issue955_live_first_done", runId, seq: 11, type: "terminal_status", payload: { commandId: firstCommandId, terminalStatus: "completed" }, createdAt: "2026-06-06T01:46:19.000Z" },
    { id: "evt_issue955_live_second_message", runId, seq: 20, type: "assistant_message", payload: { commandId: secondCommandId, itemId: "msg_issue955_live_second", text: secondFinalText }, createdAt: "2026-06-06T01:46:28.000Z" },
    { id: "evt_issue955_live_second_done", runId, seq: 21, type: "terminal_status", payload: { commandId: secondCommandId, terminalStatus: "completed" }, createdAt: "2026-06-06T01:46:28.000Z" }
  ];
  const agentRunServer = createHttpServer(async (request, response) => {
    const url = new URL(request.url || "/", "http://127.0.0.1");
    calls.push({ method: request.method, path: url.pathname, search: url.search });
    const send = (data) => {
      response.writeHead(200, { "content-type": "application/json" });
      response.end(`${JSON.stringify({ ok: true, data, traceId: "trc_fake_issue955_live_cache" })}\n`);
    };
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/commands`) {
      return send({ items: [
        { id: firstCommandId, runId, state: "completed", idempotencyKey: firstTraceId, payload: { traceId: firstTraceId, conversationId: "cnv_issue955_live_cache", hwlabSessionId: "ses_issue955_live_cache", threadId: "thread-issue955-live-cache" } },
        { id: secondCommandId, runId, state: "completed", idempotencyKey: secondTraceId, payload: { traceId: secondTraceId, conversationId: "cnv_issue955_live_cache", hwlabSessionId: "ses_issue955_live_cache", threadId: "thread-issue955-live-cache" } }
      ] });
    }
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/commands/${firstCommandId}/result`) {
      return send({ runId, commandId: firstCommandId, status: "completed", runStatus: "completed", commandState: "completed", terminalStatus: "completed", completed: true, reply: firstFinalText, lastSeq: 11, eventCount: 11 });
    }
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/commands/${secondCommandId}/result`) {
      return send({ runId, commandId: secondCommandId, status: "completed", runStatus: "completed", commandState: "completed", terminalStatus: "completed", completed: true, reply: secondFinalText, lastSeq: 21, eventCount: 21 });
    }
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/events`) {
      return send({ items: events });
    }
    response.writeHead(404, { "content-type": "application/json" });
    response.end(`${JSON.stringify({ ok: false, message: `unexpected ${request.method} ${url.pathname}` })}\n`);
  });
  await new Promise((resolve) => agentRunServer.listen(0, "127.0.0.1", resolve));

  const agentRunPort = agentRunServer.address().port;
  const codeAgentChatResults = new Map();
  codeAgentChatResults.set(secondTraceId, {
    accepted: true,
    status: "completed",
    shortConnection: true,
    traceId: secondTraceId,
    conversationId: "cnv_issue955_live_cache",
    sessionId: "ses_issue955_live_cache",
    threadId: "thread-issue955-live-cache",
    ownerUserId: TEST_AGENT_ACTOR.id,
    ownerRole: TEST_AGENT_ACTOR.role,
    reply: { role: "assistant", content: firstFinalText },
    finalResponse: { text: firstFinalText, textChars: firstFinalText.length, role: "assistant", status: "completed", traceId: secondTraceId, valuesPrinted: false },
    traceSummary: { traceId: secondTraceId, source: "code-agent-derived-session-evidence", sourceEventCount: 11, terminalStatus: "completed", agentRun: { runId, commandId: firstCommandId, lastSeq: 11, valuesPrinted: false }, valuesPrinted: false },
    agentRun: {
      adapter: "agentrun-v01",
      managerUrl: `http://127.0.0.1:${agentRunPort}`,
      runId,
      commandId: firstCommandId,
      traceId: secondTraceId,
      lastSeq: 11,
      terminalStatus: "completed",
      providerTrace: { traceId: secondTraceId, runId, commandId: firstCommandId, terminalStatus: "completed", valuesPrinted: false },
      valuesPrinted: false
    },
    providerTrace: { traceId: secondTraceId, runId, commandId: firstCommandId, terminalStatus: "completed", valuesPrinted: false },
    valuesPrinted: false
  });

  const server = createCloudApiServer({
    traceStore: createCodeAgentTraceStore(),
    codeAgentChatResults,
    env: {
      HWLAB_CODE_AGENT_ADAPTER: "agentrun-v01",
      AGENTRUN_MGR_URL: `http://127.0.0.1:${agentRunPort}`,
      HWLAB_CODE_AGENT_AGENTRUN_ALLOW_NON_K3S_URL: "1",
      HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID: "D601",
      HWLAB_ENVIRONMENT: "v02",
      HWLAB_GITOPS_PROFILE: "v02"
    },
    accessController: {
      required: false,
      async authenticate() {
        return { ok: true, actor: TEST_AGENT_ACTOR, session: TEST_AUTH_SESSION };
      }
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat/result/${secondTraceId}`, {
      headers: { cookie: "hwlab_session=test-stub-session" }
    });
    assert.equal(response.status, 200);
    const body = await response.json();
    const text = JSON.stringify(body);
    assert.equal(body.traceId, secondTraceId);
    assert.equal(body.status, "completed");
    assert.equal(body.projectionStatus, "caught-up");
    assert.equal(body.agentRun.commandId, firstCommandId);
    assert.equal(body.agentRun.traceId, secondTraceId);
    assert.equal(body.terminalEvidence.available, true);
    assert.equal(body.terminalEvidence.agentRun.commandId, firstCommandId);
    assert.equal(body.terminalEvidence.finalResponse.traceId, secondTraceId);
    assert.equal(body.reply.content, firstFinalText);
    assert.match(text, /目前只有一个 HWPOD 可用/u);
    assert.doesNotMatch(text, /编译成功/u);
    assert.equal(text.includes('"fallback"'), false);
    assert.deepEqual(calls, []);
    assert.equal(codeAgentChatResults.get(secondTraceId).agentRun.commandId, firstCommandId);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
    await new Promise((resolve, reject) => {
      agentRunServer.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api result polling does not query AgentRun registry when projection is stale (#1519)", async () => {
  const calls = [];
  const runId = "run_issue955_registry_missing";
  const traceId = "trc_issue955_registry_missing";
  const staleCommandId = "cmd_issue955_registry_stale";
  const staleFinalText = "目前只有一个 HWPOD 可用：d601-f103-v2。";
  const agentRunServer = createHttpServer(async (request, response) => {
    const url = new URL(request.url || "/", "http://127.0.0.1");
    calls.push({ method: request.method, path: url.pathname });
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/commands`) {
      response.writeHead(200, { "content-type": "application/json" });
      response.end(`${JSON.stringify({ ok: true, data: { items: [] }, traceId: "trc_fake_issue955_missing" })}\n`);
      return;
    }
    response.writeHead(404, { "content-type": "application/json" });
    response.end(`${JSON.stringify({ ok: false, message: `unexpected ${request.method} ${url.pathname}` })}\n`);
  });
  await new Promise((resolve) => agentRunServer.listen(0, "127.0.0.1", resolve));

  const agentRunPort = agentRunServer.address().port;
  const codeAgentChatResults = new Map();
  codeAgentChatResults.set(traceId, {
    accepted: true,
    status: "completed",
    shortConnection: true,
    traceId,
    conversationId: "cnv_issue955_registry_missing",
    sessionId: "ses_issue955_registry_missing",
    threadId: "thread-issue955-registry-missing",
    ownerUserId: TEST_AGENT_ACTOR.id,
    ownerRole: TEST_AGENT_ACTOR.role,
    reply: { role: "assistant", content: staleFinalText },
    finalResponse: { text: staleFinalText, textChars: staleFinalText.length, role: "assistant", status: "completed", traceId, valuesPrinted: false },
    agentRun: { adapter: "agentrun-v01", managerUrl: `http://127.0.0.1:${agentRunPort}`, runId, commandId: staleCommandId, traceId, terminalStatus: "completed", valuesPrinted: false },
    valuesPrinted: false
  });

  const server = createCloudApiServer({
    traceStore: createCodeAgentTraceStore(),
    codeAgentChatResults,
    env: {
      HWLAB_CODE_AGENT_ADAPTER: "agentrun-v01",
      AGENTRUN_MGR_URL: `http://127.0.0.1:${agentRunPort}`,
      HWLAB_CODE_AGENT_AGENTRUN_ALLOW_NON_K3S_URL: "1",
      HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID: "D601",
      HWLAB_ENVIRONMENT: "v02",
      HWLAB_GITOPS_PROFILE: "v02"
    },
    accessController: {
      required: false,
      async authenticate() {
        return { ok: true, actor: TEST_AGENT_ACTOR, session: TEST_AUTH_SESSION };
      }
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat/result/${traceId}`, {
      headers: { cookie: "hwlab_session=test-stub-session" }
    });
    assert.equal(response.status, 200);
    const body = await response.json();
    const text = JSON.stringify(body);
    assert.equal(body.traceId, traceId);
    assert.equal(body.status, "completed");
    assert.equal(body.projectionStatus, "caught-up");
    assert.equal(body.agentRun.commandId, staleCommandId);
    assert.match(text, /目前只有一个 HWPOD 可用/u);
    assert.deepEqual(calls, []);
    assert.equal(calls.some((call) => call.path.includes("/result")), false);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
    await new Promise((resolve, reject) => {
      agentRunServer.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api result polling compacts large runnerTrace while preserving providerTrace", async () => {
  const workspace = await mkdtemp(path.join(os.tmpdir(), "hwlab-agent-result-compact-"));
  const codexHome = await mkdtemp(path.join(os.tmpdir(), "hwlab-agent-result-compact-codex-home-"));
  const server = createCloudApiServer({
    env: {
      PATH: process.env.PATH,
      CODEX_HOME: codexHome,
      HWLAB_CODE_AGENT_CODEX_WORKSPACE: workspace,
      HWLAB_CODE_AGENT_CODEX_SANDBOX: "danger-full-access",
      HWLAB_CODE_AGENT_PROVIDER: "codex-stdio",
      HWLAB_CODE_AGENT_MODEL: "gpt-test",
      HWLAB_CODE_AGENT_RESULT_TRACE_EVENT_LIMIT: "32",
      OPENAI_API_KEY: "test-openai-key-material",
      HWLAB_CODE_AGENT_OPENAI_BASE_URL: "http://127.0.0.1:65535/v1/responses"
    },
    codexStdioManager: {
      describe() {
        return {
          ...codexStdioReadyFixture({ workspace, codexHome }),
          sandbox: "danger-full-access"
        };
      },
      async probe() {
        return {
          ...codexStdioReadyFixture({ workspace, codexHome }),
          sandbox: "danger-full-access"
        };
      },
      async chat(params = {}) {
        const base = codexStdioChatFixture({ workspace, codexHome, params });
        const events = Array.from({ length: 160 }, (_, index) => ({
          seq: index + 1,
          traceId: params.traceId,
          type: "assistant_message",
          status: "chunk",
          label: index === 159 ? "assistant:completed" : "assistant:chunk",
          createdAt: "2026-05-23T00:00:00.000Z",
          waitingFor: index === 159 ? null : "turn/completed",
          valuesPrinted: false
        }));
        return {
          ...base,
          sandbox: "danger-full-access",
          session: {
            ...base.session,
            sandbox: "danger-full-access"
          },
          runnerTrace: {
            ...base.runnerTrace,
            events,
            eventLabels: events.map((event) => event.label),
            eventCount: events.length,
            lastEvent: events.at(-1)
          }
        };
      },
      cancel() {},
      reapIdle() {}
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const traceId = "trc_server-test-result-compact";
    const manualSession = await createManualAgentSession(port, {
      conversationId: "cnv_server-test-result-compact"
    });
    const submit = await fetch(`http://127.0.0.1:${port}/v1/agent/chat`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        cookie: manualSession.cookie,
        "x-trace-id": traceId,
        "prefer": "respond-async",
        "x-hwlab-short-connection": "1"
      },
      body: JSON.stringify({
        conversationId: manualSession.conversationId,
        sessionId: manualSession.sessionId,
        message: "生成大量 trace 后返回"
      })
    });
    assert.equal(submit.status, 202);

    const payload = await pollAgentResult(port, traceId);
    validateCodeAgentChatSchema(payload);
    assert.equal(payload.status, "completed");
    assert.equal(payload.traceId, traceId);
    assert.equal(payload.providerTrace.protocol, "codex-app-server-jsonrpc-stdio");
    assert.equal(payload.providerTrace.command, "codex app-server --listen stdio://");
    assert.equal(payload.runnerTrace.eventCount, 160);
    assert.equal(payload.runnerTrace.eventsCompacted, true);
    assert.equal(payload.runnerTrace.events.length, 32);
    assert.equal(payload.runnerTrace.events.some((event) => event.label === "trace:compacted"), true);
    assert.equal(payload.runnerTrace.lastEvent.label, "assistant:completed");
    assert.equal(payload.runnerTrace.eventLabels.includes("trace:compacted"), true);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
    await rm(workspace, { recursive: true, force: true });
    await rm(codexHome, { recursive: true, force: true });
  }
});

test("cloud api /v1/agent/chat answers skills prompt through real Codex stdio and retains trace", async () => {
  const workspace = await mkdtemp(path.join(os.tmpdir(), "hwlab-agent-stdio-skills-"));
  const codexHome = path.join(workspace, "codex-home");
  const skillsDir = path.join(workspace, "skills");
  const fakeCodex = await createFakeCodexCommand();
  await mkdir(path.join(skillsDir, "hwlab-test-skill"), { recursive: true });
  await prepareFakeCodexHome(codexHome);
  await writeFile(path.join(skillsDir, "hwlab-test-skill", "SKILL.md"), [
    "---",
    "name: hwlab-test-skill",
    "description: Test skill mounted for Codex stdio discovery.",
    "version: v-test",
    "---",
    "",
    "# HWLAB Test Skill"
  ].join("\n"));
  const server = createCloudApiServer({
    env: {
      PATH: process.env.PATH,
      OPENAI_API_KEY: "test-openai-key-material",
      CODEX_HOME: codexHome,
      HWLAB_CODE_AGENT_PROVIDER: "codex-stdio",
      HWLAB_CODE_AGENT_MODEL: "gpt-test",
      HWLAB_CODE_AGENT_CODEX_COMMAND: fakeCodex.command,
      HWLAB_CODE_AGENT_CODEX_STDIO_ENABLED: "1",
      HWLAB_CODE_AGENT_CODEX_STDIO_SUPERVISOR: "repo-owned",
      HWLAB_CODE_AGENT_CODEX_WORKSPACE: workspace,
      HWLAB_CODE_AGENT_SKILLS_DIRS: skillsDir,
      HWLAB_CODE_AGENT_SKILLS_STRICT: "1",
      HWLAB_CODE_AGENT_OPENAI_BASE_URL: "http://127.0.0.1:65535/v1/responses"
    },
    codexStdioManager: createCodexStdioSessionManager({
      idFactory: () => "ses_server_stdio_skills",
      createRpcClient: async () => createFakeAppServerClient({
        text: "模型泛化回答不应成为 skills 最终回复。"
      })
    })
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const payload = await postAgent(port, {
      conversationId: "cnv_server_stdio_skills",
      traceId: "trc_server_stdio_skills",
      message: "列出你可用的skills"
    });

    validateCodeAgentChatSchema(payload);
    assert.equal(payload.status, "completed");
    assert.equal(payload.provider, "codex-stdio");
    assert.equal(payload.backend, "hwlab-cloud-api/codex-app-server-stdio");
    assert.equal(payload.capabilityLevel, "long-lived-codex-stdio-session");
    assert.equal(payload.providerTrace.sidecarOnly, undefined);
    assert.equal(payload.providerTrace.toolName, "codex-app-server.thread/start+turn/start");
    assert.equal(payload.skills.status, "ready");
    const discovered = payload.skills.items.find((skill) => skill.name === "hwlab-test-skill");
    assert.ok(discovered);
    assert.equal(discovered.source, path.join(skillsDir, "hwlab-test-skill", "SKILL.md"));
    assert.equal(discovered.manifest.path, path.join(skillsDir, "hwlab-test-skill", "SKILL.md"));
    assert.equal(discovered.version, "v-test");
    assert.ok(payload.toolCalls.some((toolCall) => toolCall.name === "skills.discover" && toolCall.status === "completed"));
    assert.match(payload.reply.content, /hwlab-test-skill/u);
    assert.match(payload.reply.content, /真实 skill manifest 清单/u);
    assert.doesNotMatch(payload.reply.content, /模型泛化回答/u);
    assert.ok(payload.runnerTrace.events.some((event) => event.label === "prompt:sent"));
    assert.ok(payload.runnerTrace.events.some((event) => event.label === "tool:codex-app-server.thread/start+turn/start:started"));
    assert.equal(JSON.stringify(payload).includes("test-openai-key-material"), false);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
    await rm(workspace, { recursive: true, force: true });
    await rm(fakeCodex.root, { recursive: true, force: true });
  }
});

test("cloud api /v1/agent/chat returns structured skills blocker without local skills manifest", async () => {
  const workspace = await mkdtemp(path.join(os.tmpdir(), "hwlab-agent-stdio-skills-missing-"));
  const codexHome = path.join(workspace, "codex-home");
  const fakeCodex = await createFakeCodexCommand();
  await prepareFakeCodexHome(codexHome);
  const server = createCloudApiServer({
    env: {
      PATH: process.env.PATH,
      OPENAI_API_KEY: "test-openai-key-material",
      CODEX_HOME: codexHome,
      HWLAB_CODE_AGENT_PROVIDER: "codex-stdio",
      HWLAB_CODE_AGENT_MODEL: "gpt-test",
      HWLAB_CODE_AGENT_CODEX_COMMAND: fakeCodex.command,
      HWLAB_CODE_AGENT_CODEX_STDIO_ENABLED: "1",
      HWLAB_CODE_AGENT_CODEX_STDIO_SUPERVISOR: "repo-owned",
      HWLAB_CODE_AGENT_CODEX_WORKSPACE: workspace,
      HWLAB_CODE_AGENT_SKILLS_DIRS: path.join(workspace, "missing-skills"),
      HWLAB_CODE_AGENT_SKILLS_STRICT: "1",
      HWLAB_CODE_AGENT_OPENAI_BASE_URL: "http://127.0.0.1:65535/v1/responses"
    },
    codexStdioManager: createCodexStdioSessionManager({
      idFactory: () => "ses_server_stdio_skills_missing",
      createRpcClient: async () => createFakeAppServerClient({
        text: "模型泛化回答：alpha-skill"
      })
    })
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const payload = await postAgent(port, {
      conversationId: "cnv_server_stdio_skills_missing",
      traceId: "trc_server_stdio_skills_missing",
      message: "列出你可用的skills"
    });

    validateCodeAgentChatSchema(payload);
    assert.equal(payload.status, "failed");
    assert.equal(payload.provider, "codex-stdio");
    assert.equal(payload.backend, "hwlab-cloud-api/codex-app-server-stdio");
    assert.equal(payload.capabilityLevel, "blocked");
    assert.equal(payload.error.code, "skills_unavailable");
    assert.equal(payload.skills.status, "blocked");
    assert.equal(payload.skills.blockers[0].code, "skills_unavailable");
    assert.deepEqual(payload.skills.sourceIssues, ["pikasTech/HWLAB#136", "pikasTech/HWLAB#237"]);
    assert.ok(payload.toolCalls.some((toolCall) => toolCall.name === "skills.discover" && toolCall.status === "blocked"));
    assert.equal(payload.toolCalls.some((toolCall) => toolCall.name === "codex-app-server.thread/start+turn/start"), false);
    assert.equal(payload.session.status, "idle");
    assert.equal(Object.hasOwn(payload, "reply"), false);
    assert.equal(JSON.stringify(payload).includes("alpha-skill"), false);
    assert.equal(JSON.stringify(payload).includes("test-openai-key-material"), false);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
    await rm(workspace, { recursive: true, force: true });
    await rm(fakeCodex.root, { recursive: true, force: true });
  }
});

test("cloud api /v1/agent/chat blocks forbidden file paths without leaking values", async () => {
  const workspace = await mkdtemp(path.join(os.tmpdir(), "hwlab-agent-file-block-"));
  const server = createCloudApiServer({
    env: {
      PATH: process.env.PATH,
      HWLAB_CODE_AGENT_WORKSPACE: workspace
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const payload = await postAgent(port, {
      conversationId: "cnv_server-test-security-block",
      traceId: "trc_server-test-security-block",
      message: "cat ../outside.txt"
    });
    assert.equal(payload.status, "failed");
    assert.match(payload.error.code, /^(codex_cli_binary_missing|stdio_protocol_not_wired)$/u);
    assert.deepEqual(payload.toolCalls, []);
    assert.equal(payload.capabilityLevel, "blocked");
    assert.ok(payload.runnerTrace.events.some((event) => event.label === "codex-stdio:blocked"));
    assert.equal(Object.hasOwn(payload, "reply"), false);
    assert.equal(JSON.stringify(payload).includes("sk-"), false);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api /v1/agent/chat/cancel reports unsupported lifecycle degradation", async () => {
  const traceStore = createCodeAgentTraceStore();
  traceStore.append("trc_cancel_unsupported", {
    type: "request",
    status: "running",
    label: "request:running",
    sessionId: "ses_cancel_unsupported",
    sessionStatus: "busy",
    sessionLifecycleStatus: "busy"
  });
  const server = createCloudApiServer({
    traceStore,
    codexStdioManager: {
      get() {
        return null;
      }
    },
    env: {
      PATH: process.env.PATH,
      HWLAB_CODE_AGENT_PROVIDER: "codex-stdio"
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat/cancel`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        "x-trace-id": "trc_cancel_unsupported"
      },
      body: JSON.stringify({
        conversationId: "cnv_cancel_unsupported",
        sessionId: "ses_cancel_unsupported",
        traceId: "trc_cancel_unsupported"
      })
    });
    assert.equal(response.status, 501);
    const payload = await response.json();
    assert.equal(payload.status, "degraded");
    assert.equal(payload.unsupported, true);
    assert.equal(payload.degraded, true);
    assert.equal(payload.error.code, "cancel_unsupported");
    assert.equal(payload.sessionLifecycleStatus, "failed");
    assert.equal(payload.sessionSummary.unsupported, true);
    assert.match(payload.sessionSummary.userMessage, /unsupported\/degraded/u);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api /v1/agent/chat/cancel rejects AgentRun trace scope mismatch", async () => {
  const traceId = "trc_cancel_scope_mismatch";
  const codeAgentChatResults = new Map();
  const traceStore = createCodeAgentTraceStore();
  codeAgentChatResults.set(traceId, {
    traceId,
    status: "running",
    conversationId: "cnv_cancel_scope",
    sessionId: "ses_cancel_scope",
    threadId: "thread-cancel-scope",
    agentRun: {
      runId: "run_cancel_scope",
      commandId: "cmd_cancel_scope",
      sessionId: "ses_agentrun_cancel_scope",
      conversationId: "cnv_cancel_scope",
      threadId: "thread-cancel-scope",
      managerUrl: "http://127.0.0.1:65535",
      status: "running",
      commandState: "running"
    }
  });
  const server = createCloudApiServer({
    traceStore,
    codeAgentChatResults,
    env: {
      PATH: process.env.PATH,
      HWLAB_CODE_AGENT_ADAPTER: "agentrun-v01",
      HWLAB_CODE_AGENT_PROVIDER: "agentrun-v01",
      HWLAB_CODE_AGENT_AGENTRUN_ALLOW_NON_K3S_URL: "1"
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat/cancel`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        "x-trace-id": traceId
      },
      body: JSON.stringify({
        conversationId: "cnv_cancel_scope_other",
        sessionId: "ses_cancel_scope_other",
        threadId: "thread-cancel-scope-other",
        traceId
      })
    });
    assert.equal(response.status, 409);
    const payload = await response.json();
    assert.equal(payload.status, "blocked");
    assert.equal(payload.canceled, false);
    assert.equal(payload.error.code, "cancel_scope_mismatch");
    assert.equal(codeAgentChatResults.get(traceId)?.status, "running");
    assert.ok(traceStore.snapshot(traceId)?.events?.some((event) => event.label === "agentrun:cancel:scope_mismatch"));
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api /v1/agent/chat/cancel keeps already terminal AgentRun result instead of overwriting", async () => {
  const traceId = "trc_cancel_already_terminal";
  const codeAgentChatResults = new Map();
  const traceStore = createCodeAgentTraceStore();
  codeAgentChatResults.set(traceId, {
    traceId,
    status: "completed",
    finalResponse: "OK",
    conversationId: "cnv_cancel_already_terminal",
    sessionId: "ses_cancel_already_terminal",
    threadId: "thread-cancel-already-terminal",
    agentRun: {
      runId: "run_cancel_already_terminal",
      commandId: "cmd_cancel_already_terminal",
      sessionId: "ses_agentrun_cancel_already_terminal",
      conversationId: "cnv_cancel_already_terminal",
      threadId: "thread-cancel-already-terminal",
      status: "completed",
      commandState: "completed",
      terminalStatus: "completed"
    }
  });
  const accessController = {
    required: false,
    async authenticate() { return { ok: true, actor: TEST_AGENT_ACTOR, session: TEST_AUTH_SESSION }; }
  };
  const server = createCloudApiServer({
    traceStore,
    codeAgentChatResults,
    accessController,
    env: {
      PATH: process.env.PATH,
      HWLAB_CODE_AGENT_ADAPTER: "agentrun-v01",
      HWLAB_CODE_AGENT_PROVIDER: "agentrun-v01"
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat/cancel`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        "x-trace-id": traceId
      },
      body: JSON.stringify({
        conversationId: "cnv_cancel_already_terminal",
        sessionId: "ses_cancel_already_terminal",
        threadId: "thread-cancel-already-terminal",
        traceId
      })
    });
    assert.equal(response.status, 200);
    const payload = await response.json();
    assert.equal(payload.status, "completed");
    assert.equal(payload.finalResponse, "OK");
    assert.equal(payload.cancelDisposition.status, "already_terminal");
    assert.equal(payload.cancelDisposition.forwarded, false);
    assert.equal(codeAgentChatResults.get(traceId).status, "completed");
    assert.ok(traceStore.snapshot(traceId)?.events?.some((event) => event.label === "agentrun:cancel:already-terminal"));
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api /v1/agent/chat/cancel returns already-terminal when AgentRun result completed", async () => {
  const calls = [];
  const traceId = "trc_cancel_terminal_result_authority";
  const runId = "run_cancel_terminal_result_authority";
  const commandId = "cmd_cancel_terminal_result_authority";
  const finalText = "Cancel did not overwrite the completed AgentRun result.";
  const agentRunServer = createHttpServer(async (request, response) => {
    const url = new URL(request.url || "/", "http://127.0.0.1");
    calls.push({ method: request.method, path: url.pathname });
    const send = (body, status = 200) => {
      response.writeHead(status, { "content-type": "application/json" });
      response.end(`${JSON.stringify(body)}\n`);
    };
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/events`) return send({ items: [] });
    if (request.method === "GET" && url.pathname === `/api/v1/runs/${runId}/commands/${commandId}/result`) {
      return send({ runId, commandId, status: "completed", runStatus: "completed", commandState: "completed", terminalStatus: "completed", completed: true, reply: finalText, lastSeq: 7, eventCount: 7 });
    }
    if (request.method === "POST" && url.pathname === `/api/v1/commands/${commandId}/cancel`) return send({ ok: true, canceled: true });
    return send({ ok: false, message: `unexpected ${request.method} ${url.pathname}` }, 404);
  });
  await new Promise((resolve) => agentRunServer.listen(0, "127.0.0.1", resolve));
  const agentRunPort = agentRunServer.address().port;
  const traceStore = createCodeAgentTraceStore();
  const codeAgentChatResults = new Map();
  codeAgentChatResults.set(traceId, {
    traceId,
    status: "running",
    conversationId: "cnv_cancel_terminal_result_authority",
    sessionId: "ses_cancel_terminal_result_authority",
    threadId: "thread-cancel-terminal-result-authority",
    agentRun: {
      adapter: "agentrun-v01",
      managerUrl: `http://127.0.0.1:${agentRunPort}`,
      runId,
      commandId,
      traceId,
      providerTrace: { traceId, runId, commandId, valuesPrinted: false },
      lastSeq: 6,
      status: "running",
      commandState: "running",
      valuesPrinted: false
    },
    valuesRedacted: true
  });
  const server = createCloudApiServer({
    traceStore,
    codeAgentChatResults,
    env: {
      PATH: process.env.PATH,
      HWLAB_CODE_AGENT_ADAPTER: "agentrun-v01",
      HWLAB_CODE_AGENT_PROVIDER: "agentrun-v01",
      HWLAB_CODE_AGENT_AGENTRUN_ALLOW_NON_K3S_URL: "1"
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat/cancel`, {
      method: "POST",
      headers: { "content-type": "application/json", "x-trace-id": traceId },
      body: JSON.stringify({ traceId, conversationId: "cnv_cancel_terminal_result_authority", sessionId: "ses_cancel_terminal_result_authority", threadId: "thread-cancel-terminal-result-authority" })
    });
    assert.equal(response.status, 200);
    const payload = await response.json();
    assert.equal(payload.status, "completed");
    assert.equal(payload.cancelDisposition.status, "already_terminal");
    assert.equal(payload.cancelDisposition.forwarded, false);
    assert.equal(payload.finalResponse.text, finalText);
    assert.equal(calls.some((call) => call.method === "POST" && call.path === `/api/v1/commands/${commandId}/cancel`), false);
    assert.equal(codeAgentChatResults.get(traceId)?.status, "completed");
  } finally {
    await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
    await new Promise((resolve, reject) => agentRunServer.close((error) => (error ? reject(error) : resolve())));
  }
});

test("cloud api /v1/agent/chat reports Codex stdio blocker instead of structured skills fallback", async () => {
  const root = await mkdtemp(path.join(os.tmpdir(), "hwlab-agent-no-skills-"));
  const skillsDir = path.join(root, "missing-skills");
  const server = createCloudApiServer({
    env: {
      PATH: process.env.PATH,
      HWLAB_CODE_AGENT_WORKSPACE: root
    },
    skillsDirs: [skillsDir],
    skillsDirsExact: true
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const manualSession = await createManualAgentSession(port, {
      conversationId: "cnv_server-test-skills-missing"
    });
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        cookie: manualSession.cookie
      },
      body: JSON.stringify({
        conversationId: manualSession.conversationId,
        sessionId: manualSession.sessionId,
        message: "列出你可用的skills"
      })
    });
    assert.equal(response.status, 200);
    const payload = await response.json();
    assert.equal(payload.status, "failed");
    assert.equal(payload.provider, "codex-stdio");
    assert.notEqual(payload.error.code, "skills_unavailable");
    assert.equal(payload.capabilityLevel, "blocked");
    assert.equal(payload.skills.status, "not_requested");
    assert.deepEqual(payload.toolCalls, []);
    assert.ok(payload.runnerLimitations.includes("no-controlled-readonly-fallback"));
    assert.equal(Object.hasOwn(payload, "reply"), false);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api /v1/agent/chat does not run unsupported local grep fallback", async () => {
  const workspace = await mkdtemp(path.join(os.tmpdir(), "hwlab-agent-tool-blocked-"));
  const server = createCloudApiServer({
    env: {
      PATH: process.env.PATH,
      HWLAB_CODE_AGENT_WORKSPACE: workspace
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const manualSession = await createManualAgentSession(port, {
      conversationId: "cnv_server-test-tool-unavailable"
    });
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        cookie: manualSession.cookie
      },
      body: JSON.stringify({
        conversationId: manualSession.conversationId,
        sessionId: manualSession.sessionId,
        message: "请用grep搜索 package.json"
      })
    });
    assert.equal(response.status, 200);
    const payload = await response.json();
    assert.equal(payload.status, "failed");
    assert.notEqual(payload.error.code, "tool_unavailable");
    assert.equal(payload.provider, "codex-stdio");
    assert.equal(payload.capabilityLevel, "blocked");
    assert.deepEqual(payload.toolCalls, []);
    assert.ok(payload.runnerLimitations.includes("no-controlled-readonly-fallback"));
    assert.equal(Object.hasOwn(payload, "reply"), false);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api /v1/agent/chat does not call delayed provider fallback beyond legacy 4500ms UI timeout", async () => {
  let providerCalled = false;
  const server = createCloudApiServer({
    callCodeAgentProvider: async ({ providerPlan, message, traceId }) => {
      providerCalled = true;
      await delay(4700);
      return {
        provider: providerPlan.provider,
        model: providerPlan.model,
        backend: providerPlan.backend,
        content: `延迟真实 provider stub: ${message} / ${traceId}`,
        usage: null,
        providerTrace: {
          source: "delayed-test-provider"
        }
      };
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const manualSession = await createManualAgentSession(port, {
      conversationId: "cnv_server-test-agent-chat-delayed"
    });
    const startedAt = Date.now();
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        cookie: manualSession.cookie,
        "x-trace-id": "trc_server-test-agent-chat-delayed"
      },
      body: JSON.stringify({
        conversationId: manualSession.conversationId,
        sessionId: manualSession.sessionId,
        message: "请用一句话说明当前 HWLAB 工作台可以做什么，稍后回答"
      })
    });
    assert.equal(response.status, 200);
    const payload = await response.json();
    assert.equal(Date.now() - startedAt < 4500, true);
    assert.equal(payload.status, "failed");
    assert.equal(payload.conversationId, "cnv_server-test-agent-chat-delayed");
    assert.equal(payload.traceId, "trc_server-test-agent-chat-delayed");
    assert.equal(payload.provider, "codex-stdio");
    assert.equal(payload.capabilityLevel, "blocked");
    assert.equal(providerCalled, false);
    assert.equal(Object.hasOwn(payload, "reply"), false);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
  }
});

test("cloud api /v1/agent/chat does not call OpenAI provider 502/503 fallback", async () => {
  for (const status of [502, 503]) {
    const providerServer = createHttpServer((request, response) => {
      request.resume();
      response.writeHead(status, { "content-type": "application/json" });
      response.end(JSON.stringify({
        error: {
          message: `upstream ${status}`
        }
      }));
    });
    await new Promise((resolve) => providerServer.listen(0, "127.0.0.1", resolve));
    const providerPort = providerServer.address().port;

    const server = createCloudApiServer({
      env: {
        OPENAI_API_KEY: "test-openai-key-material",
        HWLAB_CODE_AGENT_PROVIDER: "openai",
        HWLAB_CODE_AGENT_ALLOW_TEXT_FALLBACK: "true",
        HWLAB_CODE_AGENT_MODEL: "gpt-test",
        HWLAB_CODE_AGENT_OPENAI_BASE_URL: `http://127.0.0.1:${providerPort}/v1/responses`
      }
    });
    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

    try {
      const { port } = server.address();
      const manualSession = await createManualAgentSession(port, {
        conversationId: `cnv_server-test-agent-chat-provider-${status}`
      });
      const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat`, {
        method: "POST",
        headers: {
          "content-type": "application/json",
          cookie: manualSession.cookie,
          "x-trace-id": `trc_server-test-agent-chat-provider-${status}`
        },
        body: JSON.stringify({
          conversationId: manualSession.conversationId,
          sessionId: manualSession.sessionId,
          message: `provider ${status}`
        })
      });
      assert.equal(response.status, 200);
      const payload = await response.json();
      assert.equal(payload.status, "failed");
      assert.equal(payload.traceId, `trc_server-test-agent-chat-provider-${status}`);
      assert.match(payload.error.code, /^(codex_cli_binary_missing|codex_cli_native_dependency_missing|codex_stdio_supervisor_disabled|stdio_protocol_not_wired)$/u);
      assert.match(payload.error.layer, /^(runner|api)$/u);
      assert.equal(typeof payload.error.retryable, "boolean");
      assert.equal(payload.error.blocker.traceId, `trc_server-test-agent-chat-provider-${status}`);
      assert.equal(typeof payload.error.blocker.retryable, "boolean");
      assert.equal(payload.error.blocker.capabilityLevel, "blocked");
      assert.equal(payload.provider, "codex-stdio");
      assert.equal(Object.hasOwn(payload, "reply"), false);
    } finally {
      await new Promise((resolve, reject) => {
        server.close((error) => (error ? reject(error) : resolve()));
      });
      await new Promise((resolve, reject) => {
        providerServer.close((error) => (error ? reject(error) : resolve()));
      });
    }
  }
});

test("cloud api /v1/agent/chat does not call empty provider text fallback", async () => {
  let providerCalled = false;
  const server = createCloudApiServer({
    callCodeAgentProvider: async () => {
      providerCalled = true;
      throw new Error("empty provider fallback must not be used");
    }
  });
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));

  try {
    const { port } = server.address();
    const manualSession = await createManualAgentSession(port, {
      conversationId: "cnv_empty-provider-text"
    });
    const response = await fetch(`http://127.0.0.1:${port}/v1/agent/chat`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        cookie: manualSession.cookie
      },
      body: JSON.stringify({
        conversationId: manualSession.conversationId,
        sessionId: manualSession.sessionId,
        message: "你好"
      })
    });
    assert.equal(response.status, 200);
    const payload = await response.json();
    assert.equal(payload.conversationId, "cnv_empty-provider-text");
    assert.equal(payload.status, "failed");
    assert.match(payload.error.code, /^(codex_cli_binary_missing|stdio_protocol_not_wired)$/u);
    assert.equal(payload.provider, "codex-stdio");
    assert.equal(Object.hasOwn(payload, "reply"), false);
    assert.equal(providerCalled, false);
  } finally {
    await new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    });
  }
});