tmux-ide 2.9.2 → 2.9.3

package/packages/contracts/src/__tests__/workspace-pane-creation.test.ts

@@ -1,249 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  WORKSPACE_PANE_CREATE_COMMAND_DESCRIPTOR,
-  WORKSPACE_PANE_CREATE_COMMAND_ID,
-  WorkspacePaneCreateInvocationSchemaZ,
-  WorkspacePaneCreateHostResultSchemaZ,
-  WorkspacePaneCreateMutationRequestSchemaZ,
-  WorkspacePaneCreateMutationResultSchemaZ,
-  WorkspacePaneCreationReferenceSchemaZ,
-  WorkspacePaneCreationWorkspaceNameSchemaZ,
-  workspacePaneCreateInvocation,
-} from "../workspace-pane-creation.ts";
-
-describe("semantic workspace pane creation command", () => {
-  it("publishes one daemon-owned descriptor for every host surface", () => {
-    expect(WORKSPACE_PANE_CREATE_COMMAND_DESCRIPTOR).toEqual({
-      version: 1,
-      id: WORKSPACE_PANE_CREATE_COMMAND_ID,
-      owner: "daemon",
-      label: "Create terminal or agent",
-      description:
-        "Ask the daemon to create a tmux-backed terminal or harness-backed agent from semantic workspace resources.",
-      category: "workspace",
-      schemas: {
-        input: "workspace.pane.create.input.v1",
-        result: "workspace.pane.create.result.v1",
-      },
-      dangerous: false,
-      confirmation: "none",
-    });
-    expect(Object.isFrozen(WORKSPACE_PANE_CREATE_COMMAND_DESCRIPTOR)).toBe(true);
-  });
-
-  it("keeps host retry metadata outside renderer-authored semantic intent", () => {
-    const request = WorkspacePaneCreateMutationRequestSchemaZ.parse({
-      operationId: "10000000-0000-4000-8000-000000000001",
-      expectedDaemonInstanceId: "20000000-0000-4000-8000-000000000002",
-      intent: {
-        kind: "agent",
-        workspaceName: "tmux-ide",
-        displayTitle: "Implementer",
-        harnessProfileId: "codex",
-        role: "implementer",
-      },
-    });
-    expect(request.intent).not.toHaveProperty("operationId");
-    expect(request.intent).not.toHaveProperty("expectedDaemonInstanceId");
-    expect(
-      WorkspacePaneCreateMutationRequestSchemaZ.safeParse({
-        ...request,
-        cwd: "/tmp/project",
-      }).success,
-    ).toBe(false);
-  });
-
-  it("returns stable semantic resource identity without daemon-private runtime facts", () => {
-    const result = WorkspacePaneCreateMutationResultSchemaZ.parse({
-      operationId: "10000000-0000-4000-8000-000000000001",
-      daemonInstanceId: "20000000-0000-4000-8000-000000000002",
-      outcome: "created",
-      resource: {
-        resourceVersion: 1,
-        workspaceName: "tmux-ide",
-        semanticPaneId: "pane.10000000000040008000000000000001",
-        kind: "terminal",
-        displayTitle: "Terminal",
-        harnessProfileId: null,
-        role: null,
-        missionId: null,
-      },
-    });
-    for (const forbidden of ["paneId", "windowId", "sessionName", "cwd", "argv", "env"]) {
-      expect(JSON.stringify(result)).not.toContain(`"${forbidden}"`);
-    }
-    expect(WorkspacePaneCreateHostResultSchemaZ.parse({ status: "ok", result })).toEqual({
-      status: "ok",
-      result,
-    });
-  });
-
-  it("round-trips a terminal request containing presentation identity only", () => {
-    const invocation = workspacePaneCreateInvocation(
-      {
-        kind: "terminal",
-        workspaceName: "tmux-ide/docs",
-        displayTitle: "Release shell",
-      },
-      { kind: "palette", surface: "command-palette" },
-    );
-
-    expect(
-      WorkspacePaneCreateInvocationSchemaZ.parse(JSON.parse(JSON.stringify(invocation))),
-    ).toEqual(invocation);
-    expect(invocation.args).not.toHaveProperty("cwd");
-    expect(invocation.args).not.toHaveProperty("argv");
-    expect(Object.isFrozen(invocation.args)).toBe(true);
-  });
-
-  it("round-trips an agent request using an exposed harness and mission identity", () => {
-    expect(
-      workspacePaneCreateInvocation(
-        {
-          kind: "agent",
-          workspaceName: "tmux-ide",
-          harnessProfileId: "codex-implementer",
-          role: "implementer",
-          missionId: "mis_gloomberb_parity",
-        },
-        { kind: "mouse", surface: "create-pane-dialog" },
-      ),
-    ).toMatchObject({
-      id: WORKSPACE_PANE_CREATE_COMMAND_ID,
-      args: {
-        kind: "agent",
-        harnessProfileId: "codex-implementer",
-        role: "implementer",
-        missionId: "mis_gloomberb_parity",
-      },
-    });
-  });
-
-  it("accepts split placement only through a durable semantic target", () => {
-    const invocation = workspacePaneCreateInvocation(
-      {
-        kind: "agent",
-        workspaceName: "tmux-ide",
-        harnessProfileId: "codex",
-        role: "implementer",
-        placement: {
-          kind: "split",
-          direction: "right",
-          targetSemanticPaneId: "pane.editor",
-        },
-      },
-      { kind: "keyboard", surface: "terminals" },
-    );
-    expect(invocation.args.placement).toEqual({
-      kind: "split",
-      direction: "right",
-      targetSemanticPaneId: "pane.editor",
-    });
-    expect(
-      WorkspacePaneCreateInvocationSchemaZ.safeParse({
-        ...invocation,
-        args: {
-          ...invocation.args,
-          placement: { kind: "split", direction: "right", targetSemanticPaneId: "%42" },
-        },
-      }).success,
-    ).toBe(false);
-  });
-
-  const forbiddenRuntimeFields = [
-    ["cwd", "/Users/example/project"],
-    ["argv", ["codex", "--yolo"]],
-    ["command", "claude"],
-    ["sessionName", "tmux-ide"],
-    ["paneId", "%42"],
-    ["token", "renderer-secret"],
-    ["executable", "/usr/local/bin/codex"],
-    ["env", { SECRET: "value" }],
-    ["model", "provider-owned-model"],
-  ] as const;
-
-  it.each(forbiddenRuntimeFields)(
-    "rejects terminal renderer-owned runtime field %s",
-    (field, value) => {
-      expect(
-        WorkspacePaneCreateInvocationSchemaZ.safeParse({
-          version: 1,
-          id: WORKSPACE_PANE_CREATE_COMMAND_ID,
-          source: { kind: "mouse", surface: "create-pane-dialog" },
-          args: { kind: "terminal", workspaceName: "tmux-ide", [field]: value },
-        }).success,
-      ).toBe(false);
-    },
-  );
-
-  it.each(forbiddenRuntimeFields)(
-    "rejects agent renderer-owned runtime field %s",
-    (field, value) => {
-      expect(
-        WorkspacePaneCreateInvocationSchemaZ.safeParse({
-          version: 1,
-          id: WORKSPACE_PANE_CREATE_COMMAND_ID,
-          source: { kind: "mouse", surface: "create-pane-dialog" },
-          args: {
-            kind: "agent",
-            workspaceName: "tmux-ide",
-            harnessProfileId: "codex",
-            role: "implementer",
-            [field]: value,
-          },
-        }).success,
-      ).toBe(false);
-    },
-  );
-
-  it.each([
-    ["token", "renderer-secret"],
-    ["daemonUrl", "http://127.0.0.1:9999"],
-    ["sessionName", "tmux-ide"],
-    ["paneId", "%42"],
-  ])("rejects invocation-level runtime field %s", (field, value) => {
-    expect(
-      WorkspacePaneCreateInvocationSchemaZ.safeParse({
-        version: 1,
-        id: WORKSPACE_PANE_CREATE_COMMAND_ID,
-        source: { kind: "mouse", surface: "create-pane-dialog" },
-        args: { kind: "terminal", workspaceName: "tmux-ide" },
-        [field]: value,
-      }).success,
-    ).toBe(false);
-  });
-
-  it("uses canonical desktop workspace names losslessly, including slash names", () => {
-    expect(WorkspacePaneCreationWorkspaceNameSchemaZ.parse("docs/site")).toBe("docs/site");
-    expect(WorkspacePaneCreationWorkspaceNameSchemaZ.safeParse(" docs/site ").success).toBe(false);
-    expect(WorkspacePaneCreationWorkspaceNameSchemaZ.safeParse("\u0000docs").success).toBe(false);
-  });
-
-  it.each(["%42", "$session", "@window", "/tmp/project", "folder\\project", " padded "])(
-    "rejects raw runtime or path-shaped reference %s",
-    (reference) => {
-      expect(WorkspacePaneCreationReferenceSchemaZ.safeParse(reference).success).toBe(false);
-    },
-  );
-
-  it("rejects C0, DEL, and C1 controls from titles and semantic references", () => {
-    for (const control of ["\u0009", "\u007f", "\u0085"]) {
-      expect(WorkspacePaneCreationReferenceSchemaZ.safeParse(`agent${control}one`).success).toBe(
-        false,
-      );
-      expect(
-        WorkspacePaneCreateInvocationSchemaZ.safeParse({
-          version: 1,
-          id: WORKSPACE_PANE_CREATE_COMMAND_ID,
-          source: { kind: "mouse" },
-          args: {
-            kind: "terminal",
-            workspaceName: "tmux-ide",
-            displayTitle: `Terminal${control}one`,
-          },
-        }).success,
-      ).toBe(false);
-    }
-  });
-});

package/packages/contracts/src/__tests__/workspace-promotion.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  WorkspacePromoteArgumentsSchemaZ,
-  WorkspacePromoteMutationRequestSchemaZ,
-  WorkspacePromoteMutationResultSchemaZ,
-  WorkspacePromotedResourceSchemaZ,
-} from "../workspace-promotion.ts";
-
-const DAEMON = "20000000-0000-4000-8000-000000000002";
-const OPERATION = "10000000-0000-4000-8000-000000000001";
-
-describe("workspace promotion contract", () => {
-  it("accepts an opaque fleet session id as the promotion target", () => {
-    const parsed = WorkspacePromoteArgumentsSchemaZ.parse({
-      sessionId: "session.0123456789abcdef0123",
-    });
-    expect(parsed.sessionId).toBe("session.0123456789abcdef0123");
-  });
-
-  it("rejects a raw tmux session name or id as the target", () => {
-    expect(WorkspacePromoteArgumentsSchemaZ.safeParse({ sessionId: "$3" }).success).toBe(false);
-    expect(WorkspacePromoteArgumentsSchemaZ.safeParse({ sessionId: "my session" }).success).toBe(
-      false,
-    );
-    expect(
-      WorkspacePromoteArgumentsSchemaZ.safeParse({ sessionId: "/home/user/project" }).success,
-    ).toBe(false);
-  });
-
-  it("requires the operation and daemon-generation envelope", () => {
-    const request = WorkspacePromoteMutationRequestSchemaZ.parse({
-      operationId: OPERATION,
-      expectedDaemonInstanceId: DAEMON,
-      intent: { sessionId: "session.0123456789abcdef0123" },
-    });
-    expect(request.operationId).toBe(OPERATION);
-    expect(
-      WorkspacePromoteMutationRequestSchemaZ.safeParse({
-        operationId: "not-a-uuid",
-        expectedDaemonInstanceId: DAEMON,
-        intent: { sessionId: "session.0123456789abcdef0123" },
-      }).success,
-    ).toBe(false);
-  });
-
-  it("carries only the workspace name in the wire-safe result", () => {
-    const result = WorkspacePromoteMutationResultSchemaZ.parse({
-      operationId: OPERATION,
-      daemonInstanceId: DAEMON,
-      outcome: "promoted",
-      resource: {
-        resourceVersion: 1,
-        workspaceName: "fleet-alpha-0123456789abcdef0123456789abcdef",
-      },
-    });
-    expect(result.outcome).toBe("promoted");
-    // The resource is strictly the version + workspace name — no path or id keys.
-    expect(Object.keys(result.resource).sort()).toEqual(["resourceVersion", "workspaceName"]);
-  });
-
-  it("only permits the promoted and replayed outcomes", () => {
-    for (const outcome of ["promoted", "replayed"] as const) {
-      expect(
-        WorkspacePromoteMutationResultSchemaZ.safeParse({
-          operationId: OPERATION,
-          daemonInstanceId: DAEMON,
-          outcome,
-          resource: { resourceVersion: 1, workspaceName: "w" },
-        }).success,
-      ).toBe(true);
-    }
-    for (const outcome of ["created", "reopened"]) {
-      expect(
-        WorkspacePromoteMutationResultSchemaZ.safeParse({
-          operationId: OPERATION,
-          daemonInstanceId: DAEMON,
-          outcome,
-          resource: { resourceVersion: 1, workspaceName: "w" },
-        }).success,
-      ).toBe(false);
-    }
-  });
-
-  it("rejects an extra key on the promoted resource", () => {
-    expect(
-      WorkspacePromotedResourceSchemaZ.safeParse({
-        resourceVersion: 1,
-        workspaceName: "w",
-        projectDir: "/home/user/project",
-      }).success,
-    ).toBe(false);
-  });
-});

package/packages/contracts/src/__tests__/workspace-resource-identity.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  WorkspaceChangeResourceIdSchemaZ,
-  WorkspaceChangesRevisionSchemaZ,
-  WorkspaceFileResourceIdSchemaZ,
-  WorkspaceFilesRevisionSchemaZ,
-  WorkspaceRelativeDisplayPathSchemaZ,
-  WorkspaceResourceNameSchemaZ,
-  WorkspaceResourceOpaqueTokenSchemaZ,
-  WorkspaceResourceWorkspaceNameSchemaZ,
-} from "../workspace-resource-identity.ts";
-
-const NUL = String.fromCharCode(0);
-const BELL = String.fromCharCode(7);
-const TAB = String.fromCharCode(9);
-const DEL = String.fromCharCode(127);
-
-describe("workspace resource identity", () => {
-  it("accepts prefixed opaque ids and rejects path-shaped or reserved values", () => {
-    expect(WorkspaceFileResourceIdSchemaZ.safeParse("file.0123456789abcdef").success).toBe(true);
-    expect(WorkspaceChangeResourceIdSchemaZ.safeParse("change.0123456789abcdef").success).toBe(
-      true,
-    );
-    expect(WorkspaceFilesRevisionSchemaZ.safeParse("files-rev.0123456789abcdef").success).toBe(
-      true,
-    );
-    expect(WorkspaceChangesRevisionSchemaZ.safeParse("changes-rev.0123456789abcdef").success).toBe(
-      true,
-    );
-
-    // Wrong prefix, missing prefix, and cross-prefix are all rejected.
-    expect(WorkspaceFileResourceIdSchemaZ.safeParse("change.0123456789abcdef").success).toBe(false);
-    expect(WorkspaceFileResourceIdSchemaZ.safeParse("0123456789abcdef").success).toBe(false);
-    // A path separator can never appear inside an opaque id.
-    expect(WorkspaceFileResourceIdSchemaZ.safeParse("file.../etc/passwd").success).toBe(false);
-    expect(WorkspaceFileResourceIdSchemaZ.safeParse("file.a/b0123456789abcd").success).toBe(false);
-    // Reserved record keys cannot masquerade as an id.
-    expect(WorkspaceFileResourceIdSchemaZ.safeParse("__proto__").success).toBe(false);
-    expect(WorkspaceFileResourceIdSchemaZ.safeParse("file.__proto__").success).toBe(false);
-    // Length bounds: too short, and past the 64-char token ceiling.
-    expect(WorkspaceFileResourceIdSchemaZ.safeParse("file.short").success).toBe(false);
-    expect(WorkspaceFileResourceIdSchemaZ.safeParse(`file.${"a".repeat(65)}`).success).toBe(false);
-  });
-
-  it("bounds the bare opaque token", () => {
-    expect(WorkspaceResourceOpaqueTokenSchemaZ.safeParse("0123456789abcdef").success).toBe(true);
-    expect(WorkspaceResourceOpaqueTokenSchemaZ.safeParse("short").success).toBe(false);
-    expect(WorkspaceResourceOpaqueTokenSchemaZ.safeParse("has/slash012345678").success).toBe(false);
-  });
-
-  it("treats a resource name as a single sanitized path segment", () => {
-    expect(WorkspaceResourceNameSchemaZ.safeParse("index.ts").success).toBe(true);
-    expect(WorkspaceResourceNameSchemaZ.safeParse(".gitignore").success).toBe(true);
-
-    expect(WorkspaceResourceNameSchemaZ.safeParse(".").success).toBe(false);
-    expect(WorkspaceResourceNameSchemaZ.safeParse("..").success).toBe(false);
-    expect(WorkspaceResourceNameSchemaZ.safeParse("").success).toBe(false);
-    expect(WorkspaceResourceNameSchemaZ.safeParse("a/b").success).toBe(false);
-    expect(WorkspaceResourceNameSchemaZ.safeParse("a\\b").success).toBe(false);
-    expect(WorkspaceResourceNameSchemaZ.safeParse(`a${NUL}b`).success).toBe(false);
-    expect(WorkspaceResourceNameSchemaZ.safeParse(`a${BELL}b`).success).toBe(false);
-    expect(WorkspaceResourceNameSchemaZ.safeParse(`a${DEL}b`).success).toBe(false);
-    expect(WorkspaceResourceNameSchemaZ.safeParse("a".repeat(256)).success).toBe(false);
-  });
-
-  it("keeps display paths relative, forward-slashed, and control-free", () => {
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse("src/index.ts").success).toBe(true);
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse("README.md").success).toBe(true);
-
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse("/etc/passwd").success).toBe(false);
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse("../secret").success).toBe(false);
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse("src/../secret").success).toBe(false);
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse("a//b").success).toBe(false);
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse("src\\index.ts").success).toBe(false);
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse("src/.").success).toBe(false);
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse(`a${TAB}b`).success).toBe(false);
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse(`a${DEL}b`).success).toBe(false);
-    expect(WorkspaceRelativeDisplayPathSchemaZ.safeParse("a".repeat(1_025)).success).toBe(false);
-  });
-
-  it("accepts a semantic workspace name but rejects control characters", () => {
-    expect(WorkspaceResourceWorkspaceNameSchemaZ.safeParse("tmux-ide").success).toBe(true);
-    expect(WorkspaceResourceWorkspaceNameSchemaZ.parse("  spaced name  ")).toBe("spaced name");
-
-    expect(WorkspaceResourceWorkspaceNameSchemaZ.safeParse("").success).toBe(false);
-    expect(WorkspaceResourceWorkspaceNameSchemaZ.safeParse(`with${NUL}nul`).success).toBe(false);
-    expect(WorkspaceResourceWorkspaceNameSchemaZ.safeParse(`with${DEL}del`).success).toBe(false);
-    expect(WorkspaceResourceWorkspaceNameSchemaZ.safeParse("a".repeat(161)).success).toBe(false);
-  });
-});

package/packages/contracts/src/daemon-resource-request.test.ts

@@ -1,192 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import {
-  DAEMON_RESOURCE_KINDS,
-  DAEMON_RESOURCE_RESULT_SCHEMAS,
-  DAEMON_WORKSPACE_ROUTE_KEYS,
-  DaemonResourceRequestSchemaZ,
-  createDaemonResourceMethods,
-  daemonWorkspaceRouteName,
-  isDaemonResourceKind,
-  type DaemonResourceRequest,
-} from "./daemon-resource-request.ts";
-
-const WORKSPACE = "product";
-const FILE_ID = "file.00112233445566778899aabbccddeeff";
-const CHANGE_ID = "change.00112233445566778899aabbccddeeff";
-
-/** One valid request per variant: the round-trip corpus. */
-const REQUESTS: readonly DaemonResourceRequest[] = [
-  { resource: "capabilities" },
-  { resource: "refreshConnection" },
-  { resource: "listWorkspaces" },
-  { resource: "fetchFleetCatalog" },
-  { resource: "fetchWorkspaceCatalog" },
-  { resource: "fetchWidgetAsset", request: { assetId: "a".repeat(64) } },
-  { resource: "startupReadiness" },
-  { resource: "fetchApplicationShell", request: { workspaceName: WORKSPACE } },
-  { resource: "fetchWorkspaceFiles", request: { workspaceName: WORKSPACE } },
-  {
-    resource: "fetchWorkspaceFilePreview",
-    request: { workspaceName: WORKSPACE, fileId: FILE_ID },
-  },
-  { resource: "fetchWorkspaceChanges", request: { workspaceName: WORKSPACE } },
-  { resource: "fetchWorkspaceMissions", request: { workspaceName: WORKSPACE } },
-  {
-    resource: "fetchWorkspaceChangeDiff",
-    request: { workspaceName: WORKSPACE, changeId: CHANGE_ID },
-  },
-  {
-    resource: "promoteWorkspace",
-    request: { sessionId: "session.00112233445566778899aabbccddeeff" },
-  },
-  {
-    resource: "createWorkspacePane",
-    request: {
-      version: 1,
-      id: "workspace.pane.create",
-      source: { kind: "mouse", surface: "create-pane-dialog" },
-      args: { kind: "terminal", workspaceName: WORKSPACE },
-    },
-  },
-  {
-    resource: "mutateAppWindow",
-    request: {
-      intent: {
-        workspaceName: WORKSPACE,
-        expectedDocumentRevision: 4,
-        command: { type: "window.move", windowId: "window.worker", x: 10, y: 20 },
-      },
-    },
-  },
-  {
-    resource: "invokeVerb",
-    request: {
-      verbId: "pane.split.right",
-      intent: {
-        verb: "workspace.window.split",
-        workspaceName: WORKSPACE,
-        semanticPaneId: "pane.worker",
-        direction: "right",
-      },
-    },
-  },
-  {
-    resource: "issueTerminalAttachment",
-    request: {
-      protocolVersion: 1,
-      target: { workspaceName: WORKSPACE, semanticPaneId: "pane.worker" },
-      viewerMode: "interactive",
-      geometryOwnership: "passive",
-      viewport: { cols: 120, rows: 40 },
-    },
-  },
-  {
-    resource: "issuePaneStream",
-    request: {
-      protocolVersion: 2,
-      workspaceName: WORKSPACE,
-      panes: ["pane.worker"],
-      viewerMode: "read-only",
-    },
-  },
-];
-
-describe("daemon resource request union", () => {
-  it("covers every declared resource exactly once", () => {
-    expect([...REQUESTS].map((request) => request.resource).sort()).toEqual(
-      [...DAEMON_RESOURCE_KINDS].sort(),
-    );
-    expect(Object.keys(DAEMON_RESOURCE_RESULT_SCHEMAS).sort()).toEqual(
-      [...DAEMON_RESOURCE_KINDS].sort(),
-    );
-  });
-
-  it("round-trips every variant unchanged", () => {
-    for (const request of REQUESTS) {
-      const parsed = DaemonResourceRequestSchemaZ.parse(JSON.parse(JSON.stringify(request)));
-      expect(parsed).toEqual(request);
-    }
-  });
-
-  it("refuses an unknown tag, a missing tag, and a payload on a payload-free resource", () => {
-    expect(DaemonResourceRequestSchemaZ.safeParse({ resource: "readEverything" }).success).toBe(
-      false,
-    );
-    expect(DaemonResourceRequestSchemaZ.safeParse({}).success).toBe(false);
-    expect(DaemonResourceRequestSchemaZ.safeParse(null).success).toBe(false);
-    expect(
-      DaemonResourceRequestSchemaZ.safeParse({
-        resource: "capabilities",
-        request: { escalate: true },
-      }).success,
-    ).toBe(false);
-  });
-
-  it("refuses a payload borrowed from another variant", () => {
-    expect(
-      DaemonResourceRequestSchemaZ.safeParse({
-        resource: "fetchWorkspaceChangeDiff",
-        request: { workspaceName: WORKSPACE },
-      }).success,
-    ).toBe(false);
-  });
-
-  it("names a resource kind only for declared resources", () => {
-    for (const kind of DAEMON_RESOURCE_KINDS) expect(isDaemonResourceKind(kind)).toBe(true);
-    expect(isDaemonResourceKind("subscribe")).toBe(false);
-    expect(isDaemonResourceKind("toString")).toBe(false);
-    expect(isDaemonResourceKind(undefined)).toBe(false);
-  });
-
-  it("keys the application-shell route on the session name and the rest on the workspace", () => {
-    const entry = { workspaceName: "product", sessionName: "tmux-product" };
-    expect(daemonWorkspaceRouteName("fetchApplicationShell", entry)).toBe("tmux-product");
-    for (const resource of ["fetchWorkspaceFiles", "fetchWorkspaceChangeDiff"] as const) {
-      expect(daemonWorkspaceRouteName(resource, entry)).toBe("product");
-    }
-    // The table is the only declaration of the fork; every workspace-keyed
-    // resource must appear in it.
-    expect(Object.keys(DAEMON_WORKSPACE_ROUTE_KEYS).sort()).toEqual([
-      "fetchApplicationShell",
-      "fetchWorkspaceChangeDiff",
-      "fetchWorkspaceChanges",
-      "fetchWorkspaceFilePreview",
-      "fetchWorkspaceFiles",
-      "fetchWorkspaceMissions",
-    ]);
-  });
-
-  it("builds one method per resource over a single dispatcher", async () => {
-    const seen: DaemonResourceRequest[] = [];
-    const methods = createDaemonResourceMethods(async (request) => {
-      seen.push(request);
-      return { status: "error", error: { code: "disposed", reason: "test" } };
-    });
-    for (const kind of DAEMON_RESOURCE_KINDS) {
-      expect(typeof methods[kind]).toBe("function");
-    }
-    await methods.listWorkspaces();
-    await methods.fetchWorkspaceCatalog();
-    await methods.fetchWorkspaceChanges({ workspaceName: WORKSPACE });
-    expect(seen).toEqual([
-      { resource: "listWorkspaces" },
-      { resource: "fetchWorkspaceCatalog" },
-      { resource: "fetchWorkspaceChanges", request: { workspaceName: WORKSPACE } },
-    ]);
-  });
-
-  it("preserves the one-argument dispatcher contract when no signal is supplied", async () => {
-    const dispatch = vi.fn(async () => ({
-      status: "error",
-      error: { code: "disposed", reason: "test" },
-    }));
-    const methods = createDaemonResourceMethods(dispatch);
-    await methods.capabilities();
-    await methods.fetchWorkspaceFiles({ workspaceName: WORKSPACE });
-    expect(dispatch.mock.calls[0]).toEqual([{ resource: "capabilities" }]);
-    expect(dispatch.mock.calls[1]).toEqual([
-      { resource: "fetchWorkspaceFiles", request: { workspaceName: WORKSPACE } },
-    ]);
-  });
-});

package/packages/contracts/src/native-operation-identity.test.ts

@@ -1,23 +0,0 @@
-import { expect, it } from "vitest";
-import { NativeOperationIdentitySchemaZ } from "./native-operation-identity.ts";
-const ack = {
-  schemaVersion: 2,
-  type: "operation-identity",
-  serverEpoch: "00000000-0000-4000-8000-000000000001",
-  operationId: "00000000-0000-4000-8000-000000000002",
-  connectionId: "1",
-  wrapperCommandId: "18446744073709551615",
-};
-it("accepts only bounded positive native identity and strict metadata", () => {
-  expect(NativeOperationIdentitySchemaZ.parse(ack)).toEqual(ack);
-  for (const bad of [
-    { connectionId: "0" },
-    { wrapperCommandId: "0" },
-    { wrapperCommandId: "18446744073709551616" },
-    { connectionId: "01" },
-    { text: "secret" },
-    { serverEpoch: "invalid" },
-    { operationId: "invalid" },
-  ])
-    expect(NativeOperationIdentitySchemaZ.safeParse({ ...ack, ...bad }).success).toBe(false);
-});

package/packages/contracts/src/workspace-admission.test.ts

@@ -1,21 +0,0 @@
-import { expect, it } from "vitest";
-import { WorkspaceAdmissionSnapshotSchemaZ } from "./workspace-admission.ts";
-const snapshot = {
-  pending: 0,
-  limit: 128,
-  disposed: false,
-  retained: 128,
-  retentionLimit: 128,
-  retentionMayBlock: false,
-};
-it("keeps admission separate from retained history and validates bounded diagnostic fields", () => {
-  expect(WorkspaceAdmissionSnapshotSchemaZ.parse(snapshot)).toEqual(snapshot);
-  for (const invalid of [
-    { ...snapshot, pending: -1 },
-    { ...snapshot, pending: Number.POSITIVE_INFINITY },
-    { ...snapshot, retained: Number.MAX_SAFE_INTEGER + 1 },
-    { ...snapshot, limit: 0 },
-    { ...snapshot, authToken: "secret" },
-  ])
-    expect(WorkspaceAdmissionSnapshotSchemaZ.safeParse(invalid).success).toBe(false);
-});