[Init] Initial commit - NetMesh terminal manager

electron/bridges/aiBridge/codexAppServer/runtime.test.cjs

@@ -0,0 +1,850 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const {
+  CodexAppServerRuntime,
+  buildTurnInput,
+  mapAppServerModels,
+  normalizeFileChanges,
+  resolveCodexPermissionConfig,
+} = require("./runtime.cjs");
+
+class FakeConnection {
+  constructor(options) {
+    this.options = options;
+    this.requests = [];
+    this.responses = [];
+    this.threadId = "thread-1";
+    this.turnId = "turn-1";
+    this.closed = false;
+  }
+  async start() { return this; }
+  async request(method, params) {
+    this.requests.push({ method, params });
+    if (method === "thread/start" || method === "thread/resume") {
+      return { thread: { id: this.threadId } };
+    }
+    if (method === "turn/start") {
+      if (this.turnStartGate) await this.turnStartGate;
+      return { turn: { id: this.turnId } };
+    }
+    if (method === "turn/steer") {
+      if (this.turnSteerGate) await this.turnSteerGate;
+      if (this.turnSteerError) throw this.turnSteerError;
+      return { turnId: this.turnId };
+    }
+    if (method === "turn/interrupt") {
+      if (this.turnInterruptGate) await this.turnInterruptGate;
+      if (this.turnInterruptError) throw this.turnInterruptError;
+      return {};
+    }
+    if (method === "model/list") {
+      return {
+        data: [
+          {
+            id: "gpt-first",
+            displayName: "GPT First",
+            description: "First model in the catalog",
+            hidden: false,
+            supportedReasoningEfforts: [{ reasoningEffort: "low" }],
+            defaultReasoningEffort: "low",
+            isDefault: false,
+          },
+          {
+            id: "gpt-test",
+            displayName: "GPT Test",
+            description: "Server default model",
+            hidden: false,
+            supportedReasoningEfforts: [{ reasoningEffort: "low" }, { reasoningEffort: "high" }],
+            defaultReasoningEffort: "high",
+            isDefault: true,
+          },
+        ],
+        nextCursor: null,
+      };
+    }
+    return {};
+  }
+  respond(id, result) { this.responses.push({ id, result }); }
+  respondError(id, code, message) { this.responses.push({ id, error: { code, message } }); }
+  notify(message) { this.options.onNotification(message); }
+  serverRequest(message) { return this.options.onServerRequest(message, this); }
+  close() { this.closed = true; }
+}
+
+function createEmitter() {
+  const events = [];
+  return {
+    events,
+    emitDone: () => events.push(["done"]),
+    sessionId: (id) => events.push(["session", id]),
+    text: (text) => events.push(["text", text]),
+    reasoning: (text) => events.push(["reasoning", text]),
+    reasoningEnd: () => events.push(["reasoning-end"]),
+    toolCall: (name, args, id) => events.push(["tool-call", name, args, id]),
+    toolResult: (id, output, name) => events.push(["tool-result", id, output, name]),
+    fileChange: (id, changes, status) => events.push(["file-change", id, changes, status]),
+    webSearch: (id, query, status) => events.push(["web-search", id, query, status]),
+    planUpdate: (id, items, status) => events.push(["plan", id, items, status]),
+    warning: (id, message) => events.push(["warning", id, message]),
+    usage: (usage) => events.push(["usage", usage]),
+  };
+}
+
+async function waitFor(predicate) {
+  for (let index = 0; index < 50; index += 1) {
+    if (predicate()) return;
+    await new Promise((resolve) => setImmediate(resolve));
+  }
+  throw new Error("condition not reached");
+}
+
+test("permission modes map to fail-closed Codex policies", () => {
+  assert.deepEqual(resolveCodexPermissionConfig("observer"), {
+    approvalPolicy: "never",
+    approvalsReviewer: "user",
+    sandbox: "read-only",
+    sandboxPolicy: { type: "readOnly", networkAccess: false },
+  });
+  assert.equal(resolveCodexPermissionConfig("confirm").approvalPolicy, "on-request");
+  assert.equal(resolveCodexPermissionConfig("confirm").sandbox, "read-only");
+  assert.equal(resolveCodexPermissionConfig("auto").sandbox, "danger-full-access");
+});
+
+test("turn input uses text plus local images only", () => {
+  assert.deepEqual(buildTurnInput("hello", [
+    { filePath: "/tmp/a.png", mediaType: "image/png" },
+    { filePath: "/tmp/a.txt", mediaType: "text/plain" },
+  ]), [
+    { type: "text", text: "hello", text_elements: [] },
+    { type: "localImage", path: "/tmp/a.png" },
+  ]);
+});
+
+test("runtime maps lifecycle, activities, usage, and retry warnings", async () => {
+  let connection;
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => (connection = new FakeConnection(options)),
+  });
+  const emitter = createEmitter();
+  const run = runtime.runTurn({
+    requestId: "request-1",
+    chatSessionId: "chat-1",
+    prompt: "hello",
+    cwd: "/repo",
+    model: "gpt-test/high",
+    permissionMode: "confirm",
+    env: { HOME: "/home" },
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter,
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+  connection.notify({ method: "item/agentMessage/delta", params: { threadId: "thread-1", turnId: "turn-1", itemId: "msg-1", delta: "Hi" } });
+  connection.notify({ method: "turn/plan/updated", params: { threadId: "thread-1", turnId: "turn-1", plan: [{ step: "Inspect", status: "completed" }] } });
+  connection.notify({ method: "item/started", params: { threadId: "thread-1", turnId: "turn-1", item: { type: "webSearch", id: "search-1", query: "Netcatty" } } });
+  connection.notify({ method: "item/completed", params: { threadId: "thread-1", turnId: "turn-1", item: { type: "fileChange", id: "file-1", status: "completed", changes: [{ path: "a.ts", kind: { type: "add" } }] } } });
+  connection.notify({ method: "thread/tokenUsage/updated", params: { threadId: "thread-1", turnId: "turn-1", tokenUsage: { last: { inputTokens: 10, cachedInputTokens: 2, outputTokens: 3, reasoningOutputTokens: 1, totalTokens: 13 } } } });
+  connection.notify({ method: "error", params: { threadId: "thread-1", turnId: "turn-1", willRetry: true, error: { message: "network" } } });
+  connection.notify({ method: "warning", params: { message: "global warning" } });
+  connection.notify({ method: "turn/completed", params: { threadId: "thread-1", turn: { id: "turn-1", status: "completed", error: null } } });
+  await run;
+
+  assert.ok(emitter.events.some((event) => event[0] === "text" && event[1] === "Hi"));
+  assert.ok(emitter.events.some((event) => event[0] === "plan"));
+  assert.ok(emitter.events.some((event) => event[0] === "web-search" && event[3] === "running"));
+  assert.ok(emitter.events.some((event) => event[0] === "file-change" && event[3] === "completed"));
+  assert.ok(emitter.events.some((event) => event[0] === "usage" && event[1].cachedInputTokens === 2));
+  assert.ok(emitter.events.some((event) => event[0] === "warning" && /retrying/.test(event[2])));
+  assert.ok(emitter.events.some((event) => event[0] === "warning" && event[2] === "global warning"));
+  assert.ok(emitter.events.some((event) => event[0] === "done"));
+});
+
+test("runtime bounds command output and avoids replaying streamed message prefixes", async () => {
+  let connection;
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => (connection = new FakeConnection(options)),
+  });
+  const emitter = createEmitter();
+  const run = runtime.runTurn({
+    requestId: "request-bounded-output",
+    chatSessionId: "chat-bounded-output",
+    prompt: "run",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter,
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+  connection.notify({ method: "item/agentMessage/delta", params: {
+    threadId: "thread-1", turnId: "turn-1", itemId: "msg-bounded", delta: "Hello",
+  } });
+  connection.notify({ method: "item/completed", params: {
+    threadId: "thread-1", turnId: "turn-1",
+    item: { type: "agentMessage", id: "msg-bounded", text: "Hello world" },
+  } });
+  connection.notify({ method: "item/commandExecution/outputDelta", params: {
+    threadId: "thread-1", turnId: "turn-1", itemId: "cmd-bounded",
+    delta: "x".repeat(1024 * 1024 + 1024),
+  } });
+  connection.notify({ method: "item/completed", params: {
+    threadId: "thread-1", turnId: "turn-1",
+    item: { type: "commandExecution", id: "cmd-bounded", command: "large", exitCode: 0 },
+  } });
+  connection.notify({ method: "turn/completed", params: {
+    threadId: "thread-1", turn: { id: "turn-1", status: "completed", error: null },
+  } });
+  await run;
+
+  assert.deepEqual(
+    emitter.events.filter((event) => event[0] === "text"),
+    [["text", "Hello"], ["text", " world"]],
+  );
+  const toolResult = emitter.events.find((event) => event[0] === "tool-result");
+  assert.ok(toolResult);
+  assert.ok(toolResult[2].length < 1024 * 1024 + 200);
+  assert.match(toolResult[2], /output truncated: 1049600 characters total/);
+  assert.match(toolResult[2], /\[exit code: 0\]$/);
+});
+
+test("runtime delegates injected MCP approvals to Netcatty's policy gate", async () => {
+  let connection;
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => (connection = new FakeConnection(options)),
+  });
+  const run = runtime.runTurn({
+    requestId: "request-mcp-policy",
+    chatSessionId: "chat-mcp-policy",
+    prompt: "inspect the terminal",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [{
+      name: "netcatty-remote-hosts",
+      command: "/abs/electron",
+      args: ["/abs/server.cjs"],
+      env: [{ name: "NETCATTY_MCP_PERMISSION_MODE", value: "confirm" }],
+    }],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+  const threadStart = connection.requests.find((request) => request.method === "thread/start");
+  assert.deepEqual(threadStart.params.config.mcp_servers["netcatty-remote-hosts"], {
+    command: "/abs/electron",
+    args: ["/abs/server.cjs"],
+    env: { NETCATTY_MCP_PERMISSION_MODE: "confirm" },
+    default_tools_approval_mode: "approve",
+  });
+
+  connection.notify({
+    method: "turn/completed",
+    params: { threadId: "thread-1", turn: { id: "turn-1", status: "completed", error: null } },
+  });
+  await run;
+});
+
+test("runtime routes native approvals and request_user_input responses", async () => {
+  let connection;
+  let interaction;
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => (connection = new FakeConnection(options)),
+    sendInteractionRequest: (payload) => { interaction = payload; return true; },
+  });
+  const run = runtime.runTurn({
+    requestId: "request-2",
+    chatSessionId: "chat-2",
+    prompt: "change it",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+  await connection.serverRequest({
+    id: 70,
+    method: "item/commandExecution/requestApproval",
+    params: {
+      threadId: "thread-1",
+      turnId: "turn-1",
+      itemId: "cmd-1",
+      command: "npm test",
+      cwd: "/repo",
+      availableDecisions: ["accept", "acceptForSession", "decline", "cancel"],
+    },
+  });
+  assert.equal(interaction.kind, "command");
+  assert.deepEqual(interaction.availableDecisions, ["accept", "acceptForSession", "decline", "cancel"]);
+  runtime.respondInteraction(interaction.interactionId, { decision: "session" });
+  assert.deepEqual(connection.responses.at(-1), { id: 70, result: { decision: "acceptForSession" } });
+
+  await connection.serverRequest({
+    id: 72,
+    method: "item/permissions/requestApproval",
+    params: {
+      threadId: "thread-1",
+      turnId: "turn-1",
+      itemId: "permissions-1",
+      permissions: { network: { enabled: true }, fileSystem: null },
+      cwd: "/repo",
+    },
+  });
+  runtime.respondInteraction(interaction.interactionId, { decision: "once" });
+  assert.deepEqual(connection.responses.at(-1), {
+    id: 72,
+    result: { permissions: { network: { enabled: true } }, scope: "turn" },
+  });
+
+  await connection.serverRequest({
+    id: 71,
+    method: "item/tool/requestUserInput",
+    params: { threadId: "thread-1", turnId: "turn-1", itemId: "question-1", questions: [{ id: "choice", question: "Choose", header: "Mode", isOther: true, isSecret: false, options: null }] },
+  });
+  runtime.respondInteraction(interaction.interactionId, { answers: { choice: { answers: ["safe"] } } });
+  assert.deepEqual(connection.responses.at(-1), { id: 71, result: { answers: { choice: { answers: ["safe"] } } } });
+
+  connection.notify({ method: "turn/completed", params: { threadId: "thread-1", turn: { id: "turn-1", status: "completed", error: null } } });
+  await run;
+});
+
+test("cancelInteractionTimeout re-arms the absolute approval deadline (Catty/MCP style)", async () => {
+  let connection;
+  let interaction;
+  const realNow = Date.now;
+  let now = 5_000_000;
+  Date.now = () => now;
+
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => (connection = new FakeConnection(options)),
+    sendInteractionRequest: (payload) => { interaction = payload; return true; },
+  });
+  try {
+    const run = runtime.runTurn({
+      requestId: "request-timeout-cancel",
+      chatSessionId: "chat-timeout-cancel",
+      prompt: "ask",
+      permissionMode: "confirm",
+      env: {},
+      binPath: "/bin/codex",
+      injectedMcpServers: [],
+      emitter: createEmitter(),
+    });
+    await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+    await connection.serverRequest({
+      id: 90,
+      method: "item/tool/requestUserInput",
+      params: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        itemId: "question-timeout",
+        questions: [{ id: "choice", question: "Choose", header: "Mode", isOther: true, isSecret: false, options: null }],
+        autoResolutionMs: 100,
+      },
+    });
+    assert.ok(interaction?.interactionId);
+
+    // Jump close to the absolute ceiling, then cancel idle. Remaining absolute ~30ms.
+    now += 70;
+    assert.equal(runtime.cancelInteractionTimeout(interaction.interactionId), true);
+    assert.equal(runtime.cancelInteractionTimeout(interaction.interactionId), false);
+
+    await new Promise((resolve) => setTimeout(resolve, 15));
+    assert.equal(
+      connection.responses.some((response) => response.id === 90),
+      false,
+      "must stay pending before absolute expiry",
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 80));
+    assert.equal(
+      connection.responses.some((response) => response.id === 90),
+      true,
+      "absolute deadline must auto-reject after remaining time elapses",
+    );
+    assert.deepEqual(connection.responses.at(-1), {
+      id: 90,
+      result: { answers: {} },
+    });
+
+    connection.notify({ method: "turn/completed", params: { threadId: "thread-1", turn: { id: "turn-1", status: "completed", error: null } } });
+    await run;
+  } finally {
+    Date.now = realNow;
+  }
+});
+
+test("cancelInteractionTimeout still allows explicit approve before absolute expiry", async () => {
+  let connection;
+  let interaction;
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => (connection = new FakeConnection(options)),
+    sendInteractionRequest: (payload) => { interaction = payload; return true; },
+  });
+  const run = runtime.runTurn({
+    requestId: "request-timeout-approve",
+    chatSessionId: "chat-timeout-approve",
+    prompt: "ask",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+  await connection.serverRequest({
+    id: 91,
+    method: "item/commandExecution/requestApproval",
+    params: {
+      threadId: "thread-1",
+      turnId: "turn-1",
+      itemId: "cmd-approve",
+      command: "echo ok",
+      cwd: "/tmp",
+      reason: "demo",
+    },
+  });
+  assert.ok(interaction?.interactionId);
+  assert.equal(runtime.cancelInteractionTimeout(interaction.interactionId), true);
+  assert.equal(runtime.respondInteraction(interaction.interactionId, { decision: "once" }), true);
+  assert.deepEqual(connection.responses.at(-1), {
+    id: 91,
+    result: { decision: "accept" },
+  });
+
+  connection.notify({ method: "turn/completed", params: { threadId: "thread-1", turn: { id: "turn-1", status: "completed", error: null } } });
+  await run;
+});
+
+test("runtime steers the active turn with text, local images, and a stable user message id", async () => {
+  let connection;
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => (connection = new FakeConnection(options)),
+  });
+  const run = runtime.runTurn({
+    requestId: "request-steer",
+    chatSessionId: "chat-steer",
+    prompt: "initial",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+  const result = await runtime.steerTurn("request-steer", {
+    chatSessionId: "chat-steer",
+    prompt: "use this image",
+    attachments: [
+      { filePath: "/tmp/image.png", mediaType: "image/png" },
+      { filePath: "/tmp/notes.txt", mediaType: "text/plain" },
+    ],
+    clientUserMessageId: "user-steer-1",
+  });
+
+  assert.deepEqual(result, { status: "accepted" });
+  assert.deepEqual(connection.requests.find((request) => request.method === "turn/steer"), {
+    method: "turn/steer",
+    params: {
+      threadId: "thread-1",
+      expectedTurnId: "turn-1",
+      input: [
+        { type: "text", text: "use this image", text_elements: [] },
+        { type: "localImage", path: "/tmp/image.png" },
+      ],
+      clientUserMessageId: "user-steer-1",
+    },
+  });
+
+  connection.notify({ method: "turn/completed", params: { threadId: "thread-1", turn: { id: "turn-1", status: "completed", error: null } } });
+  await run;
+});
+
+test("runtime serializes steering and classifies non-steerable turns", async () => {
+  let connection;
+  let releaseSteer;
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => {
+      connection = new FakeConnection(options);
+      connection.turnSteerGate = new Promise((resolve) => { releaseSteer = resolve; });
+      return connection;
+    },
+  });
+  const run = runtime.runTurn({
+    requestId: "request-steer-busy",
+    chatSessionId: "chat-steer-busy",
+    prompt: "initial",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+  const first = runtime.steerTurn("request-steer-busy", {
+    chatSessionId: "chat-steer-busy",
+    prompt: "first",
+    clientUserMessageId: "user-first",
+  });
+  await waitFor(() => connection.requests.some((request) => request.method === "turn/steer"));
+  assert.equal((await runtime.steerTurn("request-steer-busy", {
+    chatSessionId: "chat-steer-busy",
+    prompt: "second",
+    clientUserMessageId: "user-second",
+  })).status, "busy");
+  releaseSteer();
+  assert.equal((await first).status, "accepted");
+
+  const error = new Error("active turn cannot be steered");
+  error.data = { activeTurnNotSteerable: { turnKind: "review" } };
+  connection.turnSteerError = error;
+  const rejected = await runtime.steerTurn("request-steer-busy", {
+    chatSessionId: "chat-steer-busy",
+    prompt: "review change",
+    clientUserMessageId: "user-review",
+  });
+  assert.deepEqual(rejected, {
+    status: "not-steerable",
+    turnKind: "review",
+    message: "active turn cannot be steered",
+  });
+
+  connection.notify({ method: "turn/completed", params: { threadId: "thread-1", turn: { id: "turn-1", status: "completed", error: null } } });
+  await run;
+});
+
+test("stop during steering cancels the UI result without creating a replacement turn", async () => {
+  let connection;
+  let releaseSteer;
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => {
+      connection = new FakeConnection(options);
+      connection.turnSteerGate = new Promise((resolve) => { releaseSteer = resolve; });
+      return connection;
+    },
+  });
+  const run = runtime.runTurn({
+    requestId: "request-steer-stop",
+    chatSessionId: "chat-steer-stop",
+    prompt: "initial",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+  const steer = runtime.steerTurn("request-steer-stop", {
+    chatSessionId: "chat-steer-stop",
+    prompt: "too late",
+    clientUserMessageId: "user-steer-stop",
+  });
+  await waitFor(() => connection.requests.some((request) => request.method === "turn/steer"));
+  assert.equal(await runtime.cancelTurn("request-steer-stop"), true);
+  releaseSteer();
+  assert.equal((await steer).status, "cancelled");
+  assert.equal(connection.requests.filter((request) => request.method === "turn/start").length, 1);
+
+  connection.notify({ method: "turn/completed", params: { threadId: "thread-1", turn: { id: "turn-1", status: "interrupted", error: null } } });
+  await run;
+});
+
+test("stop requested while turn/start is pending interrupts the assigned turn", async () => {
+  let connection;
+  let releaseTurnStart;
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => {
+      connection = new FakeConnection(options);
+      connection.turnStartGate = new Promise((resolve) => { releaseTurnStart = resolve; });
+      return connection;
+    },
+  });
+  const emitter = createEmitter();
+  const run = runtime.runTurn({
+    requestId: "request-stop",
+    chatSessionId: "chat-stop",
+    prompt: "wait",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter,
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+  assert.equal(await runtime.cancelTurn("request-stop"), true);
+  assert.equal(connection.requests.some((request) => request.method === "turn/interrupt"), false);
+
+  releaseTurnStart();
+  await waitFor(() => connection.requests.some((request) => request.method === "turn/interrupt"));
+  connection.notify({
+    method: "turn/completed",
+    params: { threadId: "thread-1", turn: { id: "turn-1", status: "interrupted", error: null } },
+  });
+  await run;
+  assert.equal(connection.requests.filter((request) => request.method === "turn/interrupt").length, 1);
+  assert.ok(emitter.events.some((event) => event[0] === "done"));
+});
+
+test("failed interrupt force-settles the turn and releases its connection", async () => {
+  let connection;
+  const runtime = new CodexAppServerRuntime({
+    interruptGraceMs: 5,
+    connectionFactory: (options) => {
+      connection = new FakeConnection(options);
+      connection.turnInterruptError = new Error("interrupt unavailable");
+      return connection;
+    },
+  });
+  const run = runtime.runTurn({
+    requestId: "request-interrupt-failure",
+    chatSessionId: "chat-interrupt-failure",
+    prompt: "wait",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+  assert.equal(await runtime.cancelTurn("request-interrupt-failure"), true);
+  await Promise.race([
+    run,
+    new Promise((_, reject) => setTimeout(() => reject(new Error("turn did not settle")), 50)),
+  ]);
+
+  assert.equal(connection.closed, true);
+  assert.equal(runtime.activeByRequest.size, 0);
+  assert.equal(runtime.activeByThread.size, 0);
+  assert.equal(runtime.activeByTurn.size, 0);
+});
+
+test("hung interrupt request times out and force-settles the turn", async () => {
+  let connection;
+  const runtime = new CodexAppServerRuntime({
+    interruptRequestTimeoutMs: 5,
+    interruptGraceMs: 5,
+    connectionFactory: (options) => {
+      connection = new FakeConnection(options);
+      connection.turnInterruptGate = new Promise(() => {});
+      return connection;
+    },
+  });
+  const run = runtime.runTurn({
+    requestId: "request-interrupt-hung",
+    chatSessionId: "chat-interrupt-hung",
+    prompt: "wait",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+  assert.equal(await runtime.cancelTurn("request-interrupt-hung"), true);
+  await Promise.race([
+    run,
+    new Promise((_, reject) => setTimeout(() => reject(new Error("turn did not settle")), 50)),
+  ]);
+
+  assert.equal(connection.closed, true);
+  assert.equal(runtime.activeByRequest.size, 0);
+});
+
+test("acknowledged interrupt force-settles when completion never arrives", async () => {
+  let connection;
+  const runtime = new CodexAppServerRuntime({
+    interruptGraceMs: 5,
+    connectionFactory: (options) => (connection = new FakeConnection(options)),
+  });
+  const run = runtime.runTurn({
+    requestId: "request-interrupt-no-completion",
+    chatSessionId: "chat-interrupt-no-completion",
+    prompt: "wait",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+
+  assert.equal(await runtime.cancelTurn("request-interrupt-no-completion"), true);
+  await Promise.race([
+    run,
+    new Promise((_, reject) => setTimeout(() => reject(new Error("turn did not settle")), 50)),
+  ]);
+
+  assert.equal(connection.closed, true);
+  assert.equal(runtime.activeByRequest.size, 0);
+});
+
+test("idle superseded app-server connections close when their active turn finishes", async () => {
+  const connections = [];
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => {
+      const connection = new FakeConnection(options);
+      connection.threadId = `thread-${connections.length + 1}`;
+      connection.turnId = `turn-${connections.length + 1}`;
+      connections.push(connection);
+      return connection;
+    },
+  });
+  const firstRun = runtime.runTurn({
+    requestId: "request-config-a",
+    chatSessionId: "chat-config-a",
+    prompt: "first",
+    permissionMode: "confirm",
+    env: { PROFILE: "a" },
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connections[0]?.requests.some((request) => request.method === "turn/start"));
+  const secondRun = runtime.runTurn({
+    requestId: "request-config-b",
+    chatSessionId: "chat-config-b",
+    prompt: "second",
+    permissionMode: "confirm",
+    env: { PROFILE: "b" },
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connections[1]?.requests.some((request) => request.method === "turn/start"));
+
+  connections[0].notify({
+    method: "turn/completed",
+    params: { threadId: "thread-1", turn: { id: "turn-1", status: "completed", error: null } },
+  });
+  await firstRun;
+  assert.equal(connections[0].closed, true);
+  assert.equal(connections[1].closed, false);
+
+  connections[1].notify({
+    method: "turn/completed",
+    params: { threadId: "thread-2", turn: { id: "turn-2", status: "completed", error: null } },
+  });
+  await secondRun;
+  assert.equal(connections[1].closed, false);
+  runtime.close();
+});
+
+test("force-cancelling the preferred connection keeps another active connection reusable", async () => {
+  const connections = [];
+  const runtime = new CodexAppServerRuntime({
+    interruptGraceMs: 5,
+    connectionFactory: (options) => {
+      const connection = new FakeConnection(options);
+      connection.threadId = `thread-reuse-${connections.length + 1}`;
+      connection.turnId = `turn-reuse-${connections.length + 1}`;
+      connections.push(connection);
+      return connection;
+    },
+  });
+  const firstRun = runtime.runTurn({
+    requestId: "request-reuse-a",
+    chatSessionId: "chat-reuse-a",
+    prompt: "first",
+    permissionMode: "confirm",
+    env: { PROFILE: "reuse-a" },
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connections[0]?.requests.some((request) => request.method === "turn/start"));
+  const secondRun = runtime.runTurn({
+    requestId: "request-reuse-b",
+    chatSessionId: "chat-reuse-b",
+    prompt: "second",
+    permissionMode: "confirm",
+    env: { PROFILE: "reuse-b" },
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter: createEmitter(),
+  });
+  await waitFor(() => connections[1]?.requests.some((request) => request.method === "turn/start"));
+
+  assert.equal(await runtime.cancelTurn("request-reuse-b"), true);
+  await secondRun;
+  connections[0].notify({
+    method: "turn/completed",
+    params: {
+      threadId: "thread-reuse-1",
+      turn: { id: "turn-reuse-1", status: "completed", error: null },
+    },
+  });
+  await firstRun;
+
+  assert.equal(connections[0].closed, false);
+  runtime.close();
+});
+
+test("unsupported requests fail immediately and warn without hanging", async () => {
+  let connection;
+  const emitter = createEmitter();
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => (connection = new FakeConnection(options)),
+  });
+  const run = runtime.runTurn({
+    requestId: "request-unsupported",
+    chatSessionId: "chat-unsupported",
+    prompt: "hello",
+    permissionMode: "confirm",
+    env: {},
+    binPath: "/bin/codex",
+    injectedMcpServers: [],
+    emitter,
+  });
+  await waitFor(() => connection?.requests.some((request) => request.method === "turn/start"));
+  await connection.serverRequest({
+    id: 99,
+    method: "item/unknown/requestApproval",
+    params: { threadId: "thread-1", turnId: "turn-1" },
+  });
+  assert.deepEqual(connection.responses.at(-1), {
+    id: 99,
+    error: { code: -32601, message: "Unsupported Codex App Server request: item/unknown/requestApproval" },
+  });
+  assert.ok(emitter.events.some((event) => event[0] === "warning"));
+  await connection.serverRequest({
+    id: 100,
+    method: "item/commandExecution/requestApproval",
+    params: { threadId: "thread-1", turnId: "turn-1", itemId: "cmd-no-renderer", command: "rm -rf /" },
+  });
+  assert.deepEqual(connection.responses.at(-1), { id: 100, result: { decision: "decline" } });
+  connection.notify({ method: "turn/completed", params: { threadId: "thread-1", turn: { id: "turn-1", status: "completed", error: null } } });
+  await run;
+});
+
+test("model and file-change normalization preserve UI contract", async () => {
+  assert.deepEqual(normalizeFileChanges([
+    { path: "a", kind: { type: "add" } },
+    { path: "b", kind: { type: "delete" } },
+    { path: "c", kind: { type: "update", move_path: null } },
+  ]), [
+    { path: "a", kind: "add" },
+    { path: "b", kind: "delete" },
+    { path: "c", kind: "update" },
+  ]);
+  assert.equal(mapAppServerModels([{ id: "hidden", hidden: true }]).length, 0);
+
+  let connection;
+  const runtime = new CodexAppServerRuntime({
+    connectionFactory: (options) => (connection = new FakeConnection(options)),
+  });
+  const catalog = await runtime.listModels({ binPath: "/bin/codex", env: {} });
+  assert.equal(connection.requests[0].method, "model/list");
+  assert.equal(catalog.currentModelId, "gpt-test/high");
+  assert.equal(catalog.models[0].id, "gpt-first");
+  assert.deepEqual(catalog.models[1].thinkingLevels, ["low", "high"]);
+  assert.equal(catalog.models[1].defaultThinkingLevel, "high");
+});