harness-mix 0.1.0

package/src/native-ui/renderer-extension/test/renderer-codex-account-state.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it, vi } from "vitest";
+import { RendererCodexAccountState } from "../src/renderer-codex-account-state.js";
+import { createRendererModelClient } from "../src/renderer-model-client.js";
+
+const account = (accountId: string, active = false) => ({
+  accountId,
+  label: accountId,
+  codexHome: `/synthetic/${accountId}`,
+  active,
+  isDefault: accountId === "default",
+});
+
+function createState(sendRequest: (method: string, params: unknown) => Promise<unknown>) {
+  const client = createRendererModelClient([{ sendRequest }]);
+  if (!client) throw new Error("Test client is unavailable");
+  return new RendererCodexAccountState(client);
+}
+
+describe("Host-scoped Codex Account state", () => {
+  it("coalesces concurrent refreshes on the same concrete client", async () => {
+    const response = Promise.withResolvers<unknown>();
+    const sendRequest = vi.fn(() => response.promise);
+    const state = createState(sendRequest);
+    const first = state.refresh();
+    const second = state.refresh();
+    expect(second).toBe(first);
+    response.resolve({ accounts: [account("default", true)] });
+    await first;
+    expect(sendRequest).toHaveBeenCalledExactlyOnceWith("codexhost/account/list", {});
+    expect(state.selection.selectedAccountId).toBe("default");
+  });
+
+  it("does not inherit another Host's Accounts or override when the remote API is absent", async () => {
+    const local = createState(async () => ({
+      accounts: [account("default", true), account("other")],
+    }));
+    const remote = createState(async () => {
+      throw new Error("Method not found");
+    });
+    await local.refresh();
+    local.overrideAccountId = "other";
+    local.switching = true;
+    await remote.refresh();
+    expect(remote.accounts).toEqual([]);
+    expect(remote.selection.selectedAccountId).toBeNull();
+    expect(remote.switching).toBe(false);
+    expect(local.selection.selectedAccountId).toBe("other");
+  });
+
+  it("preserves this Host's selection on a transient failure and drops removed overrides on success", async () => {
+    const sendRequest = vi
+      .fn()
+      .mockResolvedValueOnce({ accounts: [account("default", true), account("other")] })
+      .mockRejectedValueOnce(new Error("disconnected"))
+      .mockResolvedValueOnce({ accounts: [account("default", true)] });
+    const state = createState(sendRequest);
+    await state.refresh();
+    state.overrideAccountId = "other";
+    await state.refresh();
+    expect(state.selection.selectedAccountId).toBe("other");
+    await state.refresh();
+    expect(state.overrideAccountId).toBeNull();
+    expect(state.selection.selectedAccountId).toBe("default");
+  });
+});

package/src/native-ui/renderer-extension/test/renderer-composer-permissions.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+
+import { isNativePermissionModeControlCandidate } from "../src/renderer-composer-dom.js";
+
+function nativePermissionButton(
+  options: {
+    target?: string;
+    includeOwner?: boolean;
+    codexhost?: boolean;
+    hasMenu?: boolean;
+  } = {},
+): Element {
+  const target = options.target ?? "permissions";
+  const attributes = new Map<string, string>([
+    ["data-composer-navigation-target", target],
+    ["aria-haspopup", options.hasMenu === false ? "dialog" : "menu"],
+  ]);
+  if (options.codexhost) attributes.set("data-codexhost-permission-mode-control", "composer-1");
+  const owner =
+    options.includeOwner === false
+      ? null
+      : {
+          memoizedProps: {
+            showPermissionsModeDropdown: true,
+            permissionsHostId: "local",
+            permissionsCwdOverride: null,
+          },
+          return: null,
+        };
+  const fiber = {
+    memoizedProps: {
+      "data-composer-navigation-target": target,
+      "aria-haspopup": options.hasMenu === false ? "dialog" : "menu",
+    },
+    return: owner,
+  };
+  const element = {
+    hasAttribute(name: string) {
+      return attributes.has(name);
+    },
+    matches(selector: string) {
+      return (
+        selector.includes('button[aria-haspopup="menu"]') &&
+        attributes.get("aria-haspopup") === "menu" &&
+        attributes.get("data-composer-navigation-target") === "permissions"
+      );
+    },
+  };
+  Object.defineProperty(element, "__reactFiber$test", { value: fiber });
+  return element as unknown as Element;
+}
+
+describe("versioned native Permission Mode control ownership", () => {
+  it("accepts the reviewed semantic trigger and Composer ownership chain", () => {
+    expect(isNativePermissionModeControlCandidate(nativePermissionButton())).toBe(true);
+  });
+
+  it("does not identify by visible label or a partial DOM match", () => {
+    expect(
+      isNativePermissionModeControlCandidate(nativePermissionButton({ includeOwner: false })),
+    ).toBe(false);
+    expect(
+      isNativePermissionModeControlCandidate(nativePermissionButton({ target: "model" })),
+    ).toBe(false);
+    expect(isNativePermissionModeControlCandidate(nativePermissionButton({ hasMenu: false }))).toBe(
+      false,
+    );
+  });
+
+  it("never recaptures the codexhost replacement control", () => {
+    expect(
+      isNativePermissionModeControlCandidate(nativePermissionButton({ codexhost: true })),
+    ).toBe(false);
+  });
+});

package/src/native-ui/renderer-extension/test/renderer-credits-control.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  creditsPeriodLabel,
+  formatRendererCreditsReset,
+  rendererCreditsTone,
+} from "../src/renderer-credits-control.js";
+import { formatRendererCreditsPercent } from "../src/renderer-usage-control.js";
+
+describe("Renderer credits control", () => {
+  it("maps used percent into a status tone", () => {
+    expect(rendererCreditsTone(0)).toBe("ok");
+    expect(rendererCreditsTone(52)).toBe("ok");
+    expect(rendererCreditsTone(70)).toBe("warn");
+    expect(rendererCreditsTone(89.9)).toBe("warn");
+    expect(rendererCreditsTone(90)).toBe("hot");
+  });
+
+  it("formats the compact percent and period label", () => {
+    expect(formatRendererCreditsPercent(47)).toBe("47%");
+    expect(creditsPeriodLabel("weekly")).toBe("Weekly limit");
+    expect(creditsPeriodLabel("monthly")).toBe("Monthly limit");
+    expect(creditsPeriodLabel("five_hour")).toBe("5-hour limit");
+    expect(creditsPeriodLabel("seven_day")).toBe("7-day limit");
+    expect(creditsPeriodLabel("unknown")).toBe("Account limit");
+    expect(creditsPeriodLabel("weekly", "zh-CN")).toBe("周额度");
+    expect(creditsPeriodLabel("monthly", "zh-CN")).toBe("月额度");
+    expect(creditsPeriodLabel("five_hour", "zh-CN")).toBe("5 小时额度");
+    expect(creditsPeriodLabel("seven_day", "zh-CN")).toBe("7 天额度");
+    expect(creditsPeriodLabel("unknown", "zh-CN")).toBe("账号额度");
+    expect(formatRendererCreditsReset("not-a-date")).toBe("not-a-date");
+  });
+
+  it("formats a same-day reset as a precise time and every other reset as a dated time", () => {
+    // Built with the local Date constructor throughout (never a bare UTC ISO string against a
+    // separately-computed "now") so the "same calendar day" check holds regardless of the
+    // machine's own timezone.
+    const now = new Date(2026, 7, 25, 12, 0, 0);
+    const sameDayReset = new Date(2026, 7, 25, 16, 12, 0);
+    const nextWeekReset = new Date(2026, 8, 5, 18, 0, 0);
+
+    expect(formatRendererCreditsReset(sameDayReset.toISOString(), now)).toBe(
+      `${sameDayReset.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" })} today`,
+    );
+    expect(formatRendererCreditsReset(sameDayReset.toISOString(), now, "zh-CN")).toBe(
+      `今天 ${sameDayReset.toLocaleTimeString("zh-CN", { hour: "numeric", minute: "2-digit" })}`,
+    );
+    expect(formatRendererCreditsReset(nextWeekReset.toISOString(), now)).toBe(
+      nextWeekReset.toLocaleString(undefined, {
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+      }),
+    );
+  });
+
+  it("keeps the time when a near-term reset has crossed local midnight", () => {
+    const now = new Date(2026, 7, 25, 23, 0, 0);
+    const justAfterMidnight = new Date(2026, 7, 26, 0, 10, 0);
+    expect(formatRendererCreditsReset(justAfterMidnight.toISOString(), now)).toBe(
+      justAfterMidnight.toLocaleString(undefined, {
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+      }),
+    );
+  });
+});

package/src/native-ui/renderer-extension/test/renderer-external-steering-rpc.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { installRendererExternalSteering } from "../src/renderer-external-steering.js";
+
+// Desktop exports its Manager as a RpcTarget. Its RPC resolver refuses own
+// properties, even when their values are functions. Ordinary object mocks miss this.
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class -- Desktop uses an empty RpcTarget marker base.
+class RpcTarget {}
+class Manager extends RpcTarget {
+  readonly #identity = "local";
+  readonly requests = vi.fn(async (method: unknown) => {
+    if (method === "codexhost/thread/ownership/list") {
+      return {
+        threads: [
+          {
+            threadId: "thread",
+            owner: this.owner,
+            ...(this.owner === "external" ? { harnessId: "pi" } : {}),
+          },
+        ],
+      };
+    }
+    if (method === "turn/steer") return { turnId: "replacement" };
+    return { data: ["available"] };
+  });
+  readonly presented: unknown[] = [];
+  readonly onMessageAdded = vi.fn(async () => undefined);
+  owner: "codex" | "external" = "external";
+
+  sendRequest(method: unknown, params?: unknown, options?: unknown): Promise<unknown> {
+    // Preserve the real receiver, including private fields, through the wrapper.
+    if (this.#identity !== "local") throw new Error("Invalid receiver");
+    void params;
+    void options;
+    return this.requests(method);
+  }
+  steerTurn(...args: unknown[]): unknown {
+    void args;
+    return { turnId: "official" };
+  }
+  async startTurn(_threadId: unknown, operation: unknown, onAdded: unknown): Promise<unknown> {
+    void _threadId;
+    const request = (operation as { request: unknown }).request;
+    this.presented.push(request);
+    if (typeof onAdded === "function") await onAdded();
+    return this.sendRequest("turn/start", request);
+  }
+  getTurnCoordinator(): unknown {
+    return {
+      loadMessages: async () => undefined,
+      readMessages: () => [],
+      mutate: () => undefined,
+      options: {
+        submissionHost: {
+          getActiveTurnId: () => "old",
+          hasPendingTurnStart: () => false,
+        },
+      },
+    };
+  }
+}
+
+async function callRpc(
+  manager: Manager,
+  method: "sendRequest" | "steerTurn",
+  ...args: unknown[]
+): Promise<unknown> {
+  if (Object.hasOwn(manager, method)) {
+    throw new TypeError(`Cannot access instance property '${method}' of RpcTarget`);
+  }
+  const exported = manager[method] as (...args: unknown[]) => unknown;
+  return exported.apply(manager, args);
+}
+
+function install(manager: Manager): () => void {
+  const dispose = installRendererExternalSteering(manager);
+  if (!dispose) throw new Error("Steering binding unavailable");
+  return dispose;
+}
+
+function steerArgs(manager: Manager): unknown[] {
+  return [
+    "thread",
+    [{ type: "text", text: "replacement input" }],
+    { id: "message", context: {} },
+    null,
+    [],
+    "message",
+    null,
+    null,
+    manager.onMessageAdded,
+  ];
+}
+
+describe("Desktop RpcTarget method visibility", () => {
+  it("keeps model and permission discovery callable over RPC while steering is installed", async () => {
+    const manager = new Manager();
+    await expect(callRpc(manager, "sendRequest", "model/list", {})).resolves.toEqual({
+      data: ["available"],
+    });
+    const dispose = install(manager);
+    try {
+      for (const method of ["model/list", "permissionProfile/list"]) {
+        await expect(callRpc(manager, "sendRequest", method, {})).resolves.toEqual({
+          data: ["available"],
+        });
+      }
+      expect(manager).toBeInstanceOf(Manager);
+    } finally {
+      dispose();
+    }
+  });
+
+  it("allows an external direction change through the exported steer method", async () => {
+    const manager = new Manager();
+    const dispose = install(manager);
+    try {
+      await expect(callRpc(manager, "steerTurn", ...steerArgs(manager))).resolves.toEqual({
+        turnId: "replacement",
+      });
+      expect(manager.presented).toHaveLength(1);
+      expect(manager.requests.mock.calls.map(([method]) => method)).toEqual([
+        "codexhost/thread/ownership/list",
+        "turn/steer",
+      ]);
+    } finally {
+      dispose();
+    }
+  });
+
+  it("preserves official steering and does not patch other Manager instances", async () => {
+    const manager = new Manager();
+    manager.owner = "codex";
+    const other = new Manager();
+    const original = other.sendRequest;
+    const dispose = install(manager);
+    try {
+      expect(other.sendRequest).toBe(original);
+      expect(Object.getPrototypeOf(other)).toBe(Manager.prototype);
+      await expect(callRpc(manager, "steerTurn", ...steerArgs(manager))).resolves.toEqual({
+        turnId: "official",
+      });
+      expect(manager.presented).toHaveLength(0);
+    } finally {
+      dispose();
+    }
+  });
+
+  it("restores the original prototype without own-property shadows across reinstall", async () => {
+    const manager = new Manager();
+    for (let i = 0; i < 2; i++) {
+      const dispose = install(manager);
+      dispose();
+      expect(Object.hasOwn(manager, "sendRequest")).toBe(false);
+      expect(Object.hasOwn(manager, "steerTurn")).toBe(false);
+      expect(Object.getPrototypeOf(manager)).toBe(Manager.prototype);
+      expect(manager.sendRequest).toBe(Manager.prototype.sendRequest);
+      await expect(callRpc(manager, "sendRequest", "permissionProfile/list", {})).resolves.toEqual({
+        data: ["available"],
+      });
+    }
+  });
+
+  it("keeps RPC reads working while a disposed replacement waits to fail closed", async () => {
+    const manager = new Manager();
+    const waiting = Promise.withResolvers<undefined>();
+    manager.onMessageAdded.mockReturnValue(waiting.promise);
+    const dispose = install(manager);
+    expect(Object.hasOwn(manager, "steerTurn")).toBe(false);
+    const result = callRpc(manager, "steerTurn", ...steerArgs(manager));
+    const rejected = expect(result).rejects.toThrow("disposed");
+    await vi.waitFor(() => expect(manager.onMessageAdded).toHaveBeenCalledOnce());
+    dispose();
+    expect(manager.steerTurn).toBe(Manager.prototype.steerTurn);
+    await expect(callRpc(manager, "sendRequest", "model/list", {})).resolves.toEqual({
+      data: ["available"],
+    });
+    waiting.resolve(undefined);
+    await rejected;
+    await vi.waitFor(() => expect(Object.getPrototypeOf(manager)).toBe(Manager.prototype));
+    expect(Object.hasOwn(manager, "sendRequest")).toBe(false);
+    expect(manager.requests.mock.calls.map(([method]) => method)).not.toContain("turn/start");
+  });
+});

package/src/native-ui/renderer-extension/test/renderer-external-steering.test.ts

@@ -0,0 +1,279 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { installRendererExternalSteering } from "../src/renderer-external-steering.js";
+
+function fixture(owner: "external" | "codex" = "external") {
+  const events: string[] = [];
+  const requestOptions: Record<string, unknown> = { timeoutMs: 30_000 };
+  let queued: Array<{ id: string; pausedReason?: string }> = [];
+  const originalTurn = {
+    turnId: "old",
+    status: "inProgress",
+    input: "original",
+    steeringItems: [],
+  };
+  const turns = [originalTurn];
+  const rpc = vi.fn(
+    async (method: unknown, params: unknown, options?: unknown): Promise<unknown> => {
+      void options;
+      if (method === "codexhost/thread/ownership/list") {
+        return {
+          threads: [
+            { threadId: "thread", owner, ...(owner === "external" ? { harnessId: "pi" } : {}) },
+          ],
+        };
+      }
+      if (method === "turn/steer") {
+        events.push("cancel old");
+        originalTurn.status = "interrupted";
+        queued = queued.map((message) => ({
+          ...message,
+          pausedReason: message.pausedReason ?? "Interrupted before the steer was accepted.",
+        }));
+        events.push("old completed");
+        return { turnId: "replacement" };
+      }
+      return { method, params };
+    },
+  );
+  const manager = {
+    sendRequest: rpc,
+    steerTurn: vi
+      .fn<(...args: unknown[]) => Promise<{ turnId: string }>>()
+      .mockResolvedValue({ turnId: "official" }),
+    getStreamRole: vi.fn(() => ({ role: "owner" })),
+    getTurnCoordinator: () => ({
+      loadMessages: async () => undefined,
+      readMessages: () => queued,
+      mutate: (_threadId: string, update: (messages: typeof queued) => typeof queued) => {
+        queued = update(queued);
+      },
+      options: {
+        submissionHost: {
+          getActiveTurnId: () =>
+            turns.at(-1)?.status === "inProgress" ? turns.at(-1)?.turnId : null,
+          hasPendingTurnStart: () => false,
+        },
+      },
+    }),
+    startTurn: vi.fn(async (...args: unknown[]) => {
+      const operation = args[1] as {
+        request: { input: Array<{ text: string }>; clientUserMessageId: string };
+        context: unknown;
+      };
+      const placeholder = {
+        turnId: "",
+        status: "inProgress",
+        input: operation.request.input[0]?.text ?? "",
+        steeringItems: [],
+      };
+      turns.push(placeholder);
+      events.push("new input displayed");
+      if (typeof args[2] === "function") await args[2]();
+      const response = (await manager.sendRequest(
+        "turn/start",
+        operation.request,
+        requestOptions,
+      )) as { turn: { id: string } };
+      placeholder.turnId = response.turn.id;
+      events.push("new identity accepted");
+      return response;
+    }),
+  };
+  const originalSteer = manager.steerTurn;
+  const dispose = installRendererExternalSteering(manager);
+  if (!dispose) throw new Error("Synthetic Renderer steering binding was not installed");
+  const args: unknown[] = [
+    "thread",
+    [{ type: "text", text: "new input", text_elements: [] }],
+    { id: "message", cwd: "/project", context: { commentAttachments: [] } },
+    null,
+    [],
+    "message",
+    null,
+    null,
+    vi.fn(),
+  ];
+  return {
+    manager,
+    rpc,
+    args,
+    events,
+    turns,
+    originalSteer,
+    dispose,
+    requestOptions,
+    queue: {
+      read: () => queued,
+      set: (messages: typeof queued) => {
+        queued = messages;
+      },
+    },
+  };
+}
+
+describe("external direction changes use normal Desktop start presentation", () => {
+  it("creates a new input placeholder, replaces through steer RPC, and never creates an old steering Item", async () => {
+    const f = fixture();
+    // Normal start operations carry their thread identity, as Desktop's start preparation does.
+    await expect(f.manager.steerTurn(...f.args)).resolves.toEqual({ turnId: "replacement" });
+    expect(f.originalSteer).not.toHaveBeenCalled();
+    expect(f.events).toEqual([
+      "new input displayed",
+      "cancel old",
+      "old completed",
+      "new identity accepted",
+    ]);
+    expect(f.turns).toEqual([
+      { turnId: "old", status: "interrupted", input: "original", steeringItems: [] },
+      { turnId: "replacement", status: "inProgress", input: "new input", steeringItems: [] },
+    ]);
+    expect(f.rpc).toHaveBeenLastCalledWith(
+      "turn/steer",
+      expect.objectContaining({
+        threadId: "thread",
+        expectedTurnId: "old",
+        clientUserMessageId: "message",
+        input: f.args[1],
+      }),
+      { timeoutMs: 30_000 },
+    );
+    expect(f.args[8]).toHaveBeenCalledOnce();
+    f.dispose();
+  });
+
+  it("passes official steering and unrelated requests through unchanged", async () => {
+    const f = fixture("codex");
+    await expect(f.manager.steerTurn(...f.args)).resolves.toEqual({ turnId: "official" });
+    expect(f.originalSteer).toHaveBeenCalledWith(...f.args);
+    expect(f.manager.startTurn).not.toHaveBeenCalled();
+    await f.manager.sendRequest(
+      "turn/start",
+      { threadId: "other", clientUserMessageId: "message" },
+      { custom: true },
+    );
+    expect(f.rpc).toHaveBeenLastCalledWith(
+      "turn/start",
+      { threadId: "other", clientUserMessageId: "message" },
+      { custom: true },
+    );
+    f.dispose();
+    expect(f.manager.steerTurn).toBe(f.originalSteer);
+    expect(f.manager.sendRequest).toBe(f.rpc);
+  });
+
+  it.each([
+    { input: [] },
+    { input: [{ type: "text", text: " " }] },
+    { input: [{ type: "image", url: "image" }] },
+    {
+      input: [
+        { type: "text", text: "new input" },
+        { type: "localImage", path: "" },
+      ],
+    },
+  ])("rejects unsupported input before cancel or creating a placeholder: %j", async ({ input }) => {
+    const f = fixture();
+    f.args[1] = input;
+    await expect(f.manager.steerTurn(...f.args)).rejects.toThrow("text input");
+    expect(f.manager.startTurn).not.toHaveBeenCalled();
+    expect(f.events).toEqual([]);
+    f.dispose();
+  });
+
+  it("coalesces duplicate messages and rejects competing replacements", async () => {
+    const f = fixture();
+    const waiting = Promise.withResolvers<undefined>();
+    f.args[8] = () => waiting.promise;
+    const first = f.manager.steerTurn(...f.args);
+    await vi.waitFor(() => expect(f.manager.startTurn).toHaveBeenCalledOnce());
+    const duplicate = f.manager.steerTurn(...f.args);
+    const competing = [...f.args];
+    competing[5] = "different-message";
+    await expect(f.manager.steerTurn(...competing)).rejects.toThrow("already changing direction");
+    waiting.resolve(undefined);
+    await expect(first).resolves.toEqual({ turnId: "replacement" });
+    await expect(duplicate).resolves.toEqual({ turnId: "replacement" });
+    expect(f.manager.startTurn).toHaveBeenCalledOnce();
+    expect(f.events.filter((event) => event === "cancel old")).toHaveLength(1);
+    f.dispose();
+  });
+
+  it("retains Desktop outcome-unknown delivery tracking until the replacement is confirmed", async () => {
+    const f = fixture();
+    const response = Promise.withResolvers<unknown>();
+    const unknown = vi.fn();
+    f.requestOptions.onOutcomeUnknown = unknown;
+    const original = f.rpc.getMockImplementation();
+    f.rpc.mockImplementation(async (method, params, options) => {
+      if (method !== "turn/steer") return original?.(method, params, options);
+      expect(options).toBe(f.requestOptions);
+      (options as { onOutcomeUnknown(delivery: unknown): void }).onOutcomeUnknown({
+        requestId: "rpc",
+        method,
+        stage: "outcome-unknown",
+      });
+      return response.promise;
+    });
+    const result = f.manager.steerTurn(...f.args);
+    await vi.waitFor(() => expect(unknown).toHaveBeenCalledOnce());
+    expect(f.events).toEqual(["new input displayed"]);
+    const duplicate = f.manager.steerTurn(...f.args);
+    response.resolve({ turnId: "replacement" });
+    await expect(result).resolves.toEqual({ turnId: "replacement" });
+    await expect(duplicate).resolves.toEqual({ turnId: "replacement" });
+    expect(f.manager.startTurn).toHaveBeenCalledOnce();
+    f.dispose();
+  });
+
+  it("does not fall back to an ordinary start if disposed before dispatch", async () => {
+    const f = fixture();
+    const waiting = Promise.withResolvers<undefined>();
+    f.args[8] = () => waiting.promise;
+    const result = f.manager.steerTurn(...f.args);
+    await vi.waitFor(() => expect(f.manager.startTurn).toHaveBeenCalledOnce());
+    f.dispose();
+    waiting.resolve(undefined);
+    await expect(result).rejects.toThrow("disposed");
+    expect(f.rpc.mock.calls.map(([method]) => method)).toEqual(["codexhost/thread/ownership/list"]);
+  });
+
+  it("resumes automatically paused queue messages without unpausing older paused entries", async () => {
+    const f = fixture();
+    const pausedReason = "Interrupted before the steer was accepted.";
+    f.queue.set([{ id: "queued" }, { id: "previously-paused", pausedReason }]);
+    f.args[8] = () => f.queue.set([...f.queue.read(), { id: "queued-during-replacement" }]);
+    await f.manager.steerTurn(...f.args);
+    expect(f.queue.read()).toEqual([
+      { id: "queued" },
+      { id: "previously-paused", pausedReason },
+      { id: "queued-during-replacement" },
+    ]);
+    f.dispose();
+  });
+
+  it("lets a follower delegate the original steer to its owning window", async () => {
+    const f = fixture();
+    f.manager.getStreamRole.mockReturnValue({ role: "follower" });
+    await expect(f.manager.steerTurn(...f.args)).resolves.toEqual({ turnId: "official" });
+    expect(f.originalSteer).toHaveBeenCalledWith(...f.args);
+    expect(f.rpc).not.toHaveBeenCalled();
+    expect(f.manager.startTurn).not.toHaveBeenCalled();
+    f.dispose();
+  });
+
+  it("does not swallow an ownership failure or retry a failed replacement", async () => {
+    const f = fixture();
+    f.rpc.mockRejectedValueOnce(new Error("ownership unavailable"));
+    await expect(f.manager.steerTurn(...f.args)).rejects.toThrow("ownership unavailable");
+    expect(f.originalSteer).not.toHaveBeenCalled();
+    f.rpc.mockImplementation(async (method) => {
+      if (method === "codexhost/thread/ownership/list")
+        return { threads: [{ threadId: "thread", owner: "external", harnessId: "pi" }] };
+      throw new Error("cancel failed");
+    });
+    await expect(f.manager.steerTurn(...f.args)).rejects.toThrow("cancel failed");
+    expect(f.manager.startTurn).toHaveBeenCalledOnce();
+    f.dispose();
+  });
+});