tmux-ide 2.9.2 → 2.9.4

package/packages/daemon-client/src/tmux-server-client.test.ts

@@ -1,279 +0,0 @@
-import { describe, expect, it, mock } from "bun:test";
-import {
-  PANE_STREAM_PROTOCOL_VERSION,
-  PANE_STREAM_REDEEM_PATH,
-  PANE_STREAM_WEBSOCKET_SUBPROTOCOL,
-  tmuxServerPaneStreamPath,
-} from "@tmux-ide/contracts";
-import {
-  createTmuxServerClient,
-  listTmuxServers,
-  registerTmuxServer,
-  removeTmuxServer,
-} from "./tmux-server-client.ts";
-const scope = {
-  serverId: `tmux-server.${"a".repeat(32)}`,
-  generation: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
-};
-const other = { ...scope, serverId: `tmux-server.${"b".repeat(32)}` };
-const requestId = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
-const base = {
-  baseUrl: "http://127.0.0.1:4000",
-  ownerToken: "owner",
-  hostClientId: "client",
-  origin: "http://localhost:3000",
-};
-const sessions = (server = scope) => ({
-  version: 1,
-  server,
-  sessions: [
-    {
-      liveSessionId: `live-session.${"a".repeat(20)}`,
-      sessionName: "main",
-      workspaceName: "alias",
-      paneCount: 1,
-    },
-  ],
-});
-const stream = {
-  protocolVersion: PANE_STREAM_PROTOCOL_VERSION,
-  workspaceName: "main",
-  panes: ["pane.one"],
-  viewerMode: "interactive" as const,
-};
-const issued = () => ({
-  status: "issued",
-  descriptor: {
-    protocolVersion: PANE_STREAM_PROTOCOL_VERSION,
-    webSocketUrl: `ws://127.0.0.1:4000${tmuxServerPaneStreamPath(scope)}`,
-    subprotocol: PANE_STREAM_WEBSOCKET_SUBPROTOCOL,
-    redemptionTicket: `ps2_${"a".repeat(43)}`,
-    daemonInstanceId: scope.generation,
-    requestId,
-    expiresAt: Date.now() + 10000,
-    panes: ["pane.one"],
-    effectiveViewerMode: "interactive",
-  },
-});
-
-describe("explicit tmux server SDK client", () => {
-  it("validates versioned server listing without fallback", async () => {
-    const fetcher = mock(async (url: string | URL | Request, init?: RequestInit) => {
-      expect(String(url)).toBe(`${base.baseUrl}/api/v1/tmux-servers`);
-      expect(init?.headers).toMatchObject({ Authorization: "Bearer owner" });
-      return Response.json({
-        version: 1,
-        servers: [{ ...scope, state: "online", label: "default" }],
-      });
-    });
-    expect(
-      (await listTmuxServers({ ...base, fetch: fetcher as typeof fetch })).servers,
-    ).toHaveLength(1);
-    await expect(
-      listTmuxServers({
-        ...base,
-        fetch: mock(async () => Response.json({ version: 2, servers: [] })) as typeof fetch,
-      }),
-    ).rejects.toThrow();
-  });
-
-  it("binds copied inputs and cache keys to an immutable exact scope", async () => {
-    const input = { ...scope };
-    const fetcher = mock(async (url: string | URL | Request) => {
-      expect(String(url)).toContain(`/${scope.serverId}/${scope.generation}/sessions`);
-      return Response.json(sessions());
-    });
-    const client = createTmuxServerClient({ ...base, fetch: fetcher as typeof fetch }, input);
-    input.serverId = other.serverId;
-    expect((await client.sessions()).server).toEqual(scope);
-    expect(Object.isFrozen(client.scope)).toBe(true);
-    expect(client.cacheKey("pane", "%0")).not.toBe(
-      createTmuxServerClient(base, other).cacheKey("pane", "%0"),
-    );
-  });
-
-  it("rejects scope mismatches and stale HTTP refusal without retries", async () => {
-    const fetcher = mock(async () => Response.json(sessions(other)));
-    await expect(
-      createTmuxServerClient({ ...base, fetch: fetcher as typeof fetch }, scope).sessions(),
-    ).rejects.toMatchObject({ code: "scope-mismatch" });
-    const refused = mock(async () =>
-      Response.json({ error: { code: "stale-generation" } }, { status: 409 }),
-    );
-    await expect(
-      createTmuxServerClient({ ...base, fetch: refused as typeof fetch }, scope).sessions(),
-    ).rejects.toMatchObject({ status: 409 });
-    expect(refused).toHaveBeenCalledTimes(1);
-  });
-
-  it("drops an old selection's late response after disposal", async () => {
-    let resolve!: (response: Response) => void;
-    const pending = new Promise<Response>((done) => {
-      resolve = done;
-    });
-    const fetcher = mock(async () => pending);
-    const client = createTmuxServerClient({ ...base, fetch: fetcher as typeof fetch }, scope);
-    const result = client.sessions();
-    client.dispose();
-    resolve(Response.json(sessions()));
-    await expect(result).rejects.toMatchObject({ code: "disposed" });
-    await expect(client.sessions()).rejects.toMatchObject({ code: "disposed" });
-    expect(fetcher).toHaveBeenCalledTimes(1);
-  });
-
-  it("uses explicit owner authority for passive fleet close without a controller principal", async () => {
-    const fetcher = mock(async (_url: RequestInfo | URL, init?: RequestInit) => {
-      expect(new Headers(init?.headers).has("X-Tmux-Ide-Host-Client-Id")).toBe(false);
-      expect(new Headers(init?.headers).get("Authorization")).toBe("Bearer owner");
-      return Response.json({
-        operationId: requestId,
-        daemonInstanceId: scope.generation,
-        workspaceName: "same",
-        verb: "workspace.session.kill",
-        outcome: "applied",
-      });
-    });
-    await createTmuxServerClient({ ...base, fetch: fetcher as typeof fetch }, scope).mutate(
-      requestId,
-      {
-        verb: "workspace.session.kill",
-        workspaceName: "same",
-        fleetTarget: {
-          daemonInstanceId: scope.generation,
-          liveSessionId: `live-session.${"a".repeat(20)}`,
-          sessionName: "same",
-        },
-      },
-    );
-    expect(fetcher).toHaveBeenCalledTimes(1);
-  });
-
-  it("sends owner-scoped mutations and verifies generation and operation echoes", async () => {
-    const fetcher = mock(async (_url: string | URL | Request, init?: RequestInit) => {
-      const body = JSON.parse(String(init?.body));
-      expect(body.expectedDaemonInstanceId).toBe(scope.generation);
-      return Response.json({
-        operationId: body.operationId,
-        daemonInstanceId: scope.generation,
-        outcome: "applied",
-        workspaceName: "main",
-        verb: "workspace.pane.select",
-        semanticPaneId: "pane.one",
-      });
-    });
-    const client = createTmuxServerClient({ ...base, fetch: fetcher as typeof fetch }, scope);
-    const result = await client.mutate(requestId, {
-      verb: "workspace.pane.select",
-      workspaceName: "main",
-      semanticPaneId: "pane.one",
-    });
-    expect(result.daemonInstanceId).toBe(scope.generation);
-  });
-
-  it("sends exact issue headers and validates scoped redemption", async () => {
-    const fetcher = mock(async (url: string | URL | Request, init?: RequestInit) => {
-      expect(String(url)).toEndWith(`/${scope.serverId}/${scope.generation}/pane-streams/issue`);
-      expect(init?.headers).toMatchObject({
-        Authorization: "Bearer owner",
-        Origin: base.origin,
-        "X-Tmux-Ide-Request-Id": requestId,
-        "X-Tmux-Ide-Expected-Daemon-Instance-Id": scope.generation,
-        "X-Tmux-Ide-Host-Client-Id": "client",
-      });
-      return Response.json(issued());
-    });
-    expect(
-      (
-        await createTmuxServerClient(
-          { ...base, fetch: fetcher as typeof fetch },
-          scope,
-        ).issuePaneStream(requestId, stream)
-      ).status,
-    ).toBe("issued");
-    const wrong = issued();
-    wrong.descriptor.webSocketUrl = `ws://127.0.0.1:4000${tmuxServerPaneStreamPath(other)}`;
-    await expect(
-      createTmuxServerClient(
-        { ...base, fetch: mock(async () => Response.json(wrong)) as typeof fetch },
-        scope,
-      ).issuePaneStream(requestId, stream),
-    ).rejects.toMatchObject({ code: "scope-mismatch" });
-  });
-
-  it("rejects inventories from the wrong workspace", async () => {
-    const fetcher = mock(async () =>
-      Response.json({
-        version: 1,
-        server: scope,
-        resource: {
-          workspaceName: "other",
-          workspaceId: "workspace.0123456789abcdefabcd",
-          sessionId: "session.0123456789abcdefabcd",
-          resourceRevision: 0,
-          semanticPaneIds: ["pane.one"],
-        },
-      }),
-    );
-    await expect(
-      createTmuxServerClient({ ...base, fetch: fetcher as typeof fetch }, scope).inventory("main"),
-    ).rejects.toMatchObject({ code: "scope-mismatch" });
-  });
-});
-
-describe("server registration and adopted default", () => {
-  it("passes remote selector intent unchanged and removes by opaque registration", async () => {
-    const calls: Array<{ url: string; init?: RequestInit }> = [];
-    const fetcher = mock(async (url: string | URL | Request, init?: RequestInit) => {
-      calls.push({ url: String(url), init });
-      return Response.json(
-        init?.method === "DELETE"
-          ? { removed: true }
-          : { ...scope, label: "remote", state: "online" },
-      );
-    });
-    const options = { ...base, fetch: fetcher as typeof fetch };
-    await registerTmuxServer(options, {
-      label: "remote",
-      selector: { kind: "path", path: "/remote/socket" },
-    });
-    expect(JSON.parse(String(calls[0]?.init?.body)).selector).toEqual({
-      kind: "path",
-      path: "/remote/socket",
-    });
-    await removeTmuxServer(options, scope.serverId);
-    expect(calls[1]?.init?.method).toBe("DELETE");
-    expect(calls[1]?.url).toEndWith(`/${scope.serverId}`);
-    await expect(removeTmuxServer(options, "../default")).rejects.toThrow();
-    expect(fetcher).toHaveBeenCalledTimes(2);
-  });
-
-  it("accepts default redemption only with an exact generation and request echo", async () => {
-    const response = issued();
-    response.descriptor.webSocketUrl = `ws://127.0.0.1:4000${PANE_STREAM_REDEEM_PATH}`;
-    const fetcher = mock(async () => Response.json(response));
-    const client = createTmuxServerClient({ ...base, fetch: fetcher as typeof fetch }, scope);
-    expect((await client.issuePaneStream(requestId, stream)).status).toBe("issued");
-    response.descriptor.daemonInstanceId = requestId;
-    await expect(client.issuePaneStream(requestId, stream)).rejects.toMatchObject({
-      code: "scope-mismatch",
-    });
-  });
-
-  it("preserves authoritative workspace aliases and unavailable collisions", async () => {
-    const response = sessions();
-    const client = createTmuxServerClient(
-      { ...base, fetch: mock(async () => Response.json(response)) as typeof fetch },
-      scope,
-    );
-    expect((await client.sessions()).sessions[0]?.workspaceName).toBe("alias");
-    const unavailable = {
-      ...response,
-      sessions: response.sessions.map((session) => ({ ...session, workspaceName: null })),
-    };
-    const otherClient = createTmuxServerClient(
-      { ...base, fetch: mock(async () => Response.json(unavailable)) as typeof fetch },
-      scope,
-    );
-    expect((await otherClient.sessions()).sessions[0]?.workspaceName).toBeNull();
-  });
-});

package/packages/daemon-client/src/tmux-server-interaction-events.test.ts

@@ -1,230 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { subscribeTmuxServerInteractions } from "./tmux-server-interaction-events.ts";
-const server = {
-  serverId: `tmux-server.${"a".repeat(32)}`,
-  generation: "11111111-1111-4111-8111-111111111111",
-};
-const observationStatus = {
-  schemaVersion: 1,
-  environmentId: "00000000-0000-4000-8000-000000000001",
-  serverScope: server,
-  method: "unavailable",
-  capabilityVersion: null,
-  commands: [],
-  effects: [],
-  coverage: "unavailable",
-  cursor: null,
-  lastGap: null,
-  droppedCount: "0",
-};
-const ready = { version: 1, server, type: "ready", after: 0, observationStatus };
-const receipt = {
-  type: "interaction.receipt",
-  sequence: 1,
-  operationId: "afbc7eaf-604a-4117-8296-aef44b889af1",
-  origin: "external",
-  workspaceName: "same",
-  sourceSemanticPaneId: null,
-  target: { kind: "pane", semanticPaneId: "pane.same" },
-  operationKind: "workspace.pane.send",
-  phase: "observed",
-  summary: { operationKind: "workspace.pane.send", observedOnly: true },
-  proof: { operationKind: "workspace.pane.send", observed: true, semanticPaneId: "pane.same" },
-  at: "2026-09-28T00:00:00.000Z",
-  resourceRevision: null,
-  evidence: {
-    schemaVersion: 1,
-    interactionId: "afbc7eaf-604a-4117-8296-aef44b889af1",
-    revision: 0,
-    endpoints: {
-      destination: {
-        kind: "pane",
-        environmentId: observationStatus.environmentId,
-        serverScope: server,
-        paneLifetimeId: "00000000-0000-4000-8000-000000000003",
-        workspaceName: "same",
-        semanticPaneId: "pane.same",
-      },
-      source: null,
-    },
-    actor: { kind: "unknown", reason: "stock-hook" },
-    observation: { kind: "stock-hook", command: "send-keys" },
-    effect: { kind: "unknown" },
-    occurredAt: null,
-    timeBasis: "unknown",
-    receivedAt: "2026-09-28T00:00:00.000Z",
-  },
-};
-const batch = {
-  version: 1,
-  server,
-  type: "batch",
-  after: 0,
-  cursor: 1,
-  gap: null,
-  receipts: [receipt],
-};
-function fake(frames: unknown[]) {
-  return (async () =>
-    new Response(
-      new ReadableStream({
-        start(c) {
-          for (const f of frames)
-            c.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(f)}\n\n`));
-          c.close();
-        },
-      }),
-    )) as typeof fetch;
-}
-function subscribe(frames: unknown[], onBatch = () => {}) {
-  return subscribeTmuxServerInteractions({
-    baseUrl: "http://localhost",
-    ownerToken: "token",
-    server,
-    fetch: fake(frames),
-    onBatch,
-  });
-}
-describe("interaction subscriber fences", () => {
-  it("rejects status scope mismatch and missing initial coverage", async () => {
-    for (const frames of [
-      [{ ...ready, observationStatus: undefined }],
-      [
-        ready,
-        {
-          version: 1,
-          server,
-          type: "status",
-          observationStatus: {
-            ...observationStatus,
-            serverScope: { ...server, generation: "22222222-2222-4222-8222-222222222222" },
-          },
-        },
-      ],
-    ]) {
-      const stream = subscribe(frames);
-      stream.ready.catch(() => {});
-      await expect(stream.done).rejects.toThrow();
-    }
-  });
-  it("rejects evidence destination scope different from its enclosing stream", async () => {
-    const foreign = structuredClone(batch);
-    foreign.receipts[0]!.evidence.endpoints.destination.serverScope.generation =
-      "22222222-2222-4222-8222-222222222222";
-    const stream = subscribe([ready, foreign]);
-    await stream.ready;
-    await expect(stream.done).rejects.toThrow();
-  });
-  it("delivers status-only frames without advancing receipt cursor", async () => {
-    const seen: string[] = [];
-    const stream = subscribeTmuxServerInteractions({
-      baseUrl: "http://localhost",
-      ownerToken: "token",
-      server,
-      fetch: fake([
-        ready,
-        {
-          version: 1,
-          server,
-          type: "status",
-          observationStatus: {
-            ...observationStatus,
-            method: "stock-hooks",
-            capabilityVersion: 1,
-            coverage: "partial",
-            commands: ["send-keys", "capture-pane"],
-          },
-        },
-      ]),
-      onBatch: () => {
-        throw Error("Unexpected batch");
-      },
-      onStatus: (status) => seen.push(status.method),
-    });
-    await stream.ready;
-    await stream.done.catch(() => {});
-    expect(seen).toEqual(["unavailable", "stock-hooks"]);
-    expect(stream.getCursor().cursor).toBe(0);
-  });
-  it("closes while a consumer is stalled without acknowledging its batch", async () => {
-    let started!: () => void;
-    const called = new Promise<void>((resolve) => {
-      started = resolve;
-    });
-    let consumerSignal: AbortSignal | undefined;
-    const stream = subscribeTmuxServerInteractions({
-      baseUrl: "http://localhost",
-      ownerToken: "token",
-      server,
-      fetch: fake([ready, batch]),
-      onBatch: (_batch, signal) => {
-        consumerSignal = signal;
-        started();
-        return new Promise<void>(() => {});
-      },
-    });
-    await called;
-    stream.close();
-    await stream.done;
-    expect(consumerSignal?.aborted).toBe(true);
-    expect(stream.getCursor().cursor).toBe(0);
-  });
-  it("rejects scoped resume reuse before making a request", () => {
-    expect(() =>
-      subscribeTmuxServerInteractions({
-        baseUrl: "http://localhost",
-        ownerToken: "token",
-        server,
-        resume: {
-          server: { ...server, generation: "22222222-2222-4222-8222-222222222222" },
-          cursor: 0,
-        },
-        onBatch: () => {},
-      }),
-    ).toThrow("another owner");
-  });
-  it.each(["owner", "generation", "repeated ready", "version", "before ready", "regression"])(
-    "rejects %s frames",
-    async (kind) => {
-      let frames: unknown[] = [ready];
-      if (kind === "owner")
-        frames.push({ ...batch, server: { ...server, serverId: `tmux-server.${"b".repeat(32)}` } });
-      if (kind === "generation")
-        frames.push({
-          ...batch,
-          server: { ...server, generation: "22222222-2222-4222-8222-222222222222" },
-        });
-      if (kind === "repeated ready") frames.push(ready);
-      if (kind === "version") frames.push({ ...batch, version: 2 });
-      if (kind === "before ready") frames = [batch];
-      if (kind === "regression") frames.push({ ...batch, cursor: 0 });
-      let calls = 0;
-      const stream = subscribe(frames, () => {
-        calls++;
-      });
-      await expect(stream.done).rejects.toThrow();
-      expect(calls).toBe(0);
-    },
-  );
-  it("rejects repeated receipts without delivering them twice", async () => {
-    let calls = 0;
-    const stream = subscribe([ready, batch, batch], () => {
-      calls++;
-    });
-    await expect(stream.done).rejects.toThrow("Repeated");
-    expect(calls).toBe(1);
-    expect(stream.getCursor().cursor).toBe(1);
-  });
-  it("retains only acknowledged callback progress for reconnect", async () => {
-    const stream = subscribe([ready, batch], () => {
-      throw Error("consumer failed");
-    });
-    await expect(stream.done).rejects.toThrow("consumer failed");
-    expect(stream.getCursor().cursor).toBe(0);
-  });
-  it("rejects a fabricated gap and noncontiguous receipts", async () => {
-    const stream = subscribe([ready, { ...batch, gap: { from: 2, through: 2 } }]);
-    await expect(stream.done).rejects.toThrow();
-    expect(stream.getCursor().cursor).toBe(0);
-  });
-});

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

@@ -1,109 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  initialWorkspaceCatalogV2State,
-  replaceWorkspaceCatalogV2,
-} from "./workspace-catalog-v2.ts";
-
-const daemon = (instanceId: string) => ({
-  protocolVersion: 1,
-  productVersion: "test",
-  instanceId,
-  startedAt: "2026-08-12T00:00:00.000Z",
-});
-const retiredFleetSessionId = "session.aaaaaaaaaaaaaaaaaaaa";
-const sameFleetSessionId = "session.bbbbbbbbbbbbbbbbbbbb";
-
-describe("workspace catalog V2 state", () => {
-  it("keeps stopped durable intent separate from observed live tmux sessions", () => {
-    const state = replaceWorkspaceCatalogV2(initialWorkspaceCatalogV2State(), {
-      version: 2,
-      daemon: daemon("11111111-1111-4111-8111-111111111111"),
-      intents: [
-        {
-          workspaceName: "saved-workspace",
-          sessionName: "saved-session",
-          source: "workspace",
-          availability: "live",
-        },
-      ],
-      liveSessions: [],
-    });
-
-    expect(state.intents).toEqual([
-      expect.objectContaining({ workspaceName: "saved-workspace", availability: "stopped" }),
-    ]);
-    expect(state.liveSessions).toEqual([]);
-  });
-
-  it("replaces rather than merges state across daemon generations", () => {
-    const first = replaceWorkspaceCatalogV2(initialWorkspaceCatalogV2State(), {
-      version: 2,
-      daemon: daemon("11111111-1111-4111-8111-111111111111"),
-      intents: [
-        {
-          workspaceName: "retired",
-          sessionName: "retired",
-          source: "project",
-          availability: "live",
-        },
-      ],
-      liveSessions: [
-        { sessionName: "retired", fleetSessionId: retiredFleetSessionId, paneCount: 2 },
-      ],
-    });
-    const replacement = replaceWorkspaceCatalogV2(first, {
-      version: 2,
-      daemon: daemon("22222222-2222-4222-8222-222222222222"),
-      intents: [],
-      liveSessions: [],
-    });
-
-    expect(replacement).toEqual({
-      daemonInstanceId: "22222222-2222-4222-8222-222222222222",
-      intents: [],
-      liveSessions: [],
-    });
-  });
-
-  it("rejects duplicate observed session identities", () => {
-    expect(() =>
-      replaceWorkspaceCatalogV2(initialWorkspaceCatalogV2State(), {
-        version: 2,
-        daemon: daemon("11111111-1111-4111-8111-111111111111"),
-        intents: [],
-        liveSessions: [
-          { sessionName: "same", fleetSessionId: sameFleetSessionId, paneCount: 1 },
-          { sessionName: "same", fleetSessionId: sameFleetSessionId, paneCount: 2 },
-        ],
-      }),
-    ).toThrow("duplicate live session");
-  });
-
-  it("retains the opaque promotion identity on the exact live route", () => {
-    const state = replaceWorkspaceCatalogV2(initialWorkspaceCatalogV2State(), {
-      version: 2,
-      daemon: daemon("11111111-1111-4111-8111-111111111111"),
-      intents: [],
-      liveSessions: [{ sessionName: "alpha", fleetSessionId: retiredFleetSessionId, paneCount: 1 }],
-    });
-
-    expect(state.liveSessions).toEqual([
-      { sessionName: "alpha", fleetSessionId: retiredFleetSessionId, paneCount: 1 },
-    ]);
-  });
-
-  it("rejects one opaque promotion identity assigned to two routing names", () => {
-    expect(() =>
-      replaceWorkspaceCatalogV2(initialWorkspaceCatalogV2State(), {
-        version: 2,
-        daemon: daemon("11111111-1111-4111-8111-111111111111"),
-        intents: [],
-        liveSessions: [
-          { sessionName: "alpha", fleetSessionId: sameFleetSessionId, paneCount: 1 },
-          { sessionName: "beta", fleetSessionId: sameFleetSessionId, paneCount: 1 },
-        ],
-      }),
-    ).toThrow("duplicate fleet session");
-  });
-});

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

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { readFileSync, readdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
-const workspaceRoot = join(packageRoot, "..", "..");
-const productionSources = readdirSync(join(packageRoot, "src"))
-  .filter((name) => name.endsWith(".ts") && !name.endsWith(".test.ts"))
-  .map((name) => [name, readFileSync(join(packageRoot, "src", name), "utf8")] as const);
-
-describe("daemon-client dependency direction", () => {
-  it("keeps the WorkspaceClient kernel renderer and host neutral", () => {
-    const forbidden = [
-      "@opentui/",
-      "solid-js",
-      "electron",
-      "node:fs",
-      "node:child_process",
-      "globalThis.WebSocket",
-      "new WebSocket",
-      "fetch(",
-      "packages/daemon/src",
-      "@tmux-ide/tmux-bridge",
-      "process.env",
-    ];
-    const kernel = productionSources.filter(
-      ([name]) =>
-        name.startsWith("workspace-client") ||
-        name === "terminal-fast-lane.ts" ||
-        name === "first-latest-coordinator.ts",
-    );
-    for (const [name, source] of kernel) {
-      for (const specifier of forbidden) {
-        expect(source, `${name} imports or reads ${specifier}`).not.toContain(specifier);
-      }
-    }
-  });
-
-  it("keeps the terminal lane as a composition over the canonical reducer, not a wire protocol", () => {
-    const lane = readFileSync(join(packageRoot, "src", "terminal-fast-lane.ts"), "utf8");
-    expect(lane).toContain("applyTerminalReplicaUpdate");
-    expect(lane).toContain("CanonicalTerminalSubscriptionPort");
-    expect(lane).not.toContain("TerminalDeliveryEnvelope");
-    expect(lane).not.toContain("PaneStreamServerFrame");
-    expect(lane).not.toContain("SchemaZ.parse");
-    expect(lane).not.toContain("as CanonicalTerminalReplicaUpdate");
-  });
-
-  it("permits daemon-client -> core while forbidding the reverse edge", () => {
-    const coreSources = readdirSync(join(workspaceRoot, "packages", "core", "src"))
-      .filter((name) => name.endsWith(".ts") && !name.endsWith(".test.ts"))
-      .map((name) => readFileSync(join(workspaceRoot, "packages", "core", "src", name), "utf8"));
-    expect(productionSources.some(([, source]) => source.includes('from "@tmux-ide/core"'))).toBe(
-      true,
-    );
-    for (const source of coreSources) expect(source).not.toContain("@tmux-ide/daemon-client");
-  });
-});