tmux-ide 2.9.2 → 2.9.4

package/packages/daemon-client/src/workspace-client.test.ts

@@ -1,2912 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  APPLICATION_SHELL_COMMAND_IDS,
-  APPLICATION_SHELL_RESOURCE_V3_VERSION,
-  ApplicationShellProjectionInputV3SchemaZ,
-  COHESION_FIXTURE_V1,
-  DAEMON_WIRE_PROTOCOL_VERSION,
-  DesktopApplicationShellTargetSchemaZ,
-  applicationShellCommandInvocation,
-  type ApplicationShellProjectionInputV3,
-  type DesktopApplicationShellTarget,
-  type InteractionReceipt,
-  type SessionRuntimeTerminalInput,
-  type TerminalReplicaAddress,
-  type TerminalReplicaUpdate,
-} from "@tmux-ide/contracts";
-
-import type {
-  WorkspaceClient,
-  ApplicationShellEventHandlers,
-  ApplicationShellTransport,
-} from "./application-shell-session.ts";
-import type { GenerationBoundClock } from "./generation-bound-store.ts";
-import {
-  createDirectLoopbackDaemonTransport,
-  type TerminalFirstDaemonTransport,
-} from "./direct-application-shell-transport.ts";
-import type {
-  WorkspaceEventSocket,
-  WorkspaceEventSocketEvent,
-  WorkspaceEventSocketEventType,
-  WorkspaceEventSocketListener,
-} from "./workspace-event-supervisor.ts";
-import { createWorkspaceClient } from "./workspace-client.ts";
-import { runtimeResourceSnapshot } from "./runtime-resource-ledger.ts";
-import {
-  createTerminalFastLane,
-  createWorkspaceClientTerminalSource,
-  type TerminalFastLane,
-} from "./terminal-fast-lane.ts";
-import { createWorkspaceClientConformanceAdapter } from "./workspace-client-conformance.ts";
-import type {
-  WorkspaceClientOwnerActionPort,
-  WorkspaceClientRuntimeInventory,
-  WorkspaceClientRuntimePort,
-} from "./workspace-client-types.ts";
-
-const daemon = (instanceId: string) => ({
-  protocolVersion: DAEMON_WIRE_PROTOCOL_VERSION,
-  productVersion: "2.8.0",
-  instanceId,
-  startedAt: "2026-08-14T10:00:00.000Z",
-});
-const ALPHA_DAEMON = daemon("11111111-1111-4111-8111-111111111111");
-const BETA_DAEMON = daemon("22222222-2222-4222-8222-222222222222");
-
-function target(workspaceName: string, identity = ALPHA_DAEMON): DesktopApplicationShellTarget {
-  return DesktopApplicationShellTargetSchemaZ.parse({ daemon: identity, workspaceName });
-}
-
-function workspaceCatalog(workspaceName: string, identity = ALPHA_DAEMON) {
-  return {
-    version: 2,
-    daemon: identity,
-    intents: [
-      {
-        workspaceName,
-        sessionName: workspaceName,
-        source: "workspace",
-        availability: "live",
-      },
-    ],
-    liveSessions: [
-      {
-        sessionName: workspaceName,
-        fleetSessionId: `session.${workspaceName === "alpha" ? "a" : "b"}`.padEnd(28, "0"),
-        paneCount: 1,
-      },
-    ],
-  };
-}
-
-function shellResource(
-  name: string,
-  semanticPaneIds: readonly string[] = [`pane.${name}`],
-): ApplicationShellProjectionInputV3 {
-  return ApplicationShellProjectionInputV3SchemaZ.parse({
-    project: { ...COHESION_FIXTURE_V1.project, name },
-    workspace: {
-      ...COHESION_FIXTURE_V1.workspace,
-      id: `workspace.${name}`,
-      activeMode: "terminals",
-      sidebar: {
-        ...COHESION_FIXTURE_V1.workspace.sidebar,
-        agents: COHESION_FIXTURE_V1.workspace.sidebar.agents.map((agent) => ({
-          ...agent,
-          paneId: null,
-        })),
-      },
-    },
-    dock: COHESION_FIXTURE_V1.dock,
-    focus: { ...COHESION_FIXTURE_V1.focus, overlays: [] },
-    connection: COHESION_FIXTURE_V1.connection,
-    terminalInventory: {
-      activeResourceId: semanticPaneIds[0] ?? null,
-      resources: semanticPaneIds.map((semanticPaneId, index) => ({
-        id: semanticPaneId,
-        title: `Terminal ${index + 1}`,
-        kind: "terminal" as const,
-        active: index === 0,
-        attachability: { status: "available" as const, semanticPaneId },
-        interactionEndpoint: null,
-        nativeIdentity: null,
-      })),
-    },
-    appWindows: {
-      version: 1,
-      revision: 7,
-      updatedAt: "2026-08-14T10:00:00.000Z",
-      windows: {},
-      dockRoot: null,
-      dockState: { mode: "collapsed", preferredHeight: null, focusZone: "canvas" },
-      floatingOrder: [],
-      focusedWindowId: null,
-      activeLayoutId: null,
-      layouts: {},
-    },
-  });
-}
-
-class FakeClock implements GenerationBoundClock {
-  nowValue = 1_000;
-  nextId = 0;
-  readonly timers = new Map<number, { at: number; callback: () => void }>();
-  now(): number {
-    return this.nowValue;
-  }
-  setTimeout(callback: () => void, delayMs: number): unknown {
-    const id = ++this.nextId;
-    this.timers.set(id, { at: this.nowValue + delayMs, callback });
-    return id;
-  }
-  clearTimeout(handle: unknown): void {
-    this.timers.delete(handle as number);
-  }
-  advance(ms: number): void {
-    this.nowValue += ms;
-    for (;;) {
-      const due = [...this.timers.entries()]
-        .filter(([, timer]) => timer.at <= this.nowValue)
-        .sort((left, right) => left[1].at - right[1].at)[0];
-      if (due === undefined) return;
-      this.timers.delete(due[0]);
-      due[1].callback();
-    }
-  }
-}
-
-interface ShellConnection {
-  readonly target: DesktopApplicationShellTarget;
-  readonly handlers: ApplicationShellEventHandlers;
-  closed: boolean;
-}
-
-function shellBroker(resources: Readonly<Record<string, ApplicationShellProjectionInputV3>>) {
-  const byWorkspace = new Map(Object.entries(resources));
-  const connections: ShellConnection[] = [];
-  const transport: ApplicationShellTransport<ApplicationShellProjectionInputV3> = {
-    validateTarget: (value) => DesktopApplicationShellTargetSchemaZ.parse(value),
-    fetchApplicationShell: async (current) => {
-      const resource = byWorkspace.get(current.workspaceName);
-      if (resource === undefined) throw new Error(`missing ${current.workspaceName}`);
-      return resource;
-    },
-    connectEvents: (current, handlers) => {
-      const connection = { target: current, handlers, closed: false };
-      connections.push(connection);
-      return { close: () => (connection.closed = true) };
-    },
-  };
-  return { transport, connections, byWorkspace };
-}
-
-class WorkspaceClientEventSocket implements WorkspaceEventSocket {
-  readyState = 1;
-  readonly sent: unknown[] = [];
-  readonly listeners = new Map<WorkspaceEventSocketEventType, Set<WorkspaceEventSocketListener>>();
-  addEventListener(type: WorkspaceEventSocketEventType, listener: WorkspaceEventSocketListener) {
-    const listeners = this.listeners.get(type) ?? new Set();
-    listeners.add(listener);
-    this.listeners.set(type, listeners);
-  }
-  removeEventListener(type: WorkspaceEventSocketEventType, listener: WorkspaceEventSocketListener) {
-    this.listeners.get(type)?.delete(listener);
-  }
-  send(value: string) {
-    this.sent.push(JSON.parse(value));
-  }
-  close() {}
-  emit(type: WorkspaceEventSocketEventType, event: WorkspaceEventSocketEvent = {}) {
-    for (const listener of this.listeners.get(type) ?? []) listener(event);
-  }
-  frame(value: unknown) {
-    this.emit("message", { data: JSON.stringify(value) });
-  }
-}
-
-class FakeTerminalSubscription {
-  readonly listeners = new Set<(update: TerminalReplicaUpdate<string, string>) => void>();
-  closeCount = 0;
-  closeGate: Promise<void> | null = null;
-  constructor(readonly generation: string) {}
-  async close(): Promise<void> {
-    this.closeCount += 1;
-    if (this.closeGate) await this.closeGate;
-  }
-  freeze(): void {}
-  thaw(): void {}
-  onUpdate(listener: (update: TerminalReplicaUpdate<string, string>) => void): () => void {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  emit(update: TerminalReplicaUpdate<string, string>): void {
-    for (const listener of this.listeners) listener(update);
-  }
-}
-
-class FakeRuntime implements WorkspaceClientRuntimePort<string, string> {
-  readonly closed = new Promise<never>(() => undefined);
-  readonly receipts = new Set<(receipt: InteractionReceipt) => void>();
-  readonly subscriptions = new Map<string, FakeTerminalSubscription>();
-  closeCount = 0;
-  submitCount = 0;
-  readonly inputs: Array<{
-    target: TerminalReplicaAddress;
-    input: SessionRuntimeTerminalInput;
-    traceId?: string;
-  }> = [];
-  inputResult: "ok" | "authority-lost" = "ok";
-  inputGate: Promise<void> | null = null;
-  readonly viewportFits: Array<{ cols: number; rows: number; semanticWindowId?: string }> = [];
-  viewportGate: Promise<void> | null = null;
-  viewportResult: "ok" | "geometry-authority-conflict" = "ok";
-  authorityGate: Promise<void> | null = null;
-  closeGate: Promise<void> | null = null;
-  readonly repairRequests: Array<{
-    target: TerminalReplicaAddress;
-    reason: "gap" | "conflict" | "wrong-address" | "missing-state";
-  }> = [];
-  constructor(readonly generation: string) {}
-  async subscribeTerminal(address: TerminalReplicaAddress): Promise<FakeTerminalSubscription> {
-    const subscription = new FakeTerminalSubscription(this.generation);
-    this.subscriptions.set(address.semanticPaneId, subscription);
-    return subscription;
-  }
-  async submitIntent(): Promise<void> {
-    this.submitCount += 1;
-  }
-  async sendTerminalInput(
-    nextTarget: TerminalReplicaAddress,
-    input: SessionRuntimeTerminalInput,
-    traceId?: string,
-  ): Promise<"ok" | "authority-lost"> {
-    if (this.inputGate) await this.inputGate;
-    this.inputs.push({ target: nextTarget, input, ...(traceId ? { traceId } : {}) });
-    return this.inputResult;
-  }
-  async fitViewport(
-    cols: number,
-    rows: number,
-    semanticWindowId?: string,
-  ): Promise<"ok" | "geometry-authority-conflict"> {
-    if (this.viewportGate) await this.viewportGate;
-    this.viewportFits.push({
-      cols,
-      rows,
-      ...(semanticWindowId === undefined ? {} : { semanticWindowId }),
-    });
-    return this.viewportResult;
-  }
-  async requestAuthority(authority: "input" | "focus" | "geometry") {
-    if (this.authorityGate) await this.authorityGate;
-    return {
-      generation: this.generation,
-      session: "alpha",
-      clientId: "opentui:test",
-      authority,
-      token: "55555555-5555-4555-8555-555555555555",
-      revision: 1,
-    } as const;
-  }
-  onReceipt(listener: (receipt: InteractionReceipt) => void): () => void {
-    this.receipts.add(listener);
-    return () => this.receipts.delete(listener);
-  }
-  emitReceipt(receipt: InteractionReceipt): void {
-    for (const listener of this.receipts) listener(receipt);
-  }
-  requestTerminalRepair = (
-    nextTarget: TerminalReplicaAddress,
-    reason: "gap" | "conflict" | "wrong-address" | "missing-state",
-  ): void => {
-    this.repairRequests.push({ target: nextTarget, reason });
-  };
-  async close(): Promise<void> {
-    this.closeCount += 1;
-    if (this.closeGate) await this.closeGate;
-  }
-}
-
-class EagerSeedRuntime extends FakeRuntime {
-  constructor(
-    generation: string,
-    private readonly snapshot: string,
-  ) {
-    super(generation);
-  }
-
-  override async subscribeTerminal(
-    address: TerminalReplicaAddress,
-  ): Promise<FakeTerminalSubscription> {
-    const subscription = new FakeTerminalSubscription(this.generation);
-    const onUpdate = subscription.onUpdate.bind(subscription);
-    subscription.onUpdate = (listener) => {
-      const unsubscribe = onUpdate(listener);
-      listener({
-        ...terminalSeedFor(address.semanticPaneId, this.generation),
-        snapshot: this.snapshot,
-      });
-      return unsubscribe;
-    };
-    this.subscriptions.set(address.semanticPaneId, subscription);
-    return subscription;
-  }
-}
-
-class ClosableFakeRuntime extends FakeRuntime {
-  private readonly closedState = deferred<void>();
-  override readonly closed = this.closedState.promise;
-  fail(): void {
-    this.closedState.resolve();
-  }
-}
-
-const actions: WorkspaceClientOwnerActionPort = {
-  dispatch: async () => null,
-};
-
-async function settle(): Promise<void> {
-  for (let turn = 0; turn < 16; turn += 1) await Promise.resolve();
-}
-
-function deferred<T>() {
-  let resolve!: (value: T) => void;
-  const promise = new Promise<T>((accept) => {
-    resolve = accept;
-  });
-  return { promise, resolve };
-}
-
-function receipt(operationId: string, phase: InteractionReceipt["phase"]): InteractionReceipt {
-  return {
-    evidence: null,
-    type: "interaction.receipt",
-    sequence: phase === "accepted" ? 1 : 2,
-    operationId,
-    origin: "sdk",
-    workspaceName: "alpha",
-    sourceSemanticPaneId: null,
-    target: { kind: "pane", semanticPaneId: "pane.alpha" },
-    operationKind: "workspace.pane.send",
-    phase,
-    summary: {
-      operationKind: "workspace.pane.send",
-      characterCount: 1,
-      byteCount: 1,
-      submitted: true,
-    },
-    proof:
-      phase === "observed"
-        ? {
-            operationKind: "workspace.pane.send",
-            observed: true,
-            semanticPaneId: "pane.alpha",
-          }
-        : null,
-    at: "2026-08-14T10:00:00.000Z",
-    resourceRevision: null,
-  };
-}
-
-function terminalSeed(generation: string): TerminalReplicaUpdate<string, string> {
-  return {
-    type: "terminal.seed",
-    workspaceName: "alpha",
-    semanticPaneId: "pane.alpha",
-    generation,
-    incarnation: "incarnation-1",
-    revision: 0,
-    cols: 80,
-    rows: 24,
-    stateHash: "0000000000000000",
-    hashAlgorithm: "fnv1a64-v1",
-    snapshot: "terminal bytes stay outside semantic snapshots",
-  };
-}
-
-function terminalSeedFor(
-  semanticPaneId: string,
-  generation: string,
-): TerminalReplicaUpdate<string, string> {
-  return { ...terminalSeed(generation), semanticPaneId };
-}
-
-describe("WorkspaceClient", () => {
-  it("publishes a bounded degraded state when semantic shell projection rejects", async () => {
-    const valid = shellResource("alpha");
-    const corrupt = {
-      ...valid,
-      workspace: {
-        ...valid.workspace,
-        sidebar: {
-          ...valid.workspace.sidebar,
-          agents: valid.workspace.sidebar.agents.map((agent, index) =>
-            index < 2 ? { ...agent, paneId: "pane.alpha" } : agent,
-          ),
-        },
-      },
-    } as ApplicationShellProjectionInputV3;
-    const shell = shellBroker({ alpha: corrupt });
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => new FakeRuntime(ALPHA_DAEMON.instanceId),
-        actions,
-      },
-    });
-
-    await settle();
-    expect(client.getSnapshot().shell).toMatchObject({
-      status: "degraded",
-      code: "schema-invalid",
-      data: null,
-      reason: "The application shell failed semantic projection.",
-    });
-    expect(client.getSnapshot().semantic).toBeNull();
-    await client.dispose();
-  });
-
-  it("defers application-shell until terminal authority adopts through runtime staging", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const inventories: WorkspaceClientRuntimeInventory[] = [];
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      deferApplicationShell: true,
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory) => {
-          inventories.push(inventory);
-          return runtime;
-        },
-        actions,
-      },
-    });
-    await settle();
-    expect(shell.connections).toHaveLength(0);
-    expect(inventories).toHaveLength(0);
-
-    expect(
-      client.adoptTerminalRuntimeInventory({
-        workspaceName: "alpha",
-        workspaceId: "workspace.alpha",
-        sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-        resourceRevision: 7,
-        semanticPaneIds: ["pane.alpha"],
-      }),
-    ).toBe(true);
-    await settle();
-    expect(inventories).toHaveLength(1);
-    expect(inventories[0]).toMatchObject({
-      terminalResourceRevision: 7,
-      shellGeneration: 1,
-      semanticPaneIds: ["pane.alpha"],
-    });
-    expect(shell.connections).toHaveLength(1);
-    await client.dispose();
-  });
-
-  it("never lets late V2 topology roll back a newer terminal revision", async () => {
-    const lateV2 = deferred<ApplicationShellProjectionInputV3>();
-    const shellConnections: ShellConnection[] = [];
-    const shellTransport: ApplicationShellTransport<ApplicationShellProjectionInputV3> = {
-      validateTarget: (value) => DesktopApplicationShellTargetSchemaZ.parse(value),
-      fetchApplicationShell: () => lateV2.promise,
-      connectEvents: (current, handlers) => {
-        shellConnections.push({ target: current, handlers, closed: false });
-        return { close: () => undefined };
-      },
-    };
-    const inventories: WorkspaceClientRuntimeInventory[] = [];
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      deferApplicationShell: true,
-      ports: {
-        shell: shellTransport,
-        connectRuntime: async (_current, inventory) => {
-          inventories.push(inventory);
-          return new FakeRuntime(ALPHA_DAEMON.instanceId);
-        },
-        actions,
-      },
-    });
-    const base = {
-      workspaceName: "alpha",
-      workspaceId: "workspace.alpha",
-      sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-    };
-    client.adoptTerminalRuntimeInventory({
-      ...base,
-      resourceRevision: 1,
-      semanticPaneIds: ["pane.a"],
-    });
-    client.adoptTerminalRuntimeInventory({
-      ...base,
-      resourceRevision: 2,
-      semanticPaneIds: ["pane.b"],
-    });
-    lateV2.resolve(shellResource("alpha", ["pane.a"]));
-    await settle();
-    // The obsolete first inventory is coalesced before physical connection.
-    expect(inventories.map((inventory) => inventory.semanticPaneIds)).toEqual([["pane.b"]]);
-    expect(
-      client.adoptTerminalRuntimeInventory({
-        ...base,
-        resourceRevision: 1,
-        semanticPaneIds: ["pane.a"],
-      }),
-    ).toBe(false);
-    await client.dispose();
-  });
-
-  it("treats V2 mismatch as a terminal-authority refresh request only", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.b"]) });
-    let refreshes = 0;
-    const inventories: WorkspaceClientRuntimeInventory[] = [];
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      deferApplicationShell: true,
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory) => {
-          inventories.push(inventory);
-          return new FakeRuntime(ALPHA_DAEMON.instanceId);
-        },
-        requestTerminalRuntimeInventoryRefresh: () => {
-          refreshes += 1;
-        },
-        actions,
-      },
-    });
-    client.adoptTerminalRuntimeInventory({
-      workspaceName: "alpha",
-      workspaceId: "workspace.alpha",
-      sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-      resourceRevision: 1,
-      semanticPaneIds: ["pane.a"],
-    });
-    await settle();
-    expect(inventories.map((inventory) => inventory.semanticPaneIds)).toEqual([["pane.a"]]);
-    expect(refreshes).toBe(1);
-    for (let index = 0; index < 2_000; index += 1) {
-      expect(
-        client.adoptTerminalRuntimeInventory({
-          workspaceName: "alpha",
-          workspaceId: "workspace.alpha",
-          sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-          resourceRevision: 1,
-          semanticPaneIds: ["pane.a"],
-        }),
-      ).toBe(true);
-    }
-    await settle();
-    expect(refreshes).toBe(1);
-
-    shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.c"]));
-    shell.connections.at(-1)?.handlers.onInvalidate();
-    await settle();
-    expect(refreshes).toBe(2);
-
-    expect(
-      client.adoptTerminalRuntimeInventory({
-        workspaceName: "alpha",
-        workspaceId: "workspace.alpha",
-        sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-        resourceRevision: 2,
-        semanticPaneIds: ["pane.c"],
-      }),
-    ).toBe(true);
-    await settle();
-    expect(refreshes).toBe(2);
-    await client.dispose();
-  });
-
-  it("bounds stale-topology refresh and reopens only the replacement inventory", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.a"]) });
-    const inventories: string[][] = [];
-    let refreshes = 0;
-    let client!: ReturnType<typeof createWorkspaceClient>;
-    client = createWorkspaceClient({
-      target: target("alpha"),
-      deferApplicationShell: true,
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory) => {
-          inventories.push([...inventory.semanticPaneIds]);
-          if (inventories.length === 1)
-            throw Object.assign(new Error("stale terminal topology"), {
-              code: "topology-changed",
-            });
-          return new FakeRuntime(ALPHA_DAEMON.instanceId);
-        },
-        requestTerminalRuntimeInventoryRefresh: () => {
-          refreshes += 1;
-          shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.b"]));
-          queueMicrotask(() => {
-            client.adoptTerminalRuntimeInventory({
-              workspaceName: "alpha",
-              workspaceId: "workspace.alpha",
-              sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-              resourceRevision: 2,
-              semanticPaneIds: ["pane.b"],
-            });
-          });
-        },
-        actions,
-      },
-    });
-    client.adoptTerminalRuntimeInventory({
-      workspaceName: "alpha",
-      workspaceId: "workspace.alpha",
-      sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-      resourceRevision: 1,
-      semanticPaneIds: ["pane.a"],
-    });
-
-    await settle();
-    await settle();
-    expect(refreshes).toBe(2);
-    expect(inventories).toEqual([["pane.a"], ["pane.b"]]);
-    await client.dispose();
-  });
-
-  it("refreshes stale topology when an active runtime reconnects after ordinary tmux changes", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.a"]) });
-    const clock = new FakeClock();
-    const firstRuntime = new ClosableFakeRuntime(ALPHA_DAEMON.instanceId);
-    const replacementRuntime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const inventories: string[][] = [];
-    const activatedInventories: string[][] = [];
-    let refreshes = 0;
-    let client!: ReturnType<typeof createWorkspaceClient>;
-    client = createWorkspaceClient({
-      target: target("alpha"),
-      deferApplicationShell: true,
-      clock,
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory) => {
-          inventories.push([...inventory.semanticPaneIds]);
-          if (inventories.length === 1) return firstRuntime;
-          if (inventory.semanticPaneIds.includes("pane.a")) {
-            throw Object.assign(new Error("ordinary tmux changed the pane topology"), {
-              code: "topology-changed",
-            });
-          }
-          return replacementRuntime;
-        },
-        requestTerminalRuntimeInventoryRefresh: () => {
-          refreshes += 1;
-          if (refreshes !== 1) return;
-          shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.b"]));
-          shell.connections.at(-1)?.handlers.onInvalidate();
-          queueMicrotask(() => {
-            client.adoptTerminalRuntimeInventory({
-              workspaceName: "alpha",
-              workspaceId: "workspace.alpha",
-              sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-              resourceRevision: 2,
-              semanticPaneIds: ["pane.b"],
-            });
-          });
-        },
-        didActivateRuntime: (_runtime, inventory) => {
-          activatedInventories.push([...inventory.semanticPaneIds]);
-        },
-        actions,
-      },
-    });
-    client.adoptTerminalRuntimeInventory({
-      workspaceName: "alpha",
-      workspaceId: "workspace.alpha",
-      sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-      resourceRevision: 1,
-      semanticPaneIds: ["pane.a"],
-    });
-    await settle();
-    expect(inventories).toEqual([["pane.a"]]);
-
-    firstRuntime.fail();
-    await settle();
-    clock.advance(1_000);
-    await settle();
-    await settle();
-
-    expect(inventories).toEqual([["pane.a"], ["pane.a"], ["pane.b"]]);
-    expect(refreshes).toBe(2);
-    expect(activatedInventories).toEqual([["pane.a"], ["pane.b"]]);
-    await client.dispose();
-  });
-
-  it("fails closed when one terminal revision carries conflicting authority", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.a"]) });
-    const inventories: WorkspaceClientRuntimeInventory[] = [];
-    let refreshes = 0;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      deferApplicationShell: true,
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory) => {
-          inventories.push(inventory);
-          return new FakeRuntime(ALPHA_DAEMON.instanceId);
-        },
-        requestTerminalRuntimeInventoryRefresh: () => {
-          refreshes += 1;
-        },
-        actions,
-      },
-    });
-    const base = {
-      workspaceName: "alpha",
-      workspaceId: "workspace.alpha",
-      sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-      resourceRevision: 7,
-    };
-    expect(client.adoptTerminalRuntimeInventory({ ...base, semanticPaneIds: ["pane.a"] })).toBe(
-      true,
-    );
-    await settle();
-    expect(client.adoptTerminalRuntimeInventory({ ...base, semanticPaneIds: ["pane.b"] })).toBe(
-      false,
-    );
-    await settle();
-    expect(inventories.map((inventory) => inventory.semanticPaneIds)).toEqual([["pane.a"]]);
-    expect(refreshes).toBe(1);
-    expect(client.adoptTerminalRuntimeInventory({ ...base, semanticPaneIds: ["pane.b"] })).toBe(
-      false,
-    );
-    expect(refreshes).toBe(1);
-    await client.dispose();
-  });
-
-  it("measures a burst of topology replacements without connecting obsolete inventories", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", []) });
-    const inventories: WorkspaceClientRuntimeInventory[] = [];
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      deferApplicationShell: true,
-      ports: {
-        shell: shell.transport,
-        actions,
-        connectRuntime: async (_current, inventory) => {
-          inventories.push(inventory);
-          return new FakeRuntime(ALPHA_DAEMON.instanceId);
-        },
-      },
-    });
-    const start = performance.now();
-    for (let revision = 1; revision <= 8; revision++)
-      client.adoptTerminalRuntimeInventory({
-        workspaceName: "alpha",
-        workspaceId: "workspace.alpha",
-        sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-        resourceRevision: revision,
-        semanticPaneIds: Array.from({ length: revision }, (_, i) => `pane.${i}`),
-      });
-    await settle();
-    console.log(
-      "REBIND_BURST",
-      JSON.stringify({
-        revisions: 8,
-        connections: inventories.length,
-        elapsedMs: performance.now() - start,
-      }),
-    );
-    expect(inventories.at(-1)?.semanticPaneIds).toHaveLength(8);
-    expect(inventories).toHaveLength(1);
-    await client.dispose();
-  });
-
-  it("treats empty inventory and same-name session replacement as terminal revisions", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", []) });
-    const inventories: WorkspaceClientRuntimeInventory[] = [];
-    let retirements = 0;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      deferApplicationShell: true,
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory) => {
-          inventories.push(inventory);
-          return new FakeRuntime(ALPHA_DAEMON.instanceId);
-        },
-        didRetireRuntime: () => {
-          retirements += 1;
-        },
-        actions,
-      },
-    });
-    const base = { workspaceName: "alpha", workspaceId: "workspace.alpha" };
-    client.adoptTerminalRuntimeInventory({
-      ...base,
-      sessionId: "session.aaaaaaaaaaaaaaaaaaaa",
-      resourceRevision: 1,
-      semanticPaneIds: ["pane.a"],
-    });
-    await settle();
-    client.adoptTerminalRuntimeInventory({
-      ...base,
-      sessionId: "session.bbbbbbbbbbbbbbbbbbbb",
-      resourceRevision: 2,
-      semanticPaneIds: ["pane.a"],
-    });
-    await settle();
-    expect(inventories.map(({ sessionId }) => sessionId)).toEqual([
-      "session.aaaaaaaaaaaaaaaaaaaa",
-      "session.bbbbbbbbbbbbbbbbbbbb",
-    ]);
-    client.adoptTerminalRuntimeInventory({
-      ...base,
-      sessionId: "session.bbbbbbbbbbbbbbbbbbbb",
-      resourceRevision: 3,
-      semanticPaneIds: [],
-    });
-    await settle();
-    expect(retirements).toBeGreaterThan(0);
-    await client.dispose();
-  });
-
-  it("waits for shell authority and connects with its exact immutable terminal inventory", async () => {
-    const shellAuthority = deferred<ApplicationShellProjectionInputV3>();
-    const shellConnections: ShellConnection[] = [];
-    const shellTransport: ApplicationShellTransport<ApplicationShellProjectionInputV3> = {
-      validateTarget: (value) => DesktopApplicationShellTargetSchemaZ.parse(value),
-      fetchApplicationShell: async () => shellAuthority.promise,
-      connectEvents: (current, handlers) => {
-        const connection = { target: current, handlers, closed: false };
-        shellConnections.push(connection);
-        return { close: () => (connection.closed = true) };
-      },
-    };
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const inventories: WorkspaceClientRuntimeInventory[] = [];
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shellTransport,
-        connectRuntime: async (_current, inventory) => {
-          inventories.push(inventory);
-          return runtime;
-        },
-        actions,
-      },
-    });
-
-    await settle();
-    expect(inventories).toHaveLength(0);
-    shellAuthority.resolve(shellResource("alpha", ["pane.z", "pane.a"]));
-    await settle();
-
-    expect(inventories).toHaveLength(1);
-    expect(inventories[0]).toEqual({
-      workspaceName: "alpha",
-      workspaceId: "workspace.alpha",
-      sessionId: COHESION_FIXTURE_V1.workspace.session.id,
-      daemonGeneration: ALPHA_DAEMON.instanceId,
-      shellGeneration: 1,
-      semanticPaneIds: ["pane.a", "pane.z"],
-    });
-    expect(Object.isFrozen(inventories[0])).toBe(true);
-    expect(Object.isFrozen(inventories[0]!.semanticPaneIds)).toBe(true);
-    client.dispose();
-    await settle();
-  });
-
-  it("primes every inventory pane before coherence and adopts the retained candidate bindings", async () => {
-    const paneIds = ["pane.window-a.one", "pane.window-a.two", "pane.window-b.hidden"];
-    const shell = shellBroker({ alpha: shellResource("alpha", paneIds) });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const coherent = deferred<void>();
-    const updates = new Map<string, TerminalReplicaUpdate<string, string>[]>();
-    let client!: WorkspaceClient<string, string>;
-    let prepared = false;
-    client = createWorkspaceClient<string, string>({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, _runtimeInventory, _signal, prepare) => {
-          await prepare(runtime);
-          prepared = true;
-          await coherent.promise;
-          return runtime;
-        },
-        actions,
-      },
-    });
-    const unsubscribes = paneIds.map((semanticPaneId) =>
-      client.subscribeTerminal({ workspaceName: "alpha", semanticPaneId }, (update) => {
-        const seen = updates.get(semanticPaneId) ?? [];
-        seen.push(update);
-        updates.set(semanticPaneId, seen);
-      }),
-    );
-
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(prepared).toBe(true);
-    expect([...runtime.subscriptions.keys()].sort()).toEqual(paneIds);
-
-    for (const semanticPaneId of paneIds) {
-      runtime.subscriptions
-        .get(semanticPaneId)!
-        .emit(terminalSeedFor(semanticPaneId, ALPHA_DAEMON.instanceId));
-    }
-    expect(updates.get("pane.window-b.hidden")).toBeUndefined();
-
-    coherent.resolve();
-    await settle();
-    expect(updates.get("pane.window-b.hidden")).toHaveLength(1);
-    expect(client.getSnapshot().authorityShell).not.toBeNull();
-    expect([...runtime.subscriptions.keys()].sort()).toEqual(paneIds);
-    expect(
-      [...runtime.subscriptions.values()].every((subscription) => subscription.closeCount === 0),
-    ).toBe(true);
-
-    for (const unsubscribe of unsubscribes) unsubscribe();
-    client.dispose();
-    await settle();
-    expect(
-      [...runtime.subscriptions.values()].every((subscription) => subscription.closeCount === 1),
-    ).toBe(true);
-  });
-
-  it("does not charge an eager canonical seed against the candidate update buffer", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.alpha"]) });
-    const runtime = new EagerSeedRuntime(ALPHA_DAEMON.instanceId, "x".repeat(8 * 1024 * 1024 + 1));
-    const publications: TerminalReplicaUpdate<string, string>[] = [];
-    const activations: FakeRuntime[] = [];
-    const client = createWorkspaceClient<string, string>({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, _inventory, _signal, prepare) => {
-          await prepare(runtime);
-          return runtime;
-        },
-        didActivateRuntime: (nextRuntime) => activations.push(nextRuntime as FakeRuntime),
-        actions,
-      },
-    });
-    client.subscribeTerminal({ workspaceName: "alpha", semanticPaneId: "pane.alpha" }, (update) =>
-      publications.push(update),
-    );
-
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-
-    expect(activations).toEqual([runtime]);
-    expect(publications).toHaveLength(1);
-    expect(publications[0]?.type).toBe("terminal.seed");
-    await client.dispose();
-  });
-
-  it("does not reconnect when a shell refresh leaves runtime inventory unchanged", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    let connects = 0;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => {
-          connects += 1;
-          return runtime;
-        },
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(connects).toBe(1);
-
-    shell.byWorkspace.set(
-      "alpha",
-      ApplicationShellProjectionInputV3SchemaZ.parse({
-        ...shellResource("alpha"),
-        project: { ...shellResource("alpha").project, rootLabel: "refreshed label" },
-      }),
-    );
-    shell.connections[0]!.handlers.onInvalidate();
-    await settle();
-    expect(connects).toBe(1);
-    expect(runtime.closeCount).toBe(0);
-    client.dispose();
-    await settle();
-  });
-
-  it("prepares a changed pane inventory and atomically swaps only after it is live", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.alpha"]) });
-    const first = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const second = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const next = deferred<FakeRuntime>();
-    const calls: WorkspaceClientRuntimeInventory[] = [];
-    const activated: FakeRuntime[] = [];
-    const activatedInventories: string[][] = [];
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory) => {
-          calls.push(inventory);
-          return calls.length === 1 ? first : next.promise;
-        },
-        didActivateRuntime: (runtime, inventory) => {
-          activated.push(runtime as FakeRuntime);
-          activatedInventories.push([...inventory.semanticPaneIds]);
-        },
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(calls).toHaveLength(1);
-    expect(activated).toEqual([first]);
-
-    shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.beta", "pane.alpha"]));
-    shell.connections[0]!.handlers.onInvalidate();
-    await settle();
-    expect(calls).toHaveLength(2);
-    expect(calls[1]!.semanticPaneIds).toEqual(["pane.alpha", "pane.beta"]);
-    expect(first.closeCount).toBe(0);
-    expect(activated).toEqual([first]);
-    expect(activatedInventories).toEqual([["pane.alpha"]]);
-    expect(
-      await client.sendTerminalInput(
-        { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-        { kind: "key", data: "Enter" },
-      ),
-    ).toBe("ok");
-    expect(first.inputs).toHaveLength(1);
-
-    next.resolve(second);
-    await settle();
-    expect(activated).toEqual([first, second]);
-    expect(activatedInventories).toEqual([["pane.alpha"], ["pane.alpha", "pane.beta"]]);
-    expect(first.closeCount).toBe(1);
-    expect(
-      await client.sendTerminalInput(
-        { workspaceName: "alpha", semanticPaneId: "pane.beta" },
-        { kind: "text", data: "ready" },
-      ),
-    ).toBe("ok");
-    expect(second.inputs).toHaveLength(1);
-    expect(calls).toHaveLength(2);
-    client.dispose();
-    await settle();
-  });
-
-  it("does not reconnect a closed incumbent after a replacement inventory is desired", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.alpha"]) });
-    const clock = new FakeClock();
-    const incumbent = new ClosableFakeRuntime(ALPHA_DAEMON.instanceId);
-    const replacement = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const replacementGate = deferred<FakeRuntime>();
-    const inventories: WorkspaceClientRuntimeInventory[] = [];
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      clock,
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory) => {
-          inventories.push(inventory);
-          return inventories.length === 1 ? incumbent : replacementGate.promise;
-        },
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(inventories).toHaveLength(1);
-
-    shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.alpha", "pane.beta"]));
-    shell.connections[0]!.handlers.onInvalidate();
-    await settle();
-    expect(inventories).toHaveLength(2);
-
-    incumbent.fail();
-    await settle();
-    clock.advance(30_000);
-    await settle();
-    expect(inventories).toHaveLength(2);
-    expect(clock.timers.size).toBe(0);
-
-    replacementGate.resolve(replacement);
-    await settle();
-    await client.dispose();
-  });
-
-  it("converges a rebound runtime select receipt with the invalidated active shell inventory", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.alpha"]) });
-    const first = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const second = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    let connections = 0;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => (++connections === 1 ? first : second),
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.alpha", "pane.beta"]));
-    shell.connections[0]!.handlers.onInvalidate();
-    await settle();
-    expect(connections).toBe(2);
-
-    const operationId = "13000000-0000-4000-8000-000000000013";
-    await client.dispatch({
-      kind: "semantic-intent",
-      operationId,
-      intent: {
-        verb: "workspace.pane.select",
-        workspaceName: "alpha",
-        semanticPaneId: "pane.beta",
-      },
-    });
-    second.emitReceipt({
-      ...receipt(operationId, "observed"),
-      target: { kind: "pane", semanticPaneId: "pane.beta" },
-      operationKind: "workspace.pane.select",
-      summary: { operationKind: "workspace.pane.select" },
-      proof: {
-        operationKind: "workspace.pane.select",
-        outcome: "applied",
-        semanticPaneId: "pane.beta",
-      },
-    });
-    const externalRenameId = "14000000-0000-4000-8000-000000000014";
-    shell.connections[0]!.handlers.onOperationAcknowledged?.({
-      daemonInstanceId: ALPHA_DAEMON.instanceId,
-      operationId: externalRenameId,
-      sequence: 10,
-      revision: 8,
-    });
-    shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.beta", "pane.alpha"]));
-    shell.connections[0]!.handlers.onInvalidate();
-    await settle();
-
-    const snapshot = client.getSnapshot();
-    expect(snapshot.operations.pending).toEqual([]);
-    expect(snapshot.operations.lastReceipt).toMatchObject({
-      operationId,
-      operationKind: "workspace.pane.select",
-      phase: "observed",
-      proof: { outcome: "applied", semanticPaneId: "pane.beta" },
-    });
-    expect(snapshot.operations.lastResourceChangeAcknowledgement).toEqual({
-      daemonInstanceId: ALPHA_DAEMON.instanceId,
-      operationId: externalRenameId,
-      sequence: 10,
-      revision: 8,
-    });
-    expect(snapshot.authorityShell?.terminalInventory?.activeResourceId).toBe("pane.beta");
-    expect(snapshot.semantic?.terminalInventory?.activeResourceId).toBe("pane.beta");
-    expect(connections).toBe(2);
-
-    const acknowledgementAfterRefreshId = "15000000-0000-4000-8000-000000000015";
-    const priorShell = shellResource("alpha", ["pane.beta", "pane.alpha"]);
-    const renamedShell = ApplicationShellProjectionInputV3SchemaZ.parse({
-      ...priorShell,
-      terminalInventory: {
-        ...priorShell.terminalInventory,
-        resources: priorShell.terminalInventory.resources.map((resource, index) =>
-          index === 0 ? { ...resource, title: "Lifecycle Renamed" } : resource,
-        ),
-      },
-    });
-    shell.byWorkspace.set("alpha", renamedShell);
-    shell.connections[0]!.handlers.onInvalidate();
-    await settle();
-    shell.connections[0]!.handlers.onOperationAcknowledged?.({
-      daemonInstanceId: ALPHA_DAEMON.instanceId,
-      operationId: acknowledgementAfterRefreshId,
-      sequence: 11,
-      revision: 8,
-    });
-    expect(connections).toBe(2);
-    expect(client.getSnapshot().semantic?.terminalInventory?.resources[0]?.title).toBe(
-      "Lifecycle Renamed",
-    );
-    expect(client.getSnapshot().operations.lastResourceChangeAcknowledgement).toEqual({
-      daemonInstanceId: ALPHA_DAEMON.instanceId,
-      operationId: acknowledgementAfterRefreshId,
-      sequence: 11,
-      revision: 8,
-    });
-    second.emitReceipt({
-      ...receipt(externalRenameId, "observed"),
-      operationKind: "workspace.rename",
-      summary: { operationKind: "workspace.rename", scope: "window" },
-      target: { kind: "window", target: { by: "pane", semanticPaneId: "pane.beta" } },
-      proof: { operationKind: "workspace.rename", outcome: "applied", scope: "window" },
-    });
-    expect(client.getSnapshot().operations.lastReceipt?.operationId).toBe(operationId);
-    client.dispose();
-    await settle();
-  });
-
-  it("fences resource-change acknowledgements by generation and monotonic sequence", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (current) => new FakeRuntime(current.daemon.instanceId),
-        actions,
-      },
-    });
-    const retiredHandlers = shell.connections[0]!.handlers;
-    retiredHandlers.onVerifiedOpen();
-    await settle();
-    await client.setTarget(target("beta", ALPHA_DAEMON));
-    const activeHandlers = shell.connections.findLast(
-      (connection) => connection.target.workspaceName === "beta" && !connection.closed,
-    )!.handlers;
-    activeHandlers.onVerifiedOpen();
-    await settle();
-
-    retiredHandlers.onOperationAcknowledged?.({
-      daemonInstanceId: ALPHA_DAEMON.instanceId,
-      operationId: "16000000-0000-4000-8000-000000000016",
-      sequence: 20,
-      revision: 9,
-    });
-    expect(client.getSnapshot().operations.lastResourceChangeAcknowledgement).toBeNull();
-    activeHandlers.onOperationAcknowledged?.({
-      daemonInstanceId: ALPHA_DAEMON.instanceId,
-      operationId: "17000000-0000-4000-8000-000000000017",
-      sequence: 21,
-      revision: 10,
-    });
-    const accepted = client.getSnapshot().operations.lastResourceChangeAcknowledgement;
-    expect(accepted).toEqual({
-      daemonInstanceId: ALPHA_DAEMON.instanceId,
-      operationId: "17000000-0000-4000-8000-000000000017",
-      sequence: 21,
-      revision: 10,
-    });
-    for (const acknowledgement of [
-      {
-        daemonInstanceId: ALPHA_DAEMON.instanceId,
-        operationId: "18000000-0000-4000-8000-000000000018",
-        sequence: 20,
-        revision: 11,
-      },
-      {
-        daemonInstanceId: BETA_DAEMON.instanceId,
-        operationId: "18000000-0000-4000-8000-000000000018",
-        sequence: 22,
-        revision: 11,
-      },
-      {
-        daemonInstanceId: ALPHA_DAEMON.instanceId,
-        operationId: "NOT-A-MINTED-OPERATION",
-        sequence: 22,
-        revision: 11,
-      },
-    ])
-      activeHandlers.onOperationAcknowledged?.(acknowledgement);
-    expect(client.getSnapshot().operations.lastResourceChangeAcknowledgement).toBe(accepted);
-    client.dispose();
-    await settle();
-  });
-
-  it("carries a supervised application-shell acknowledgement into WorkspaceClient before refresh", async () => {
-    const socket = new WorkspaceClientEventSocket();
-    const initialShell = shellResource("alpha", ["pane.alpha"]);
-    let currentShell = ApplicationShellProjectionInputV3SchemaZ.parse({
-      ...initialShell,
-      workspace: {
-        ...initialShell.workspace,
-        id: "workspace.0123456789abcdefabcd",
-        session: {
-          ...initialShell.workspace.session,
-          id: "session.0123456789abcdefabcd",
-        },
-      },
-    });
-    const transport = createDirectLoopbackDaemonTransport({
-      descriptor: { ...ALPHA_DAEMON, apiBaseUrl: "http://127.0.0.1:6060/" },
-      resolveSessionName: () => "alpha",
-      terminalRuntimeAuthority: true,
-      applicationShellResourceVersion: APPLICATION_SHELL_RESOURCE_V3_VERSION,
-      createWebSocket: () => socket,
-      fetch: async (input) => {
-        const url = new URL(String(input));
-        if (url.pathname.endsWith("/terminal-runtime-inventory")) {
-          return new Response(
-            JSON.stringify({
-              version: 1,
-              daemon: ALPHA_DAEMON,
-              resource: {
-                workspaceName: "alpha",
-                workspaceId: currentShell.workspace.id,
-                sessionId: currentShell.workspace.session.id,
-                resourceRevision: 7,
-                semanticPaneIds: ["pane.alpha"],
-              },
-            }),
-            { status: 200, headers: { "content-type": "application/json" } },
-          );
-        }
-        return new Response(
-          JSON.stringify({
-            version: APPLICATION_SHELL_RESOURCE_V3_VERSION,
-            daemon: ALPHA_DAEMON,
-            resource: currentShell,
-          }),
-          { status: 200, headers: { "content-type": "application/json" } },
-        );
-      },
-    }) as TerminalFirstDaemonTransport;
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      deferApplicationShell: true,
-      ports: { shell: transport, connectRuntime: async () => runtime, actions },
-    });
-    const preparation = transport.prepareTerminalRuntimeInventory(
-      target("alpha"),
-      new AbortController().signal,
-    );
-    socket.emit("open");
-    socket.frame({ type: "hello", daemon: ALPHA_DAEMON, sessions: [], eventSequence: 0 });
-    await settle();
-    socket.frame({
-      type: "resource.interests-ack",
-      interestRevision: 1,
-      sequence: 0,
-      unavailableInterests: [],
-    });
-    const prepared = await preparation;
-    const terminalAuthority = transport.adoptTerminalRuntimeInventory(prepared, (resource) => {
-      client.adoptTerminalRuntimeInventory(resource);
-    });
-    expect(terminalAuthority).not.toBeNull();
-    client.adoptTerminalRuntimeInventory(terminalAuthority!);
-    await settle();
-    expect(socket.sent[1]).toMatchObject({
-      type: "subscribe",
-      interestRevision: 2,
-      interests: [{ resource: "terminal-runtime-inventory" }, { resource: "application-shell" }],
-    });
-    socket.frame({
-      type: "resource.interests-ack",
-      interestRevision: 2,
-      sequence: 0,
-      unavailableInterests: [],
-    });
-    await settle();
-    expect(client.getSnapshot().phase).toBe("live");
-
-    const renamedShell = ApplicationShellProjectionInputV3SchemaZ.parse({
-      ...currentShell,
-      terminalInventory: {
-        ...currentShell.terminalInventory,
-        resources: currentShell.terminalInventory.resources.map((resource) => ({
-          ...resource,
-          title: "Lifecycle Renamed",
-        })),
-      },
-    });
-    currentShell = renamedShell;
-    const operationId = "19000000-0000-4000-8000-000000000019";
-    socket.frame({
-      type: "resource.changed",
-      sequence: 1,
-      workspaceName: "alpha",
-      resource: "application-shell",
-      revision: 8,
-      causeOperationId: operationId,
-    });
-    expect(client.getSnapshot().operations.lastResourceChangeAcknowledgement).toEqual({
-      daemonInstanceId: ALPHA_DAEMON.instanceId,
-      operationId,
-      sequence: 1,
-      revision: 8,
-    });
-    expect(client.getSnapshot().semantic?.terminalInventory?.resources[0]?.title).toBe(
-      "Terminal 1",
-    );
-    await settle();
-    expect(client.getSnapshot().semantic?.terminalInventory?.resources[0]?.title).toBe(
-      "Lifecycle Renamed",
-    );
-    expect(client.getSnapshot().operations.lastReceipt).toBeNull();
-    await client.dispose();
-    transport.disposeEventSupervisor();
-  });
-
-  it("suspends only the exact active runtime while its supervisor reconnects", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const first = new ClosableFakeRuntime(ALPHA_DAEMON.instanceId);
-    const replacement = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const suspended: FakeRuntime[] = [];
-    let connects = 0;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => (++connects === 1 ? first : replacement),
-        didSuspendRuntime: (runtime) => suspended.push(runtime as FakeRuntime),
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(client.ownsRuntimeAuthority("input")).toBe(false);
-
-    first.fail();
-    await settle();
-    expect(suspended).toEqual([first]);
-    expect(connects).toBe(1);
-    expect(await client.requestAuthority("input")).toBeNull();
-    expect(replacement.closeCount).toBe(0);
-
-    await client.dispose();
-  });
-
-  it("isolates overlapping candidate preparation and publishes only the winning runtime", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.alpha"]) });
-    const active = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const candidateB = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const candidateC = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const coherentB = deferred<void>();
-    const coherentC = deferred<void>();
-    const preparedB = deferred<void>();
-    const preparedC = deferred<void>();
-    const publications: string[] = [];
-    const activated: FakeRuntime[] = [];
-    const client = createWorkspaceClient<string, string>({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory, _signal, prepare) => {
-          if (inventory.semanticPaneIds.includes("pane.b")) {
-            await prepare(candidateB);
-            preparedB.resolve();
-            await coherentB.promise;
-            return candidateB;
-          }
-          if (inventory.semanticPaneIds.includes("pane.c")) {
-            await prepare(candidateC);
-            preparedC.resolve();
-            await coherentC.promise;
-            return candidateC;
-          }
-          return active;
-        },
-        didActivateRuntime: (runtime) => activated.push(runtime as FakeRuntime),
-        actions,
-      },
-    });
-    client.subscribeTerminal({ workspaceName: "alpha", semanticPaneId: "pane.alpha" }, (update) =>
-      publications.push(update.snapshot ?? update.patch ?? "tombstone"),
-    );
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(activated).toEqual([active]);
-    const activeSubscription = active.subscriptions.get("pane.alpha")!;
-    const activeClose = deferred<void>();
-    activeSubscription.closeGate = activeClose.promise;
-
-    shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.alpha", "pane.b"]));
-    shell.connections[0]!.handlers.onInvalidate();
-    await preparedB.promise;
-    candidateB.subscriptions
-      .get("pane.alpha")!
-      .emit({ ...terminalSeed(ALPHA_DAEMON.instanceId), snapshot: "candidate-b" });
-    expect(publications).toEqual([]);
-
-    shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.alpha", "pane.c"]));
-    shell.connections[0]!.handlers.onInvalidate();
-    await preparedC.promise;
-    candidateC.subscriptions
-      .get("pane.alpha")!
-      .emit({ ...terminalSeed(ALPHA_DAEMON.instanceId), snapshot: "candidate-c" });
-    expect(publications).toEqual([]);
-
-    coherentC.resolve();
-    await settle();
-    expect(activated).toEqual([active, candidateC]);
-    expect(publications).toEqual(["candidate-c"]);
-    expect(candidateB.subscriptions.get("pane.alpha")!.closeCount).toBe(1);
-    expect(activeSubscription.closeCount).toBe(1);
-    expect(activeSubscription.listeners.size).toBe(0);
-    activeSubscription.emit({
-      ...terminalSeed(ALPHA_DAEMON.instanceId),
-      snapshot: "retired-active",
-    });
-    expect(publications).toEqual(["candidate-c"]);
-    candidateC.subscriptions.get("pane.alpha")!.emit({
-      ...terminalSeed(ALPHA_DAEMON.instanceId),
-      snapshot: "candidate-c-live",
-    });
-    expect(publications).toEqual(["candidate-c", "candidate-c-live"]);
-    activeClose.resolve();
-
-    coherentB.resolve();
-    await settle();
-    expect(activated).toEqual([active, candidateC]);
-    expect(publications).toEqual(["candidate-c", "candidate-c-live"]);
-    expect(candidateB.closeCount).toBe(1);
-    await client.dispose();
-  });
-
-  it("stages the production fast-lane inventory before candidate coherence without trimming the incumbent", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.alpha"]) });
-    const active = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const candidate = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const candidateCoherent = deferred<void>();
-    const candidatePrepared = deferred<void>();
-    const staged = new WeakMap<FakeRuntime, () => void>();
-    let lane!: TerminalFastLane;
-    let client!: ReturnType<typeof createWorkspaceClient<string, string>>;
-    client = createWorkspaceClient<string, string>({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory, _signal, prepare) => {
-          const runtime = inventory.semanticPaneIds.includes("pane.beta") ? candidate : active;
-          const release = lane.stagePanes(inventory.semanticPaneIds);
-          await prepare(runtime);
-          staged.set(runtime, release);
-          if (runtime === candidate) {
-            candidatePrepared.resolve();
-            await candidateCoherent.promise;
-          }
-          return runtime;
-        },
-        didActivateRuntime: (runtime, inventory) => {
-          lane.retainPanes(inventory.semanticPaneIds);
-          const release = staged.get(runtime as FakeRuntime);
-          staged.delete(runtime as FakeRuntime);
-          release?.();
-        },
-        actions,
-      },
-    });
-    lane = createTerminalFastLane({
-      address: { workspaceName: "alpha", generation: ALPHA_DAEMON.instanceId },
-      source: createWorkspaceClientTerminalSource(client as never),
-      repair: { request: () => undefined },
-      control: {
-        owns: () => true,
-        request: async () => true,
-        write: async () => "ok",
-        resize: async () => "ok",
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(active.subscriptions.has("pane.alpha")).toBe(true);
-
-    shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.alpha", "pane.beta"]));
-    shell.connections[0]!.handlers.onInvalidate();
-    await candidatePrepared.promise;
-    // This is the production-order proof: prepare() saw the new fast-lane
-    // interest, while the incumbent remained subscribed and paint-capable.
-    expect(candidate.subscriptions.has("pane.alpha")).toBe(true);
-    expect(candidate.subscriptions.has("pane.beta")).toBe(true);
-    expect(active.subscriptions.get("pane.alpha")?.listeners.size).toBe(1);
-
-    candidateCoherent.resolve();
-    await settle();
-    expect(active.subscriptions.get("pane.alpha")?.listeners.size).toBe(0);
-    expect(candidate.subscriptions.get("pane.alpha")?.listeners.size).toBe(1);
-    expect(candidate.subscriptions.get("pane.beta")?.listeners.size).toBe(1);
-    lane.dispose();
-    await client.dispose();
-  });
-
-  it("retires a flooded candidate without dropping, reordering, or publishing partial state", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha", ["pane.alpha"]) });
-    const active = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const flooded = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const prepared = deferred<void>();
-    const coherent = deferred<void>();
-    const publications: string[] = [];
-    const activated: FakeRuntime[] = [];
-    const client = createWorkspaceClient<string, string>({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_current, inventory, _signal, prepare) => {
-          if (!inventory.semanticPaneIds.includes("pane.flood")) return active;
-          await prepare(flooded);
-          prepared.resolve();
-          await coherent.promise;
-          return flooded;
-        },
-        didActivateRuntime: (runtime) => activated.push(runtime as FakeRuntime),
-        actions,
-      },
-    });
-    client.subscribeTerminal({ workspaceName: "alpha", semanticPaneId: "pane.alpha" }, (update) =>
-      publications.push(update.snapshot ?? update.patch ?? "tombstone"),
-    );
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(activated).toEqual([active]);
-
-    shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.alpha", "pane.flood"]));
-    shell.connections[0]!.handlers.onInvalidate();
-    await prepared.promise;
-    const subscription = flooded.subscriptions.get("pane.alpha")!;
-    for (let index = 0; index <= 256; index += 1) {
-      subscription.emit({
-        ...terminalSeed(ALPHA_DAEMON.instanceId),
-        snapshot: `flood-${index}`,
-      });
-    }
-    await settle();
-    expect(publications).toEqual([]);
-    expect(activated).toEqual([active]);
-    expect(subscription.closeCount).toBe(1);
-    expect(subscription.listeners.size).toBe(0);
-
-    coherent.resolve();
-    await settle();
-    expect(flooded.closeCount).toBe(1);
-    expect(activated).toEqual([active]);
-    expect(
-      await client.sendTerminalInput(
-        { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-        { kind: "text", data: "incumbent-still-live" },
-      ),
-    ).toBe("ok");
-    expect(active.inputs).toHaveLength(1);
-    await client.dispose();
-  });
-
-  it("retires the runtime cleanly when authority publishes an empty inventory", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    let connects = 0;
-    let retirements = 0;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => {
-          connects += 1;
-          return runtime;
-        },
-        didRetireRuntime: () => {
-          retirements += 1;
-        },
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    shell.byWorkspace.set("alpha", shellResource("alpha", []));
-    shell.connections[0]!.handlers.onInvalidate();
-    await settle();
-
-    expect(connects).toBe(1);
-    expect(runtime.closeCount).toBe(1);
-    expect(retirements).toBe(1);
-    expect(
-      await client.sendTerminalInput(
-        { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-        { kind: "key", data: "Enter" },
-      ),
-    ).toBe("authority-lost");
-    client.dispose();
-    await settle();
-  });
-
-  it("fences a late runtime candidate after target replacement", async () => {
-    const shell = shellBroker({
-      alpha: shellResource("alpha"),
-      beta: shellResource("beta"),
-    });
-    const alpha = deferred<FakeRuntime>();
-    const staleAlpha = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const beta = new FakeRuntime(BETA_DAEMON.instanceId);
-    const calls: string[] = [];
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (current) => {
-          calls.push(current.workspaceName);
-          return current.workspaceName === "alpha" ? alpha.promise : beta;
-        },
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(calls).toEqual(["alpha"]);
-
-    client.setTarget(target("beta", BETA_DAEMON));
-    alpha.resolve(staleAlpha);
-    shell.connections[1]!.handlers.onVerifiedOpen();
-    await settle();
-
-    expect(calls).toEqual(["alpha", "beta"]);
-    expect(staleAlpha.closeCount).toBe(1);
-    expect(
-      await client.sendTerminalInput(
-        { workspaceName: "beta", semanticPaneId: "pane.beta" },
-        { kind: "key", data: "Enter" },
-      ),
-    ).toBe("ok");
-    expect(beta.inputs).toHaveLength(1);
-    client.dispose();
-    await settle();
-  });
-
-  it("ignores a delayed catalog read from a retired target generation", async () => {
-    const alphaCatalog = deferred<ReturnType<typeof workspaceCatalog>>();
-    const betaCatalog = deferred<ReturnType<typeof workspaceCatalog>>();
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        catalog: {
-          read: (current) =>
-            current.workspaceName === "alpha" ? alphaCatalog.promise : betaCatalog.promise,
-          subscribe: () => ({ close: () => undefined }),
-        },
-        connectRuntime: async (current) => new FakeRuntime(current.daemon.instanceId),
-        actions,
-      },
-    });
-    await settle();
-    const replacing = client.setTarget(target("beta", BETA_DAEMON));
-    await settle();
-    alphaCatalog.resolve(workspaceCatalog("alpha"));
-    betaCatalog.resolve(workspaceCatalog("beta", BETA_DAEMON));
-    await replacing;
-    await settle();
-    expect(client.getSnapshot().catalog).toMatchObject({
-      daemonInstanceId: BETA_DAEMON.instanceId,
-      intents: [{ workspaceName: "beta" }],
-      liveSessions: [{ sessionName: "beta" }],
-    });
-    await client.dispose();
-  });
-
-  it("settles target replacement even when the retired connect adapter never resolves", async () => {
-    const shell = shellBroker({
-      alpha: shellResource("alpha"),
-      beta: shellResource("beta"),
-    });
-    const never = new Promise<FakeRuntime>(() => undefined);
-    const beta = new FakeRuntime(BETA_DAEMON.instanceId);
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: (current) =>
-          current.workspaceName === "alpha" ? never : Promise.resolve(beta),
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-
-    await client.setTarget(target("beta", BETA_DAEMON));
-    shell.connections[1]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(client.getSnapshot().target?.workspaceName).toBe("beta");
-    await client.dispose();
-  });
-
-  it("fences terminal repair to the active daemon generation", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: { shell: shell.transport, connectRuntime: async () => runtime, actions },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    const pane = { workspaceName: "alpha", semanticPaneId: "pane.alpha" };
-
-    client.requestTerminalRepair(pane, BETA_DAEMON.instanceId, "conflict");
-    client.requestTerminalRepair(pane, ALPHA_DAEMON.instanceId, "conflict");
-    expect(runtime.repairRequests).toEqual([{ target: pane, reason: "conflict" }]);
-    await client.dispose();
-  });
-
-  it("produces byte-identical semantic traces for core, OpenTUI, Web, and SDK adapters", async () => {
-    const labels = ["core", "opentui", "web", "sdk"] as const;
-    const clients = labels.map((surface) => {
-      const shell = shellBroker({ alpha: shellResource("alpha") });
-      const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-      const clock = new FakeClock();
-      const client = createWorkspaceClient({
-        target: target("alpha"),
-        ports: {
-          shell: shell.transport,
-          connectRuntime: async () => runtime,
-          actions,
-        },
-        clock,
-        operationId: () => "10000000-0000-4000-8000-000000000001",
-      });
-      shell.connections[0]!.handlers.onVerifiedOpen();
-      return {
-        client,
-        shell,
-        runtime,
-        adapter: createWorkspaceClientConformanceAdapter(surface, client),
-      };
-    });
-    await settle();
-    const liveTraceHashes = clients.map(({ adapter }) => adapter.traceHash());
-    expect(new Set(liveTraceHashes).size).toBe(1);
-
-    const invocation = applicationShellCommandInvocation(
-      APPLICATION_SHELL_COMMAND_IDS.activateMode,
-      { mode: "home" },
-      { kind: "program", surface: "workspace-client-conformance" },
-    );
-    for (const { client } of clients) {
-      await client.dispatch({ kind: "application-shell", invocation });
-    }
-    const localProjectionTraceHashes = clients.map(({ adapter }) => adapter.traceHash());
-    expect(new Set(localProjectionTraceHashes).size).toBe(1);
-
-    const operationId = "10000000-0000-4000-8000-000000000001";
-    for (const { client } of clients) {
-      await client.dispatch({
-        kind: "semantic-intent",
-        operationId,
-        intent: {
-          verb: "workspace.pane.read",
-          workspaceName: "alpha",
-          semanticPaneId: "pane.alpha",
-          origin: "sdk",
-        },
-      });
-    }
-    for (const { runtime } of clients) {
-      runtime.emitReceipt(receipt(operationId, "accepted"));
-      runtime.emitReceipt(receipt(operationId, "observed"));
-    }
-    const receiptTraceHashes = clients.map(({ adapter }) => adapter.traceHash());
-    expect(new Set(receiptTraceHashes).size).toBe(1);
-
-    const beforeTerminal = clients.map(({ adapter }) => adapter.traceHash());
-    for (const { client, runtime } of clients) {
-      client.subscribeTerminal(
-        { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-        () => undefined,
-      );
-      await settle();
-      runtime.subscriptions.get("pane.alpha")!.emit(terminalSeed(ALPHA_DAEMON.instanceId));
-    }
-    expect(clients.map(({ adapter }) => adapter.traceHash())).toEqual(beforeTerminal);
-
-    const bytes = clients.map(({ adapter }) => adapter.semanticBytes());
-    const hashes = clients.map(({ adapter }) => adapter.semanticHash());
-    expect(new Set(bytes).size).toBe(1);
-    expect(new Set(hashes).size).toBe(1);
-    expect(clients[0]!.client.getSnapshot().authorityShell?.appWindows.revision).toBe(7);
-    for (const { adapter, client } of clients) {
-      adapter.dispose();
-      client.dispose();
-    }
-  });
-
-  it("fences stale target work, terminal frames, receipts, and timers", async () => {
-    const clock = new FakeClock();
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    let resolveAlpha!: (runtime: FakeRuntime) => void;
-    const alphaRuntimePromise = new Promise<FakeRuntime>((resolve) => (resolveAlpha = resolve));
-    const betaRuntime = new FakeRuntime(BETA_DAEMON.instanceId);
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: (current) =>
-          current.workspaceName === "alpha" ? alphaRuntimePromise : Promise.resolve(betaRuntime),
-        actions,
-      },
-      clock,
-      operationTimeoutMs: 50,
-    });
-    const generations: number[] = [];
-    client.subscribe("lifecycle", ({ generation }) => generations.push(generation));
-    const staleAlphaRuntime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    client.setTarget(target("beta", BETA_DAEMON));
-    client.setTarget(target("beta", BETA_DAEMON));
-    resolveAlpha(staleAlphaRuntime);
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    shell.connections[0]!.handlers.onInvalidate();
-    await settle();
-
-    expect(client.getSnapshot()).toMatchObject({
-      generation: 2,
-      target: { workspaceName: "beta" },
-    });
-    expect(Math.max(...generations)).toBe(2);
-    // Inventory authority never arrived for alpha, so no speculative runtime was opened.
-    expect(staleAlphaRuntime.closeCount).toBe(0);
-    expect(client.getSnapshot().authorityShell?.project.name).toBe("beta");
-    clock.advance(10_000);
-    expect(client.getSnapshot().generation).toBe(2);
-    client.dispose();
-  });
-
-  it("routes canonical terminal input through one runtime and fences late generation acks", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const alphaRuntime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const betaRuntime = new FakeRuntime(BETA_DAEMON.instanceId);
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (current) =>
-          current.workspaceName === "alpha" ? alphaRuntime : betaRuntime,
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-
-    expect(
-      await Promise.all([
-        client.sendTerminalInput(
-          { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-          { kind: "text", data: "hello" },
-        ),
-        client.sendTerminalInput(
-          { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-          { kind: "key", data: "Enter" },
-        ),
-      ]),
-    ).toEqual(["ok", "ok"]);
-    expect(alphaRuntime.inputs.map(({ input }) => input)).toEqual([
-      { kind: "text", data: "hello" },
-      { kind: "key", data: "Enter" },
-    ]);
-
-    const lateAck = deferred<void>();
-    alphaRuntime.inputGate = lateAck.promise;
-    const stale = client.sendTerminalInput(
-      { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-      { kind: "key", data: "C-c" },
-    );
-    client.setTarget(target("beta", BETA_DAEMON));
-    lateAck.resolve();
-    expect(await stale).toBe("authority-lost");
-    expect(
-      await client.sendTerminalInput(
-        { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-        { kind: "key", data: "Up" },
-      ),
-    ).toBe("authority-lost");
-    client.dispose();
-  });
-
-  it("fits the shared runtime viewport and fences a late retired generation", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const alphaRuntime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const betaRuntime = new FakeRuntime(BETA_DAEMON.instanceId);
-    const lateFit = deferred<void>();
-    alphaRuntime.viewportGate = lateFit.promise;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (current) =>
-          current.workspaceName === "alpha" ? alphaRuntime : betaRuntime,
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-
-    const retiredFit = client.fitViewport(132, 44);
-    client.setTarget(target("beta", BETA_DAEMON));
-    lateFit.resolve();
-    shell.connections[1]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(await retiredFit).toBe("authority-lost");
-    expect(alphaRuntime.viewportFits).toEqual([{ cols: 132, rows: 44 }]);
-    expect(await client.fitViewport(100, 30)).toBe("ok");
-    expect(betaRuntime.viewportFits).toEqual([{ cols: 100, rows: 30 }]);
-    client.dispose();
-    await settle();
-  });
-
-  it("preserves a scoped window target and fences its retired generation", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const alphaRuntime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const betaRuntime = new FakeRuntime(BETA_DAEMON.instanceId);
-    const lateFit = deferred<void>();
-    alphaRuntime.viewportGate = lateFit.promise;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (current) =>
-          current.workspaceName === "alpha" ? alphaRuntime : betaRuntime,
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-
-    const retiredFit = client.fitViewport(132, 44, "window.alpha");
-    client.setTarget(target("beta", BETA_DAEMON));
-    lateFit.resolve();
-    shell.connections[1]!.handlers.onVerifiedOpen();
-    await settle();
-    expect(await retiredFit).toBe("authority-lost");
-    expect(alphaRuntime.viewportFits).toEqual([
-      { cols: 132, rows: 44, semanticWindowId: "window.alpha" },
-    ]);
-    expect(await client.fitViewport(100, 30)).toBe("ok");
-    expect(betaRuntime.viewportFits).toEqual([{ cols: 100, rows: 30 }]);
-    client.dispose();
-    await settle();
-  });
-
-  it("preserves an exact geometry-authority conflict from the current runtime", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    runtime.viewportResult = "geometry-authority-conflict";
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: { shell: shell.transport, connectRuntime: async () => runtime, actions },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-
-    expect(await client.fitViewport(140, 46)).toBe("geometry-authority-conflict");
-    expect(runtime.viewportFits).toEqual([{ cols: 140, rows: 46 }]);
-    client.dispose();
-    await settle();
-  });
-
-  it("rejects an authority grant that settles after its exact runtime was replaced", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const alphaRuntime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const betaRuntime = new FakeRuntime(BETA_DAEMON.instanceId);
-    const lateAuthority = deferred<void>();
-    alphaRuntime.authorityGate = lateAuthority.promise;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (current) =>
-          current.workspaceName === "alpha" ? alphaRuntime : betaRuntime,
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-
-    const staleGrant = client.requestAuthority("input");
-    client.setTarget(target("beta", BETA_DAEMON));
-    shell.connections[1]!.handlers.onVerifiedOpen();
-    await settle();
-    lateAuthority.resolve();
-    await expect(staleGrant).resolves.toBeNull();
-    await expect(client.requestAuthority("input")).resolves.toMatchObject({
-      generation: BETA_DAEMON.instanceId,
-      authority: "input",
-    });
-    client.dispose();
-    await settle();
-  });
-
-  it("delivers external receipt observations to independent clients without creating local operations", async () => {
-    const clients = [];
-    for (let index = 0; index < 2; index++) {
-      const shell = shellBroker({ alpha: shellResource("alpha") });
-      const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-      const client = createWorkspaceClient({
-        target: target("alpha"),
-        ports: { shell: shell.transport, connectRuntime: async () => runtime, actions },
-      });
-      shell.connections[0]!.handlers.onVerifiedOpen();
-      await settle();
-      clients.push({ client, runtime });
-    }
-    const external = {
-      ...receipt("15000000-0000-4000-8000-000000000015", "observed"),
-      origin: "external" as const,
-    };
-    for (const { client, runtime } of clients) {
-      let publications = 0;
-      client.subscribe("operations", () => publications++);
-      runtime.emitReceipt(external);
-      const observed = publications;
-      runtime.emitReceipt(external);
-      expect(publications).toBe(observed);
-      expect(client.getSnapshot().operations).toMatchObject({
-        lastObservedReceipt: external,
-        pending: [],
-        lastReceipt: null,
-      });
-      client.dispose();
-    }
-    await settle();
-  });
-
-  it("settles duplicate and reordered receipts once without waking semantic subscribers", async () => {
-    const clock = new FakeClock();
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const operationId = "10000000-0000-4000-8000-000000000001";
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: { shell: shell.transport, connectRuntime: async () => runtime, actions },
-      clock,
-      operationId: () => operationId,
-      operationTimeoutMs: 50,
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    let semanticPublications = 0;
-    let operationPublications = 0;
-    client.subscribe("semantic", () => (semanticPublications += 1));
-    client.subscribe("operations", () => (operationPublications += 1));
-    const baselineSemantic = semanticPublications;
-    await client.dispatch({
-      kind: "semantic-intent",
-      operationId,
-      intent: {
-        verb: "workspace.pane.read",
-        workspaceName: "alpha",
-        semanticPaneId: "pane.alpha",
-        origin: "sdk",
-      },
-    });
-    runtime.emitReceipt(receipt(operationId, "accepted"));
-    runtime.emitReceipt(receipt(operationId, "accepted"));
-    runtime.emitReceipt(receipt(operationId, "observed"));
-    runtime.emitReceipt(receipt(operationId, "observed"));
-    const afterTerminal = operationPublications;
-    clock.advance(1_000);
-
-    expect(client.getSnapshot().operations.pending).toEqual([]);
-    expect(client.getSnapshot().operations.terminalOperationIds).toEqual([operationId]);
-    expect(operationPublications).toBe(afterTerminal);
-    expect(semanticPublications).toBe(baselineSemantic);
-    client.dispose();
-    client.dispose();
-    await settle();
-    expect(runtime.closeCount).toBe(1);
-  });
-
-  it("rejects pending and terminal duplicate operation ids before semantic transport", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const operationId = "11000000-0000-4000-8000-000000000011";
-    let resolveSubmit!: () => void;
-    const submitCompletion = new Promise<void>((resolve) => (resolveSubmit = resolve));
-    runtime.submitIntent = async () => {
-      runtime.submitCount += 1;
-      await submitCompletion;
-    };
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: { shell: shell.transport, connectRuntime: async () => runtime, actions },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    const command = {
-      kind: "semantic-intent" as const,
-      operationId,
-      intent: {
-        verb: "workspace.pane.read" as const,
-        workspaceName: "alpha",
-        semanticPaneId: "pane.alpha",
-        origin: "sdk" as const,
-      },
-    };
-
-    const first = client.dispatch(command);
-    await settle();
-    await expect(client.dispatch(command)).rejects.toThrow("already pending or terminal");
-    expect(runtime.submitCount).toBe(1);
-    resolveSubmit();
-    await first;
-    runtime.emitReceipt(receipt(operationId, "observed"));
-    await expect(client.dispatch(command)).rejects.toThrow("already pending or terminal");
-    expect(runtime.submitCount).toBe(1);
-    client.dispose();
-    await settle();
-  });
-
-  it("rejects pending and terminal duplicate operation ids before owner transport", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const operationId = "12000000-0000-4000-8000-000000000012";
-    let resolveOwner!: (value: null) => void;
-    const ownerCompletion = new Promise<null>((resolve) => (resolveOwner = resolve));
-    let ownerSubmitCount = 0;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => runtime,
-        actions: {
-          async dispatch() {
-            ownerSubmitCount += 1;
-            return ownerCompletion;
-          },
-        },
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    const command = {
-      kind: "owner-action" as const,
-      operationId,
-      name: "workspace.pane.select" as const,
-      input: { semanticPaneId: "pane.alpha" },
-    };
-
-    const first = client.dispatch(command);
-    await settle();
-    await expect(client.dispatch(command)).rejects.toThrow("already pending or terminal");
-    expect(ownerSubmitCount).toBe(1);
-    resolveOwner(null);
-    await first;
-    await expect(client.dispatch(command)).rejects.toThrow("already pending or terminal");
-    expect(ownerSubmitCount).toBe(1);
-    client.dispose();
-    await settle();
-  });
-
-  it("retires pane publications, receipts, and operation timers with a target generation", async () => {
-    const timerBaseline = runtimeResourceSnapshot()["runtime-timer"].active;
-    const clock = new FakeClock();
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const alphaRuntime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const betaRuntime = new FakeRuntime(BETA_DAEMON.instanceId);
-    const operationId = "10000000-0000-4000-8000-000000000001";
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (current) =>
-          current.workspaceName === "alpha" ? alphaRuntime : betaRuntime,
-        actions,
-      },
-      clock,
-      operationTimeoutMs: 50,
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    let terminalWakeups = 0;
-    client.subscribeTerminal(
-      { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-      () => (terminalWakeups += 1),
-    );
-    await settle();
-    await client.dispatch({
-      kind: "semantic-intent",
-      operationId,
-      intent: {
-        verb: "workspace.pane.read",
-        workspaceName: "alpha",
-        semanticPaneId: "pane.alpha",
-        origin: "sdk",
-      },
-    });
-    const retiredSubscription = alphaRuntime.subscriptions.get("pane.alpha")!;
-    expect(runtimeResourceSnapshot()["runtime-timer"].active).toBeGreaterThan(timerBaseline);
-
-    client.setTarget(target("beta", BETA_DAEMON));
-    retiredSubscription.emit(terminalSeed(ALPHA_DAEMON.instanceId));
-    alphaRuntime.emitReceipt(receipt(operationId, "observed"));
-    clock.advance(1_000);
-    await settle();
-
-    expect(terminalWakeups).toBe(0);
-    expect(client.getSnapshot().generation).toBe(2);
-    expect(client.getSnapshot().operations).toMatchObject({
-      pending: [],
-      terminalOperationIds: [],
-      lastReceipt: null,
-    });
-    expect(retiredSubscription.closeCount).toBe(1);
-    expect(runtimeResourceSnapshot()["runtime-timer"].active).toBe(timerBaseline);
-    client.dispose();
-    await settle();
-  });
-
-  it("keeps pane delivery scoped and bounded across 2, 4, and 8 clients", async () => {
-    for (const count of [2, 4, 8]) {
-      const clients = [];
-      const runtimes: FakeRuntime[] = [];
-      let semanticWakeups = 0;
-      let terminalWakeups = 0;
-      for (let index = 0; index < count; index += 1) {
-        const shell = shellBroker({ alpha: shellResource("alpha") });
-        const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-        const client = createWorkspaceClient({
-          target: target("alpha"),
-          ports: { shell: shell.transport, connectRuntime: async () => runtime, actions },
-        });
-        shell.connections[0]!.handlers.onVerifiedOpen();
-        client.subscribe("semantic", () => (semanticWakeups += 1));
-        client.subscribeTerminal(
-          { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-          () => (terminalWakeups += 1),
-        );
-        clients.push(client);
-        runtimes.push(runtime);
-      }
-      await settle();
-      const semanticBaseline = semanticWakeups;
-      for (const runtime of runtimes) {
-        runtime.subscriptions.get("pane.alpha")!.emit(terminalSeed(ALPHA_DAEMON.instanceId));
-      }
-      expect(terminalWakeups).toBe(count);
-      expect(semanticWakeups).toBe(semanticBaseline);
-      expect(runtimes.reduce((sum, runtime) => sum + runtime.subscriptions.size, 0)).toBe(count);
-      for (const client of clients) client.dispose();
-      await settle();
-      expect(runtimes.every((runtime) => runtime.closeCount === 1)).toBe(true);
-    }
-  });
-
-  it("keeps workspace prepare and decision in one generation-fenced action lifecycle", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const prepareToken = "30000000-0000-4000-8000-000000000003";
-    const calls: string[] = [];
-    const handoffActions: WorkspaceClientOwnerActionPort = {
-      async dispatch(input) {
-        calls.push(input.name);
-        if (input.name === "workspace.open.prepare") {
-          return {
-            operationId: "20000000-0000-4000-8000-000000000002",
-            daemonInstanceId: ALPHA_DAEMON.instanceId,
-            phase: "prepared",
-            prepareToken,
-            preparedRevision: 1,
-            outcome: "reopened",
-            workspaceName: "alpha",
-            previousWorkspaceName: null,
-            proof: {
-              semanticPaneId: "pane.alpha",
-              paneCount: 1,
-              terminalRevision: 0,
-              terminalStateHash: "0000000000000000",
-            },
-          } as never;
-        }
-        return {
-          operationId: "40000000-0000-4000-8000-000000000004",
-          daemonInstanceId: ALPHA_DAEMON.instanceId,
-          phase: "committed",
-          prepareToken,
-          preparedRevision: 1,
-          workspaceName: "alpha",
-          previousWorkspaceName: null,
-        } as never;
-      },
-    };
-    let nextOperation = 10;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => runtime,
-        actions: handoffActions,
-      },
-      operationId: () => `50000000-0000-4000-8000-${String(nextOperation++).padStart(12, "0")}`,
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    await client.dispatch({
-      kind: "owner-action",
-      name: "workspace.open.prepare",
-      input: { source: { kind: "project", projectDir: "/project" } },
-    });
-    await expect(
-      client.dispatch({
-        kind: "owner-action",
-        name: "workspace.open.commit",
-        input: {
-          prepareToken: "60000000-0000-4000-8000-000000000006",
-          preparedRevision: 1,
-        },
-      }),
-    ).rejects.toThrow("does not match");
-    await client.dispatch({
-      kind: "owner-action",
-      name: "workspace.open.commit",
-      input: { prepareToken, preparedRevision: 1 },
-    });
-    expect(calls).toEqual(["workspace.open.prepare", "workspace.open.commit"]);
-    client.dispose();
-    await settle();
-  });
-
-  it("terminalizes a rejected owner action immediately", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const operationId = "70000000-0000-4000-8000-000000000007";
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => runtime,
-        actions: {
-          dispatch: async () => {
-            throw new Error("owner rejected");
-          },
-        },
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-
-    await expect(
-      client.dispatch({
-        kind: "owner-action",
-        operationId,
-        name: "workspace.pane.select",
-        input: { semanticPaneId: "pane.alpha" },
-      }),
-    ).rejects.toThrow("owner rejected");
-
-    expect(client.getSnapshot().operations.pending).toEqual([]);
-    expect(client.getSnapshot().operations.terminalOperationIds).toContain(operationId);
-    client.dispose();
-    await settle();
-  });
-
-  it("actively cancels a prepared open on target replacement and fences its late completion", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const alphaRuntime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const betaRuntime = new FakeRuntime(BETA_DAEMON.instanceId);
-    const prepareToken = "80000000-0000-4000-8000-000000000008";
-    let rejectCancel!: (error: Error) => void;
-    const cancelCompletion = new Promise<void>((_resolve, reject) => (rejectCancel = reject));
-    const calls: Array<{ name: string; workspaceName: string; input: unknown }> = [];
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (current) =>
-          current.workspaceName === "alpha" ? alphaRuntime : betaRuntime,
-        actions: {
-          async dispatch(input) {
-            calls.push({
-              name: input.name,
-              workspaceName: input.target.workspaceName,
-              input: input.input,
-            });
-            if (input.name === "workspace.open.prepare") {
-              return {
-                operationId: input.operationId,
-                daemonInstanceId: ALPHA_DAEMON.instanceId,
-                phase: "prepared",
-                prepareToken,
-                preparedRevision: 4,
-                outcome: "reopened",
-                workspaceName: "alpha",
-                previousWorkspaceName: null,
-                proof: {
-                  semanticPaneId: "pane.alpha",
-                  paneCount: 1,
-                  terminalRevision: 0,
-                  terminalStateHash: "0000000000000000",
-                },
-              } as never;
-            }
-            if (input.name === "workspace.open.cancel") await cancelCompletion;
-            return null as never;
-          },
-        },
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    await client.dispatch({
-      kind: "owner-action",
-      name: "workspace.open.prepare",
-      input: { source: { kind: "project", projectDir: "/project" } },
-    });
-
-    client.setTarget(target("beta", BETA_DAEMON));
-    await settle();
-    expect(calls).toContainEqual({
-      name: "workspace.open.cancel",
-      workspaceName: "alpha",
-      input: { prepareToken, preparedRevision: 4 },
-    });
-    expect(client.getSnapshot().generation).toBe(2);
-    expect(client.getSnapshot().operations.pending).toEqual([]);
-
-    rejectCancel(new Error("late retired cancellation failure"));
-    await settle();
-    expect(client.getSnapshot().generation).toBe(2);
-    expect(client.getSnapshot().target?.workspaceName).toBe("beta");
-    expect(client.getSnapshot().operations.pending).toEqual([]);
-    client.dispose();
-    await settle();
-  });
-
-  it("cancels a capability whose prepare resolves after its exact target retired", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const pending = deferred<unknown>();
-    const calls: Array<{ name: string; workspaceName: string; input: unknown }> = [];
-    const prepareToken = "81000000-0000-4000-8000-000000000008";
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (current) => new FakeRuntime(current.daemon.instanceId),
-        actions: {
-          async dispatch(input) {
-            calls.push({
-              name: input.name,
-              workspaceName: input.target.workspaceName,
-              input: input.input,
-            });
-            if (input.name === "workspace.open.prepare") return (await pending.promise) as never;
-            return null as never;
-          },
-        },
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    const preparing = client.dispatch({
-      kind: "owner-action",
-      name: "workspace.open.prepare",
-      input: { source: { kind: "project", projectDir: "/project" } },
-    });
-    client.setTarget(target("beta", BETA_DAEMON));
-    pending.resolve({
-      operationId: "late-prepare",
-      daemonInstanceId: ALPHA_DAEMON.instanceId,
-      phase: "prepared",
-      prepareToken,
-      preparedRevision: 7,
-      outcome: "reopened",
-      workspaceName: "alpha",
-      previousWorkspaceName: null,
-      proof: {
-        semanticPaneId: "pane.alpha",
-        paneCount: 1,
-        terminalRevision: 0,
-        terminalStateHash: "0000000000000000",
-      },
-    });
-    await expect(preparing).rejects.toThrow("retired");
-    expect(calls.at(-1)).toEqual({
-      name: "workspace.open.cancel",
-      workspaceName: "alpha",
-      input: { prepareToken, preparedRevision: 7 },
-    });
-    await client.dispose();
-  });
-
-  it("actively cancels a prepared open during idempotent disposal", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const prepareToken = "90000000-0000-4000-8000-000000000009";
-    const calls: string[] = [];
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => runtime,
-        actions: {
-          async dispatch(input) {
-            calls.push(input.name);
-            if (input.name === "workspace.open.prepare") {
-              return {
-                operationId: input.operationId,
-                daemonInstanceId: ALPHA_DAEMON.instanceId,
-                phase: "prepared",
-                prepareToken,
-                preparedRevision: 2,
-                outcome: "reopened",
-                workspaceName: "alpha",
-                previousWorkspaceName: null,
-                proof: {
-                  semanticPaneId: "pane.alpha",
-                  paneCount: 1,
-                  terminalRevision: 0,
-                  terminalStateHash: "0000000000000000",
-                },
-              } as never;
-            }
-            return null as never;
-          },
-        },
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    await client.dispatch({
-      kind: "owner-action",
-      name: "workspace.open.prepare",
-      input: { source: { kind: "project", projectDir: "/project" } },
-    });
-
-    await client.dispose();
-    await client.dispose();
-    await settle();
-    expect(calls).toEqual(["workspace.open.prepare", "workspace.open.cancel"]);
-    expect(client.getSnapshot().phase).toBe("disposed");
-    expect(runtime.closeCount).toBe(1);
-  });
-
-  it("cancels a capability whose prepare resolves after disposal", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const pending = deferred<unknown>();
-    const calls: string[] = [];
-    const prepareToken = "91000000-0000-4000-8000-000000000009";
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => new FakeRuntime(ALPHA_DAEMON.instanceId),
-        actions: {
-          async dispatch(input) {
-            calls.push(input.name);
-            if (input.name === "workspace.open.prepare") return (await pending.promise) as never;
-            return null as never;
-          },
-        },
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    const preparing = client.dispatch({
-      kind: "owner-action",
-      name: "workspace.open.prepare",
-      input: { source: { kind: "project", projectDir: "/project" } },
-    });
-    const disposal = client.dispose();
-    pending.resolve({
-      operationId: "late-disposed-prepare",
-      daemonInstanceId: ALPHA_DAEMON.instanceId,
-      phase: "prepared",
-      prepareToken,
-      preparedRevision: 8,
-      outcome: "reopened",
-      workspaceName: "alpha",
-      previousWorkspaceName: null,
-      proof: {
-        semanticPaneId: "pane.alpha",
-        paneCount: 1,
-        terminalRevision: 0,
-        terminalStateHash: "0000000000000000",
-      },
-    });
-    await expect(preparing).rejects.toThrow("retired");
-    await disposal;
-    expect(calls).toEqual(["workspace.open.prepare", "workspace.open.cancel"]);
-  });
-
-  it("does not settle disposal until the runtime supervisor closes its transport", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const closing = deferred<void>();
-    runtime.closeGate = closing.promise;
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async () => runtime,
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-
-    let settled = false;
-    const disposing = client.dispose().then(() => (settled = true));
-    await settle();
-    expect(runtime.closeCount).toBe(1);
-    expect(settled).toBe(false);
-    closing.resolve();
-    await disposing;
-    expect(settled).toBe(true);
-  });
-
-  it("does not settle target retirement until its terminal subscription closes", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const alpha = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const beta = new FakeRuntime(BETA_DAEMON.instanceId);
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (current) => (current.workspaceName === "alpha" ? alpha : beta),
-        actions,
-      },
-    });
-    client.subscribeTerminal(
-      { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-      () => undefined,
-    );
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    const subscription = alpha.subscriptions.get("pane.alpha")!;
-    const closeGate = deferred<void>();
-    subscription.closeGate = closeGate.promise;
-
-    let retired = false;
-    const retirement = client.setTarget(target("beta", BETA_DAEMON)).then(() => (retired = true));
-    await settle();
-    expect(subscription.closeCount).toBe(1);
-    expect(retired).toBe(false);
-    closeGate.resolve();
-    await retirement;
-    expect(retired).toBe(true);
-    await client.dispose();
-  });
-
-  it("fences and closes a terminal subscription that resolves after disposal settled", async () => {
-    const shell = shellBroker({ alpha: shellResource("alpha") });
-    const runtime = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const subscriptionStarted = deferred<void>();
-    const subscriptionReady = deferred<FakeTerminalSubscription>();
-    runtime.subscribeTerminal = async () => {
-      subscriptionStarted.resolve();
-      return subscriptionReady.promise;
-    };
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: { shell: shell.transport, connectRuntime: async () => runtime, actions },
-    });
-    client.subscribeTerminal(
-      { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-      () => undefined,
-    );
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await subscriptionStarted.promise;
-
-    await client.dispose();
-    expect(client.getSnapshot().phase).toBe("disposed");
-
-    const closeStarted = deferred<void>();
-    const closeFinished = deferred<void>();
-    const late = new FakeTerminalSubscription(ALPHA_DAEMON.instanceId);
-    const closeGate = deferred<void>();
-    late.close = async () => {
-      late.closeCount += 1;
-      closeStarted.resolve();
-      await closeGate.promise;
-      closeFinished.resolve();
-    };
-    subscriptionReady.resolve(late);
-    await closeStarted.promise;
-    expect(late.closeCount).toBe(1);
-    closeGate.resolve();
-    await closeFinished.promise;
-    expect(late.closeCount).toBe(1);
-  });
-});
-
-describe("semantic mutation acknowledgement across topology replacement", () => {
-  const operationId = "45000000-0000-4000-8000-000000000045";
-  const command = {
-    kind: "semantic-intent" as const,
-    operationId,
-    intent: {
-      verb: "workspace.window.split" as const,
-      workspaceName: "alpha",
-      semanticPaneId: "pane.alpha",
-      direction: "right" as const,
-    },
-  };
-  const acknowledgement = {
-    operationId,
-    daemonInstanceId: ALPHA_DAEMON.instanceId,
-    outcome: "applied" as const,
-    workspaceName: "alpha",
-    verb: "workspace.window.split" as const,
-    direction: "right" as const,
-    semanticPaneId: "pane.new",
-    displayTitle: "Shell",
-  };
-  async function fixture(
-    beforeReplacement?: (client: WorkspaceClient<string, string>, active: FakeRuntime) => void,
-  ) {
-    const shell = shellBroker({ alpha: shellResource("alpha"), beta: shellResource("beta") });
-    const response = deferred<typeof acknowledgement | void>();
-    const active = Object.assign(new FakeRuntime(ALPHA_DAEMON.instanceId), {
-      submitIntent: () => response.promise,
-    });
-    const replacement = new FakeRuntime(ALPHA_DAEMON.instanceId);
-    const client = createWorkspaceClient({
-      target: target("alpha"),
-      ports: {
-        shell: shell.transport,
-        connectRuntime: async (_target, inventory) =>
-          inventory.semanticPaneIds.includes("pane.new") ? replacement : active,
-        actions,
-      },
-    });
-    shell.connections[0]!.handlers.onVerifiedOpen();
-    await settle();
-    beforeReplacement?.(client, active);
-    const completion = client.dispatch(command);
-    // Attach rejection observation before advancing asynchronous topology work.
-    void completion.catch(() => undefined);
-    shell.byWorkspace.set("alpha", shellResource("alpha", ["pane.alpha", "pane.new"]));
-    shell.connections[0]!.handlers.onInvalidate();
-    await settle();
-    expect(active.closeCount).toBe(1);
-    return { client, response, completion };
-  }
-  it("accepts the exact durable acknowledgement without retaining a stream receipt dependency", async () => {
-    const { client, response, completion } = await fixture();
-    response.resolve(acknowledgement);
-    await expect(completion).resolves.toMatchObject({
-      kind: "semantic-intent",
-      operationId,
-      result: acknowledgement,
-    });
-    await expect(client.dispatch(command)).rejects.toThrow("already pending or terminal");
-    await client.dispose();
-  });
-  it.each([
-    ["operation", { operationId: "55000000-0000-4000-8000-000000000055" }],
-    ["daemon", { daemonInstanceId: BETA_DAEMON.instanceId }],
-    ["workspace", { workspaceName: "beta" }],
-    ["verb", { verb: "workspace.session.kill" }],
-    ["malformed", { outcome: "unknown" }],
-  ])("rejects a mismatched %s acknowledgement", async (_label, patch) => {
-    const { client, response, completion } = await fixture();
-    response.resolve({ ...acknowledgement, ...patch } as typeof acknowledgement);
-    await expect(completion).rejects.toThrow("matching mutation acknowledgement");
-    await client.dispose();
-  });
-  it("keeps input, viewport, and authority completions fenced to the exact old runtime", async () => {
-    const gate = deferred<void>();
-    let input!: Promise<unknown>;
-    let fit!: Promise<unknown>;
-    let grant!: Promise<unknown>;
-    const { client, response, completion } = await fixture((client, active) => {
-      active.inputGate = gate.promise;
-      active.viewportGate = gate.promise;
-      active.authorityGate = gate.promise;
-      input = client.sendTerminalInput(
-        { workspaceName: "alpha", semanticPaneId: "pane.alpha" },
-        { type: "text", text: "hello" },
-      );
-      fit = client.fitViewport(100, 30);
-      grant = client.requestAuthority("input");
-    });
-    gate.resolve();
-    response.resolve(acknowledgement);
-    await expect(completion).resolves.toMatchObject({ operationId });
-    await expect(input).resolves.toBe("authority-lost");
-    await expect(fit).resolves.toBe("authority-lost");
-    await expect(grant).resolves.toBeNull();
-    await client.dispose();
-  });
-  it("rejects an unacknowledged retired runtime completion", async () => {
-    const { client, response, completion } = await fixture();
-    response.resolve();
-    await expect(completion).rejects.toThrow("matching mutation acknowledgement");
-    await client.dispose();
-  });
-  it.each(["target", "daemon", "dispose"])("still fences %s retirement", async (kind) => {
-    const { client, response, completion } = await fixture();
-    if (kind === "dispose") await client.dispose();
-    else if (kind === "daemon") client.setTarget(target("alpha", BETA_DAEMON));
-    else client.setTarget(target("beta"));
-    response.resolve(acknowledgement);
-    await expect(completion).rejects.toThrow("client generation was retired");
-    await client.dispose();
-  });
-});