tmux-ide 2.9.2 → 2.9.3

package/packages/contracts/src/workspace-catalog-resource.test.ts

@@ -1,146 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  projectWorkspaceCatalogV2,
-  projectWorkspaceCatalogV3,
-} from "./workspace-catalog-resource.ts";
-
-const daemon = {
-  protocolVersion: 1,
-  productVersion: "2.8.0",
-  instanceId: "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-  startedAt: "2026-07-21T00:00:00.000Z",
-};
-const alphaFleetSessionId = "session.aaaaaaaaaaaaaaaaaaaa";
-
-describe("projectWorkspaceCatalogV2", () => {
-  it("keeps durable intent while publishing zero live sessions", () => {
-    expect(
-      projectWorkspaceCatalogV2(
-        daemon,
-        [{ workspaceName: "alpha", sessionName: "alpha", source: "project" }],
-        [],
-      ),
-    ).toEqual({
-      version: 2,
-      daemon,
-      intents: [
-        {
-          workspaceName: "alpha",
-          sessionName: "alpha",
-          source: "project",
-          availability: "stopped",
-        },
-      ],
-      liveSessions: [],
-    });
-  });
-
-  it("marks only an exactly observed tmux session live", () => {
-    const result = projectWorkspaceCatalogV2(
-      daemon,
-      [
-        { workspaceName: "alpha", sessionName: "alpha-live", source: "workspace" },
-        { workspaceName: "beta", sessionName: "beta", source: "project" },
-      ],
-      [
-        {
-          sessionName: "alpha-live",
-          fleetSessionId: alphaFleetSessionId,
-          paneCount: 2,
-        },
-      ],
-    );
-    expect(result.intents.map(({ availability }) => availability)).toEqual(["live", "stopped"]);
-    expect(result.liveSessions).toEqual([
-      {
-        sessionName: "alpha-live",
-        fleetSessionId: alphaFleetSessionId,
-        paneCount: 2,
-      },
-    ]);
-  });
-
-  it("requires a daemon-minted opaque id for every exact live-session route", () => {
-    expect(() =>
-      projectWorkspaceCatalogV2(
-        daemon,
-        [],
-        [
-          // @ts-expect-error Proves the runtime schema rejects the legacy identity-less row.
-          { sessionName: "alpha-live", paneCount: 2 },
-        ],
-      ),
-    ).toThrow();
-    expect(() =>
-      projectWorkspaceCatalogV2(
-        daemon,
-        [],
-        [{ sessionName: "alpha-live", fleetSessionId: "$1", paneCount: 2 }],
-      ),
-    ).toThrow();
-  });
-});
-
-describe("projectWorkspaceCatalogV3", () => {
-  it("adds a strict tmux-incarnation identity without weakening V2 routing", () => {
-    expect(
-      projectWorkspaceCatalogV3(
-        daemon,
-        [],
-        [
-          {
-            liveSessionId: "live-session.bbbbbbbbbbbbbbbbbbbb",
-            sessionName: "alpha-live",
-            fleetSessionId: alphaFleetSessionId,
-            paneCount: 2,
-          },
-        ],
-      ),
-    ).toMatchObject({
-      version: 3,
-      liveSessions: [
-        {
-          liveSessionId: "live-session.bbbbbbbbbbbbbbbbbbbb",
-          sessionName: "alpha-live",
-        },
-      ],
-    });
-
-    expect(() =>
-      projectWorkspaceCatalogV3(
-        daemon,
-        [],
-        [
-          {
-            liveSessionId: "alpha-live",
-            sessionName: "alpha-live",
-            fleetSessionId: alphaFleetSessionId,
-            paneCount: 2,
-          },
-        ],
-      ),
-    ).toThrow();
-
-    expect(() =>
-      projectWorkspaceCatalogV3(
-        daemon,
-        [],
-        [
-          {
-            liveSessionId: "live-session.bbbbbbbbbbbbbbbbbbbb",
-            sessionName: "alpha-live",
-            fleetSessionId: alphaFleetSessionId,
-            paneCount: 1,
-          },
-          {
-            liveSessionId: "live-session.bbbbbbbbbbbbbbbbbbbb",
-            sessionName: "beta-live",
-            fleetSessionId: "session.cccccccccccccccccccc",
-            paneCount: 1,
-          },
-        ],
-      ),
-    ).toThrow("duplicate live session identity");
-  });
-});

package/packages/core/src/agent-provisioning.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  projectProvisioningTargets,
-  provisioningPlacementForTarget,
-  targetFirstProvisioningStage,
-} from "./agent-provisioning.ts";
-
-describe("target-first provisioning", () => {
-  it("places the active semantic pane first and keeps unavailable workspaces visible", () => {
-    const targets = projectProvisioningTargets(
-      [
-        { name: "workspace.beta", label: "Beta", available: false },
-        { name: "workspace.alpha", label: "Alpha", available: true },
-      ],
-      { workspaceName: "workspace.alpha", semanticPaneId: "pane.editor", paneLabel: "Editor" },
-    );
-    expect(targets).toEqual([
-      expect.objectContaining({ kind: "pane", label: "Editor", workspaceName: "workspace.alpha" }),
-      expect.objectContaining({ kind: "workspace", label: "Alpha", available: true }),
-      expect.objectContaining({ kind: "workspace", label: "Beta", available: false }),
-    ]);
-  });
-
-  it("projects the same semantic placement for every renderer", () => {
-    expect(provisioningPlacementForTarget({ kind: "workspace", semanticPaneId: null })).toEqual({
-      kind: "window",
-    });
-    expect(
-      provisioningPlacementForTarget({ kind: "pane", semanticPaneId: "pane.editor" }, "down"),
-    ).toEqual({ kind: "split", direction: "down", targetSemanticPaneId: "pane.editor" });
-  });
-
-  it("moves through where, what, details without renderer state", () => {
-    const target = projectProvisioningTargets([
-      { name: "workspace.alpha", label: "Alpha", available: true },
-    ])[0]!;
-    expect(targetFirstProvisioningStage(null, null)).toBe("target");
-    expect(targetFirstProvisioningStage(target, null)).toBe("kind");
-    expect(targetFirstProvisioningStage(target, "agent")).toBe("details");
-  });
-});

package/packages/core/src/application-shell-session.test.ts

@@ -1,105 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  APPLICATION_SHELL_COMMAND_IDS,
-  COHESION_FIXTURE_V1,
-  applicationShellCommandInvocation,
-  type ApplicationShellProjectionInputV1,
-} from "@tmux-ide/contracts";
-
-import {
-  createApplicationShellReplayState,
-  projectApplicationShellSession,
-  reconcileApplicationShellReplayState,
-  reduceApplicationShellTransaction,
-} from "./application-shell-session.ts";
-
-function input(): ApplicationShellProjectionInputV1 {
-  return {
-    project: COHESION_FIXTURE_V1.project,
-    workspace: COHESION_FIXTURE_V1.workspace,
-    dock: COHESION_FIXTURE_V1.dock,
-    focus: { ...COHESION_FIXTURE_V1.focus, overlays: [] },
-    connection: COHESION_FIXTURE_V1.connection,
-  };
-}
-
-describe("application shell client session", () => {
-  it("applies a semantic command transaction identically for every renderer", () => {
-    const initial = createApplicationShellReplayState(input());
-    const source = { kind: "program" as const, surface: "parity-test" };
-    const transaction = reduceApplicationShellTransaction(initial, [
-      applicationShellCommandInvocation(
-        APPLICATION_SHELL_COMMAND_IDS.setDockMode,
-        { mode: "maximized" },
-        source,
-      ),
-      applicationShellCommandInvocation(
-        APPLICATION_SHELL_COMMAND_IDS.activateDockTool,
-        { tool: "changes" },
-        source,
-      ),
-    ]);
-
-    expect(transaction.state).toMatchObject({ dockMode: "maximized", activeDockTool: "changes" });
-    expect(
-      transaction.steps.map(({ previous, next }) => [previous.dockMode, next.dockMode]),
-    ).toEqual([
-      [initial.dockMode, "maximized"],
-      ["maximized", "maximized"],
-    ]);
-  });
-
-  it("keeps authority facts while projecting renderer-local view state", () => {
-    const authority = input();
-    const replay = {
-      ...createApplicationShellReplayState(authority),
-      activeMode: "home" as const,
-      dockMode: "maximized" as const,
-      activeDockTool: "changes" as const,
-    };
-
-    const projection = projectApplicationShellSession(authority, replay);
-    expect(projection.project).toEqual(authority.project);
-    expect(projection.sidebar.sessions).toHaveLength(authority.workspace.sidebar.sessions.length);
-    expect(projection.workspaceCanvas.activeMode).toBe("home");
-    expect(projection.bottomDock).toMatchObject({ mode: "maximized", activeTool: "changes" });
-  });
-
-  it("retains safe local state but rejects stale pane focus and resource selection", () => {
-    const previous = input();
-    const current = {
-      ...createApplicationShellReplayState(previous),
-      focus: {
-        ...previous.focus,
-        appFocusedPaneId: "pane.removed",
-        terminalInputPaneId: "pane.removed",
-      },
-      selectedResources: [{ surface: "terminals" as const, resourceId: "pane.removed" }],
-    };
-    const next = { ...previous, terminalInventory: { activeResourceId: null, resources: [] } };
-
-    const reconciled = reconcileApplicationShellReplayState(previous, next, current);
-    expect(reconciled.focus).toEqual(next.focus);
-    expect(reconciled.selectedResources).toEqual([]);
-  });
-
-  it("resets all renderer-local state when workspace authority changes", () => {
-    const previous = input();
-    const current = {
-      ...createApplicationShellReplayState(previous),
-      dockMode: "maximized" as const,
-    };
-    const next = {
-      ...previous,
-      workspace: {
-        ...previous.workspace,
-        id: "workspace.replacement",
-        activeMode: "home" as const,
-      },
-    };
-
-    expect(reconcileApplicationShellReplayState(previous, next, current)).toEqual(
-      createApplicationShellReplayState(next),
-    );
-  });
-});

package/packages/core/src/interaction-evidence.test.ts

@@ -1,134 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { InteractionEvidenceSchemaZ, type InteractionEvidence } from "@tmux-ide/contracts";
-import { canEnrichInteractionEvidence } from "./interaction-evidence.ts";
-
-const id = "00000000-0000-4000-8000-000000000001";
-const other = "00000000-0000-4000-8000-000000000002";
-const stock = InteractionEvidenceSchemaZ.parse({
-  schemaVersion: 1,
-  interactionId: id,
-  revision: 0,
-  endpoints: {
-    destination: {
-      kind: "pane",
-      environmentId: id,
-      serverScope: { serverId: `tmux-server.${"a".repeat(32)}`, generation: id },
-      paneLifetimeId: id,
-      workspaceName: "workspace.project",
-      semanticPaneId: "pane.editor",
-    },
-    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-28T10:00:00Z",
-});
-const native = InteractionEvidenceSchemaZ.parse({
-  ...stock,
-  revision: 1,
-  actor: {
-    kind: "native",
-    issuerId: id,
-    identity: "connection",
-    sourceBindingId: null,
-    classification: { kind: "viewer", bindingId: id },
-  },
-  observation: {
-    kind: "native-journal",
-    serverEpoch: id,
-    command: "send-keys",
-    commandId: id,
-    parentCommandId: null,
-    correlatedOperationId: null,
-    cursor: { epoch: id, sequence: "9007199254740993" },
-  },
-  effect: { kind: "input-enqueued" },
-});
-
-describe("monotonic interaction evidence", () => {
-  it("enriches a correlated stock command without changing its immutable endpoint", () => {
-    if (native.observation.kind !== "native-journal") throw Error("fixture");
-    expect(
-      canEnrichInteractionEvidence(stock, {
-        ...native,
-        observation: {
-          ...native.observation,
-          correlatedOperationId: stock.interactionId,
-        },
-      }),
-    ).toBe(true);
-    expect(canEnrichInteractionEvidence(native, native)).toBe(false);
-  });
-  it("does not correlate matching command, target and timestamp without explicit native proof", () => {
-    expect(canEnrichInteractionEvidence(stock, native)).toBe(false);
-  });
-  it("rejects endpoint, generation, lifetime, effect, actor and occurrence changes", () => {
-    const destination = stock.endpoints.destination;
-    const observation = native.observation;
-    if (destination.kind !== "pane" || observation.kind !== "native-journal")
-      throw Error("fixture");
-    const candidates = [
-      { interactionId: other },
-      { effect: { kind: "unknown" } },
-      { actor: stock.actor },
-      { occurredAt: native.receivedAt, timeBasis: "daemon" },
-      { receivedAt: "2026-09-28T09:00:00Z" },
-      ...[
-        { paneLifetimeId: other },
-        { environmentId: other },
-        { serverScope: { ...destination.serverScope, generation: other } },
-      ].map((patch) => ({
-        endpoints: {
-          ...native.endpoints,
-          destination: { ...destination, ...patch },
-        },
-      })),
-      ...[
-        { commandId: other },
-        { cursor: { epoch: other, sequence: "9007199254740994" } },
-        { cursor: { epoch: id, sequence: "9007199254740992" } },
-      ].map((patch) => ({ observation: { ...observation, ...patch } })),
-    ];
-    for (const patch of candidates)
-      expect(
-        canEnrichInteractionEvidence(native, {
-          ...native,
-          revision: 2,
-          ...patch,
-        } as InteractionEvidence),
-      ).toBe(false);
-  });
-  it("compares uint64 cursors precisely without Number conversion", () => {
-    if (native.observation.kind !== "native-journal") throw Error("fixture");
-    expect(
-      canEnrichInteractionEvidence(native, {
-        ...native,
-        revision: 2,
-        observation: {
-          ...native.observation,
-          cursor: { epoch: id, sequence: "9007199254740994" },
-        },
-      }),
-    ).toBe(true);
-  });
-  it("permits admitted completion but requires an explicit native operation correlation", () => {
-    const admitted: InteractionEvidence = {
-      ...stock,
-      observation: { kind: "admission", operationId: id },
-    };
-    expect(canEnrichInteractionEvidence(admitted, native)).toBe(false);
-    if (native.observation.kind !== "native-journal") throw Error("fixture");
-    expect(
-      canEnrichInteractionEvidence(admitted, {
-        ...native,
-        observation: {
-          ...native.observation,
-          correlatedOperationId: id,
-        },
-      }),
-    ).toBe(true);
-  });
-});

package/packages/core/src/interaction-flow.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  cycleWorkspaceFocusZone,
-  workspaceEscapeFocusTarget,
-  workspaceInteractionPresentation,
-  type WorkspaceInteractionContext,
-} from "./interaction-flow.ts";
-
-function context(
-  overrides: Partial<WorkspaceInteractionContext> = {},
-): WorkspaceInteractionContext {
-  return {
-    overlay: null,
-    surface: "terminals",
-    focusZone: "canvas",
-    dockMode: "open",
-    missionMode: "board",
-    editorFocus: "list",
-    editorFilterOpen: false,
-    diffFilterOpen: false,
-    homePromptOpen: false,
-    hosted: false,
-    ...overrides,
-  };
-}
-
-describe("renderer-neutral workspace interaction flow", () => {
-  it.each([
-    [context({ overlay: "dialog" }), "DIALOG", "dialog"],
-    [context({ overlay: "commands" }), "COMMANDS", "command palette"],
-    [context({ focusZone: "dock-tabs" }), "TOOL TABS", "tool tabs"],
-    [context({ surface: "files", editorFilterOpen: true }), "FILTER", "file filter"],
-    [context({ surface: "files", editorFocus: "editor" }), "EDITOR", "file editor"],
-    [context({ surface: "changes" }), "CHANGES", "changes"],
-    [context({ surface: "missions", missionMode: "detail" }), "MISSION", "mission detail"],
-    [context({ surface: "home" }), "HOME", "workspace list"],
-    [context(), "TERMINAL INPUT", "terminal"],
-  ] as const)("projects the active input owner", (input, mode, focus) => {
-    expect(workspaceInteractionPresentation(input)).toMatchObject({ mode, focus });
-  });
-
-  it("walks the same reversible focus ring for every renderer", () => {
-    expect(cycleWorkspaceFocusZone("canvas", "open")).toBe("dock-tabs");
-    expect(cycleWorkspaceFocusZone("dock-tabs", "open")).toBe("dock-body");
-    expect(cycleWorkspaceFocusZone("dock-body", "open")).toBe("canvas");
-    expect(cycleWorkspaceFocusZone("dock-tabs", "collapsed")).toBe("canvas");
-    expect(cycleWorkspaceFocusZone("canvas", "open", "previous")).toBe("dock-body");
-  });
-
-  it("advertises the tmux-safe focus key", () => {
-    expect(workspaceInteractionPresentation(context()).help).toContain("F8 focus tools");
-    expect(workspaceInteractionPresentation(context()).help).not.toContain("^tab");
-  });
-
-  it("backs out through local state before parent focus zones", () => {
-    expect(
-      workspaceEscapeFocusTarget({ focusZone: "dock-body", layer: "editor-input" }),
-    ).toBeNull();
-    expect(workspaceEscapeFocusTarget({ focusZone: "dock-body", layer: "editor-list" })).toBe(
-      "dock-tabs",
-    );
-    expect(workspaceEscapeFocusTarget({ focusZone: "dock-tabs", layer: "terminal" })).toBe(
-      "canvas",
-    );
-  });
-});