tmux-ide 2.9.2 → 2.9.4

package/packages/contracts/src/__tests__/experience-kernel-boundary.test.ts

@@ -1,113 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { builtinModules } from "node:module";
-import { dirname, extname, relative, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-import ts from "typescript";
-import { describe, expect, it } from "vitest";
-
-const SOURCE_ROOT = fileURLToPath(new URL("../", import.meta.url));
-const KERNEL_ENTRY_FILES = [
-  "application-shell.ts",
-  "experience-identifiers.ts",
-  "experience-shell.ts",
-  "visual-recipes.ts",
-  "visual-tokens.ts",
-  "pane-appearance.ts",
-  "focus-overlay.ts",
-  "cohesion-fixture.ts",
-] as const;
-const ALLOWED_EXTERNAL_IMPORTS = new Set(["zod"]);
-const NODE_IMPORTS = new Set(builtinModules.flatMap((name) => [name, name.replace(/^node:/u, "")]));
-const FORBIDDEN_LOCAL_SEGMENT =
-  /(?:^|[/._-])(?:cell|cells|dom|electron|geometry|opentui|pixel|pixels|pty|react|rect|solid|string-width|tmux|xterm)(?=$|[/._-])/iu;
-
-function resolveLocalImport(importer: string, specifier: string): string | null {
-  const candidate = resolve(dirname(importer), specifier);
-  for (const path of [candidate, `${candidate}.ts`, resolve(candidate, "index.ts")]) {
-    if (existsSync(path)) return path;
-  }
-  return null;
-}
-
-function displayPath(path: string): string {
-  return relative(SOURCE_ROOT, path).split(sep).join("/");
-}
-
-describe("experience-kernel import boundary", () => {
-  it("keeps the complete shared graph free of host, runtime, and terminal dependencies", () => {
-    const pending = KERNEL_ENTRY_FILES.map((file) => resolve(SOURCE_ROOT, file));
-    const visited = new Set<string>();
-    const findings: string[] = [];
-
-    while (pending.length > 0) {
-      const file = pending.pop()!;
-      if (visited.has(file)) continue;
-      visited.add(file);
-      const source = readFileSync(file, "utf8");
-      const preprocessed = ts.preProcessFile(source, true, true);
-      const specifiers = [
-        ...preprocessed.importedFiles.map(({ fileName }) => fileName),
-        ...preprocessed.typeReferenceDirectives.map(({ fileName }) => fileName),
-        ...preprocessed.libReferenceDirectives.map(({ fileName }) => fileName),
-      ];
-
-      for (const specifier of specifiers) {
-        const evidence = `${displayPath(file)} -> ${specifier}`;
-        if (!specifier.startsWith(".")) {
-          const packageName = specifier
-            .replace(/^node:/u, "")
-            .split("/")
-            .slice(0, specifier.startsWith("@") ? 2 : 1)
-            .join("/");
-          if (
-            specifier.startsWith("node:") ||
-            NODE_IMPORTS.has(specifier) ||
-            NODE_IMPORTS.has(packageName) ||
-            !ALLOWED_EXTERNAL_IMPORTS.has(packageName)
-          ) {
-            findings.push(evidence);
-          }
-          continue;
-        }
-
-        if (FORBIDDEN_LOCAL_SEGMENT.test(specifier)) findings.push(evidence);
-        const dependency = resolveLocalImport(file, specifier);
-        if (dependency === null) {
-          findings.push(`${evidence} (unresolved)`);
-          continue;
-        }
-        const outsideSource = relative(SOURCE_ROOT, dependency).startsWith(`..${sep}`);
-        if (outsideSource || extname(dependency) !== ".ts") {
-          findings.push(`${evidence} (outside shared TypeScript graph)`);
-          continue;
-        }
-        pending.push(dependency);
-      }
-    }
-
-    expect(findings).toEqual([]);
-    expect([...visited].map(displayPath).sort()).toEqual([
-      "agent-graph-overlay.ts",
-      "app-window-state.ts",
-      "application-shell.ts",
-      "cohesion-fixture.ts",
-      "commands.ts",
-      "daemon-wire.ts",
-      "desktop-missions.ts",
-      "desktop-workspace-name.ts",
-      "domain.ts",
-      "experience-identifiers.ts",
-      "experience-shell.ts",
-      "fleet-catalog.ts",
-      "focus-overlay.ts",
-      "interaction-evidence.ts",
-      "mission-projections.ts",
-      "owner-scope-identity.ts",
-      "pane-appearance.ts",
-      "pane-team.ts",
-      "semantic-identity.ts",
-      "visual-recipes.ts",
-      "visual-tokens.ts",
-    ]);
-  });
-});

package/packages/contracts/src/__tests__/experience-shell.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  CANONICAL_SHELL_AREAS,
-  CANONICAL_SURFACE_REGISTRY,
-  canonicalSurface,
-  commandsToOpenSurface,
-} from "../experience-shell.ts";
-import { VISUAL_RECIPE_REGISTRY } from "../visual-recipes.ts";
-
-describe("experience shell", () => {
-  it("keeps one canonical shell order", () => {
-    expect(CANONICAL_SHELL_AREAS.map(({ id }) => id)).toEqual([
-      "application-bar",
-      "sidebar",
-      "primary-navigation",
-      "context-actions",
-      "workspace-canvas",
-      "bottom-dock",
-      "status-strip",
-    ]);
-    expect(CANONICAL_SHELL_AREAS.map(({ order }) => order)).toEqual([0, 1, 2, 3, 4, 5, 6]);
-  });
-
-  it("keeps modes and tools in separate, stable registries", () => {
-    expect(CANONICAL_SURFACE_REGISTRY.map(({ id }) => id)).toEqual([
-      "home",
-      "terminals",
-      "files",
-      "changes",
-      "missions",
-      "activity",
-    ]);
-    expect(
-      CANONICAL_SURFACE_REGISTRY.filter(({ kind }) => kind === "primary-mode").map(({ id }) => id),
-    ).toEqual(["home", "terminals"]);
-    expect(
-      CANONICAL_SURFACE_REGISTRY.filter(({ kind }) => kind === "dock-tool").map(({ id }) => id),
-    ).toEqual(["files", "changes", "missions", "activity"]);
-    expect(new Set(CANONICAL_SURFACE_REGISTRY.map(({ shortcut }) => shortcut)).size).toBe(6);
-  });
-
-  it("converges direct, keyboard, and deep-link opening on semantic commands", () => {
-    expect(commandsToOpenSurface({ surface: "terminals" })).toEqual([
-      { id: "application.shell.mode.activate", args: { mode: "terminals" } },
-    ]);
-    expect(commandsToOpenSurface({ surface: "missions", resourceId: "mission.m31" })).toEqual([
-      { id: "application.shell.mode.activate", args: { mode: "terminals" } },
-      { id: "application.shell.dock.mode.set", args: { mode: "open" } },
-      { id: "application.shell.dock.activate", args: { tool: "missions" } },
-      {
-        id: "application.shell.resource.select",
-        args: { surface: "missions", resourceId: "mission.m31" },
-      },
-    ]);
-    expect(canonicalSurface("files").area).toBe("bottom-dock");
-    expect(Object.isFrozen(commandsToOpenSurface({ surface: "missions" }))).toBe(true);
-  });
-
-  it("keeps flat and elevated presentation intent explicit", () => {
-    expect(VISUAL_RECIPE_REGISTRY["pane-docked"].elevation).toBeNull();
-    expect(VISUAL_RECIPE_REGISTRY["workspace-canvas"].elevation).toBeNull();
-    expect(VISUAL_RECIPE_REGISTRY["pane-floating"].elevation).toBe("floating");
-    expect(VISUAL_RECIPE_REGISTRY["command-palette"].elevation).toBe("palette");
-  });
-});

package/packages/contracts/src/__tests__/fixtures/daemon-wire-v2.json

@@ -1,35 +0,0 @@
-{
-  "canonical": {
-    "pid": 4312,
-    "port": 4010,
-    "protocolVersion": 2,
-    "productVersion": "0.0.1",
-    "instanceId": "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-    "startedAt": "2026-07-20T12:34:56.123Z",
-    "bindHostname": "127.0.0.1",
-    "authToken": "fixture-token"
-  },
-  "health": {
-    "ok": true,
-    "protocolVersion": 2,
-    "productVersion": "0.0.1",
-    "uptime": 42
-  },
-  "healthz": {
-    "ok": true,
-    "protocolVersion": 2,
-    "productVersion": "0.0.1",
-    "uptimeMs": 42000
-  },
-  "identity": {
-    "ok": true,
-    "pid": 4312,
-    "protocolVersion": 2,
-    "productVersion": "0.0.1",
-    "instanceId": "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-    "startedAt": "2026-07-20T12:34:56.123Z"
-  },
-  "sessions": {
-    "sessions": [{ "name": "fixture-project", "dir": "/work/fixture-project" }]
-  }
-}

package/packages/contracts/src/__tests__/fixtures/daemon-wire-v3.json

@@ -1,35 +0,0 @@
-{
-  "canonical": {
-    "pid": 4312,
-    "port": 4010,
-    "protocolVersion": 3,
-    "productVersion": "0.0.1",
-    "instanceId": "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-    "startedAt": "2026-07-20T12:34:56.123Z",
-    "bindHostname": "127.0.0.1",
-    "authToken": "fixture-token"
-  },
-  "health": {
-    "ok": true,
-    "protocolVersion": 3,
-    "productVersion": "0.0.1",
-    "uptime": 42
-  },
-  "healthz": {
-    "ok": true,
-    "protocolVersion": 3,
-    "productVersion": "0.0.1",
-    "uptimeMs": 42000
-  },
-  "identity": {
-    "ok": true,
-    "pid": 4312,
-    "protocolVersion": 3,
-    "productVersion": "0.0.1",
-    "instanceId": "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-    "startedAt": "2026-07-20T12:34:56.123Z"
-  },
-  "sessions": {
-    "sessions": [{ "name": "fixture-project", "dir": "/work/fixture-project" }]
-  }
-}

package/packages/contracts/src/__tests__/fixtures/daemon-wire-v4.json

@@ -1,35 +0,0 @@
-{
-  "canonical": {
-    "pid": 4312,
-    "port": 4010,
-    "protocolVersion": 4,
-    "productVersion": "0.0.1",
-    "instanceId": "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-    "startedAt": "2026-07-20T12:34:56.123Z",
-    "bindHostname": "127.0.0.1",
-    "authToken": "fixture-token"
-  },
-  "health": {
-    "ok": true,
-    "protocolVersion": 4,
-    "productVersion": "0.0.1",
-    "uptime": 42
-  },
-  "healthz": {
-    "ok": true,
-    "protocolVersion": 4,
-    "productVersion": "0.0.1",
-    "uptimeMs": 42000
-  },
-  "identity": {
-    "ok": true,
-    "pid": 4312,
-    "protocolVersion": 4,
-    "productVersion": "0.0.1",
-    "instanceId": "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-    "startedAt": "2026-07-20T12:34:56.123Z"
-  },
-  "sessions": {
-    "sessions": [{ "name": "fixture-project", "dir": "/work/fixture-project" }]
-  }
-}

package/packages/contracts/src/__tests__/fixtures/scoped-receipt.ts

@@ -1,62 +0,0 @@
-/** Explicit synthetic inventory for tests of receipt rules unrelated to provenance. */
-export function scopedReceiptFixture<T extends Record<string, unknown>>(raw: T) {
-  const pane =
-    raw.operationKind === "workspace.pane.read" || raw.operationKind === "workspace.pane.send";
-  const id = "00000000-0000-4000-8000-000000000001";
-  const endpoint = (semanticPaneId: unknown) => ({
-    kind: "pane",
-    environmentId: id,
-    serverScope: { serverId: `tmux-server.${"a".repeat(32)}`, generation: id },
-    paneLifetimeId: id,
-    workspaceName: raw.workspaceName,
-    semanticPaneId,
-  });
-  const target = raw.target as { semanticPaneId?: unknown } | undefined;
-  const source = raw.sourceSemanticPaneId ? endpoint(raw.sourceSemanticPaneId) : null;
-  return {
-    ...raw,
-    evidence: pane
-      ? {
-          schemaVersion: 1,
-          interactionId: raw.operationId,
-          revision: raw.phase === "accepted" ? 0 : 1,
-          endpoints: { destination: endpoint(target?.semanticPaneId), source },
-          actor:
-            raw.origin === "external"
-              ? { kind: "unknown", reason: "stock-hook" }
-              : source
-                ? { kind: "cooperative", bindingId: id, agentRunId: null }
-                : { kind: "unknown", reason: "unbound-source" },
-          observation:
-            raw.origin === "external"
-              ? {
-                  kind: "stock-hook",
-                  command:
-                    raw.operationKind === "workspace.pane.read" ? "capture-pane" : "send-keys",
-                }
-              : raw.phase === "observed"
-                ? {
-                    kind: "cooperative-completion",
-                    operationId: raw.operationId,
-                    verification:
-                      raw.operationKind === "workspace.pane.read"
-                        ? "daemon-snapshot"
-                        : "daemon-input-enqueue",
-                  }
-                : { kind: "admission", operationId: raw.operationId },
-          effect:
-            raw.origin !== "external" && raw.phase === "observed"
-              ? {
-                  kind:
-                    raw.operationKind === "workspace.pane.read"
-                      ? "snapshot-produced"
-                      : "input-enqueued",
-                }
-              : { kind: "unknown" },
-          occurredAt: null,
-          timeBasis: "unknown",
-          receivedAt: raw.at,
-        }
-      : null,
-  };
-}

package/packages/contracts/src/__tests__/fleet-agent-graph.test.ts

@@ -1,231 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { AgentGraphOverlaySchemaZ } from "../agent-graph-overlay.ts";
-import {
-  fleetActivityToNodeStatus,
-  fleetDisplayNodeId,
-  fleetSessionGroupId,
-  projectFleetAgentGraphOverlay,
-  type FleetAgentGraphProjectionSession,
-} from "../fleet-agent-graph.ts";
-import {
-  FLEET_MAX_AGENTS_PER_SESSION,
-  FLEET_MAX_SESSIONS,
-  FLEET_MAX_TOTAL_AGENTS,
-} from "../fleet-catalog.ts";
-import { AGENT_ACTIVITY_IDS, type AgentActivity } from "../pane-appearance.ts";
-import { TerminalAttachmentSemanticPaneIdSchemaZ } from "../semantic-identity.ts";
-
-function agent(
-  token: string,
-  overrides: Partial<FleetAgentGraphProjectionSession["agents"][number]> = {},
-): FleetAgentGraphProjectionSession["agents"][number] {
-  return {
-    agentId: `agent.${token}`,
-    name: "reviewer",
-    activity: "running",
-    attention: false,
-    statusSource: "authority",
-    ...overrides,
-  };
-}
-
-function session(
-  token: string,
-  agents: FleetAgentGraphProjectionSession["agents"],
-): FleetAgentGraphProjectionSession {
-  return { sessionId: `session.${token}`, label: `fleet-${token.slice(0, 4)}`, agents };
-}
-
-const SESSION_A = "0123456789abcdef01";
-const SESSION_B = "fedcba9876543210ff";
-
-describe("fleetActivityToNodeStatus", () => {
-  it("is total over the activity union", () => {
-    for (const activity of AGENT_ACTIVITY_IDS) {
-      expect(() => fleetActivityToNodeStatus(activity)).not.toThrow();
-    }
-  });
-
-  it("maps each activity to its canvas status", () => {
-    const expected: Record<AgentActivity, string> = {
-      idle: "idle",
-      running: "working",
-      waiting: "blocked",
-      complete: "done",
-      failed: "blocked",
-      disconnected: "idle",
-    };
-    for (const activity of AGENT_ACTIVITY_IDS) {
-      expect(fleetActivityToNodeStatus(activity)).toBe(expected[activity]);
-    }
-  });
-});
-
-describe("fleet id derivation", () => {
-  it("keys nodes under the reserved non-attachable prefix", () => {
-    const nodeId = fleetDisplayNodeId(`agent.${SESSION_A}`);
-    expect(nodeId).toBe(`terminal.discovered.agent.${SESSION_A}`);
-  });
-
-  it("returns null for a malformed agent id", () => {
-    expect(fleetDisplayNodeId("%7")).toBeNull();
-    expect(fleetDisplayNodeId("agent.$bad")).toBeNull();
-  });
-
-  it("derives a group id from the session token", () => {
-    expect(fleetSessionGroupId(`session.${SESSION_A}`)).toBe(`group.${SESSION_A}`);
-  });
-
-  it("returns null for a malformed session id", () => {
-    expect(fleetSessionGroupId("$3")).toBeNull();
-  });
-});
-
-describe("projectFleetAgentGraphOverlay", () => {
-  it("projects an empty fleet to an empty, untruncated overlay", () => {
-    const result = projectFleetAgentGraphOverlay({ sessions: [] });
-    expect(result.truncated).toBe(false);
-    expect(Object.keys(result.overlay.nodes)).toHaveLength(0);
-    expect(result.overlay.groups).toHaveLength(0);
-    expect(result.overlay.edges).toHaveLength(0);
-    expect(AgentGraphOverlaySchemaZ.safeParse(result.overlay).success).toBe(true);
-  });
-
-  it("emits a group with no members for a session with zero agents", () => {
-    const result = projectFleetAgentGraphOverlay({ sessions: [session(SESSION_A, [])] });
-    expect(result.truncated).toBe(false);
-    expect(result.overlay.groups).toHaveLength(1);
-    expect(result.overlay.groups[0]!.id).toBe(`group.${SESSION_A}`);
-    expect(result.overlay.groups[0]!.memberWindowIds).toHaveLength(0);
-    expect(Object.keys(result.overlay.nodes)).toHaveLength(0);
-  });
-
-  it("projects agents across sessions into nodes, groups, and no edges", () => {
-    const result = projectFleetAgentGraphOverlay({
-      sessions: [
-        session(SESSION_A, [agent("aaaaaaaaaaaaaaaa01"), agent("aaaaaaaaaaaaaaaa02")]),
-        session(SESSION_B, [agent("bbbbbbbbbbbbbbbb01")]),
-      ],
-    });
-    expect(result.truncated).toBe(false);
-    expect(Object.keys(result.overlay.nodes)).toHaveLength(3);
-    expect(result.overlay.edges).toHaveLength(0);
-    expect(result.overlay.groups).toHaveLength(2);
-    const groupA = result.overlay.groups.find((group) => group.id === `group.${SESSION_A}`)!;
-    expect(groupA.memberWindowIds).toEqual([
-      "terminal.discovered.agent.aaaaaaaaaaaaaaaa01",
-      "terminal.discovered.agent.aaaaaaaaaaaaaaaa02",
-    ]);
-    expect(AgentGraphOverlaySchemaZ.safeParse(result.overlay).success).toBe(true);
-  });
-
-  it("carries status, attention, statusSource, and label onto the node", () => {
-    const result = projectFleetAgentGraphOverlay({
-      sessions: [
-        session(SESSION_A, [
-          agent("aaaaaaaaaaaaaaaa01", {
-            name: "planner",
-            activity: "waiting",
-            attention: true,
-            statusSource: "scrape",
-          }),
-        ]),
-      ],
-    });
-    const node = result.overlay.nodes["terminal.discovered.agent.aaaaaaaaaaaaaaaa01"]!;
-    expect(node.status).toBe("blocked");
-    expect(node.attention).toBe(true);
-    expect(node.statusSource).toBe("scrape");
-    expect(node.label).toBe("planner");
-  });
-
-  it("produces node ids that no attachment authority will accept", () => {
-    const result = projectFleetAgentGraphOverlay({
-      sessions: [session(SESSION_A, [agent("aaaaaaaaaaaaaaaa01")])],
-    });
-    for (const nodeId of Object.keys(result.overlay.nodes)) {
-      expect(TerminalAttachmentSemanticPaneIdSchemaZ.safeParse(nodeId).success).toBe(false);
-    }
-  });
-
-  it("collapses an agent id duplicated across sessions and reports truncation", () => {
-    const result = projectFleetAgentGraphOverlay({
-      sessions: [
-        session(SESSION_A, [agent("aaaaaaaaaaaaaaaa01")]),
-        session(SESSION_B, [agent("aaaaaaaaaaaaaaaa01")]),
-      ],
-    });
-    expect(result.truncated).toBe(true);
-    // The duplicate agent collapses to a single node; both session groups keep a
-    // reference to the one surviving node, and the overlay stays structurally valid.
-    expect(Object.keys(result.overlay.nodes)).toHaveLength(1);
-    const groupB = result.overlay.groups.find((group) => group.id === `group.${SESSION_B}`)!;
-    expect(groupB.memberWindowIds).toEqual(["terminal.discovered.agent.aaaaaaaaaaaaaaaa01"]);
-    expect(AgentGraphOverlaySchemaZ.safeParse(result.overlay).success).toBe(true);
-  });
-
-  it("skips a malformed session and marks truncation", () => {
-    const result = projectFleetAgentGraphOverlay({
-      sessions: [
-        { sessionId: "$bad", label: "broken", agents: [agent("aaaaaaaaaaaaaaaa01")] },
-        session(SESSION_A, [agent("aaaaaaaaaaaaaaaa02")]),
-      ],
-    });
-    expect(result.truncated).toBe(true);
-    expect(result.overlay.groups).toHaveLength(1);
-    expect(Object.keys(result.overlay.nodes)).toHaveLength(1);
-  });
-
-  it("skips a malformed agent id but keeps its session", () => {
-    const result = projectFleetAgentGraphOverlay({
-      sessions: [
-        session(SESSION_A, [
-          {
-            agentId: "%7",
-            name: "raw",
-            activity: "running",
-            attention: false,
-            statusSource: "unknown",
-          },
-          agent("aaaaaaaaaaaaaaaa02"),
-        ]),
-      ],
-    });
-    expect(result.truncated).toBe(true);
-    expect(result.overlay.groups).toHaveLength(1);
-    expect(Object.keys(result.overlay.nodes)).toHaveLength(1);
-  });
-
-  it("truncates sessions beyond the fleet session cap", () => {
-    const sessions = Array.from({ length: FLEET_MAX_SESSIONS + 5 }, (_unused, index) =>
-      session(`sessiontoken${String(index).padStart(6, "0")}`, []),
-    );
-    const result = projectFleetAgentGraphOverlay({ sessions });
-    expect(result.truncated).toBe(true);
-    expect(result.overlay.groups).toHaveLength(FLEET_MAX_SESSIONS);
-  });
-
-  it("truncates agents beyond the per-session cap", () => {
-    const agents = Array.from({ length: FLEET_MAX_AGENTS_PER_SESSION + 5 }, (_unused, index) =>
-      agent(`agenttoken000${String(index).padStart(6, "0")}`),
-    );
-    const result = projectFleetAgentGraphOverlay({ sessions: [session(SESSION_A, agents)] });
-    expect(result.truncated).toBe(true);
-    expect(result.overlay.groups[0]!.memberWindowIds).toHaveLength(FLEET_MAX_AGENTS_PER_SESSION);
-    expect(AgentGraphOverlaySchemaZ.safeParse(result.overlay).success).toBe(true);
-  });
-
-  it("truncates total agents beyond the fleet cap", () => {
-    let counter = 0;
-    const sessions = Array.from({ length: 6 }, (_unused, sessionIndex) => {
-      const agents = Array.from({ length: FLEET_MAX_AGENTS_PER_SESSION }, () =>
-        agent(`agenttoken${String(counter++).padStart(8, "0")}`),
-      );
-      return session(`sessiontoken${String(sessionIndex).padStart(6, "0")}`, agents);
-    });
-    const result = projectFleetAgentGraphOverlay({ sessions });
-    expect(result.truncated).toBe(true);
-    expect(Object.keys(result.overlay.nodes)).toHaveLength(FLEET_MAX_TOTAL_AGENTS);
-    expect(AgentGraphOverlaySchemaZ.safeParse(result.overlay).success).toBe(true);
-  });
-});