tmux-ide 2.9.2 → 2.9.4

package/packages/contracts/src/__tests__/missions.test.ts

@@ -1,272 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  MissionActorSchemaZ,
-  MissionAttemptIdSchemaZ,
-  MissionEventSchemaZ,
-  MissionIdSchemaZ,
-  MissionAttemptSchemaZ,
-  MissionProjectStateSchemaZ,
-  MissionSnapshotSchemaZ,
-  MissionProofSchemaZ,
-  MissionReferenceIdSchemaZ,
-  MissionStatusSchemaZ,
-  MissionTaskSchemaZ,
-  MissionTaskIdSchemaZ,
-  MissionTaskStatusSchemaZ,
-  MissionTerminalReferenceSchemaZ,
-} from "../domain.ts";
-
-const actor = { type: "user" as const, id: "pm" };
-
-describe("mission domain contracts", () => {
-  it("round-trips provider-neutral mission, task, attempt, and proof events", () => {
-    const events = [
-      {
-        version: 1,
-        type: "mission.created",
-        missionId: "mis_alpha",
-        title: "Ship durable missions",
-        objective: "Persist mission state",
-        acceptanceCriteria: ["replayable"],
-        constraints: ["harness-neutral"],
-        labels: ["m27"],
-        source: { type: "user", id: "sfora-card-114" },
-        actor,
-      },
-      {
-        version: 1,
-        type: "task.added",
-        missionId: "mis_alpha",
-        taskId: "tsk_contracts",
-        title: "Add contracts",
-        priority: 1,
-        dependencies: [],
-        assignee: "worker.profile",
-        actor,
-      },
-      {
-        version: 1,
-        type: "attempt.started",
-        missionId: "mis_alpha",
-        taskId: "tsk_contracts",
-        attemptId: "att_first",
-        agent: "worker.profile",
-        harness: "generic-harness",
-        model: "opaque/model-ref",
-        terminal: "%7",
-        session: "session_1",
-        worktree: "worktrees/task",
-        actor,
-      },
-      {
-        version: 1,
-        type: "proof.recorded",
-        missionId: "mis_alpha",
-        taskId: "tsk_contracts",
-        attemptId: "att_first",
-        proofId: "prf_tests",
-        proof: {
-          tests: [{ name: "contracts", status: "passed", passed: 12, total: 12 }],
-          commits: [{ sha: "abcdef1" }],
-          diff: { summary: "Added schemas", stats: { filesChanged: 2 } },
-          pr: { number: 114, status: "open" },
-          artifacts: [{ name: "log", uri: "runtime://artifact/log" }],
-          notes: "All checks passed",
-        },
-        actor,
-      },
-    ];
-
-    for (const event of events) {
-      expect(MissionEventSchemaZ.parse(event)).toEqual(event);
-    }
-  });
-
-  it("rejects malformed IDs, references, statuses, proofs, and event payloads", () => {
-    expect(MissionIdSchemaZ.safeParse("../mis").success).toBe(false);
-    expect(MissionTaskIdSchemaZ.safeParse("task-1").success).toBe(false);
-    expect(MissionAttemptIdSchemaZ.safeParse("att space").success).toBe(false);
-    expect(MissionReferenceIdSchemaZ.safeParse("../profile").success).toBe(false);
-    expect(MissionReferenceIdSchemaZ.safeParse("%7").success).toBe(false);
-    expect(MissionTerminalReferenceSchemaZ.safeParse("%7").success).toBe(true);
-    expect(MissionTerminalReferenceSchemaZ.safeParse("term_1").success).toBe(true);
-    for (const value of ["%", "%-1", "%abc", "%7 bad", "%7;send-keys", "%7\n"]) {
-      expect(MissionTerminalReferenceSchemaZ.safeParse(value).success).toBe(false);
-    }
-    expect(MissionTerminalReferenceSchemaZ.safeParse(`%${"7".repeat(21)}`).success).toBe(false);
-    expect(MissionStatusSchemaZ.safeParse("dispatching").success).toBe(false);
-    expect(MissionTaskStatusSchemaZ.safeParse("updated").success).toBe(false);
-    expect(MissionActorSchemaZ.safeParse({ type: "claude" }).success).toBe(false);
-    expect(MissionProofSchemaZ.safeParse({}).success).toBe(false);
-    expect(
-      MissionProofSchemaZ.safeParse({
-        tests: [{ name: "unit", status: "passed", passed: 2, total: 1 }],
-      }).success,
-    ).toBe(false);
-    expect(MissionProofSchemaZ.safeParse({ tests: [{ name: "", status: "passed" }] }).success).toBe(
-      false,
-    );
-    expect(
-      MissionEventSchemaZ.safeParse({
-        version: 2,
-        type: "mission.created",
-        missionId: "mis_alpha",
-        title: "x",
-        objective: "x",
-        acceptanceCriteria: [],
-        constraints: [],
-        labels: [],
-        source: { type: "user" },
-        actor,
-      }).success,
-    ).toBe(false);
-    expect(
-      MissionEventSchemaZ.safeParse({
-        version: 1,
-        type: "provider.claude.spawned",
-        missionId: "mis_alpha",
-        actor,
-      }).success,
-    ).toBe(false);
-  });
-
-  it("strictly parses projected task, attempt, and mission snapshots", () => {
-    const task = {
-      id: "tsk_contracts",
-      missionId: "mis_alpha",
-      title: "Contracts",
-      priority: 1,
-      dependencies: [],
-      status: "completed",
-      createdAt: "2026-01-01T00:00:00.000Z",
-      updatedAt: "2026-01-01T00:00:01.000Z",
-      proofIds: ["prf_tests"],
-      attemptIds: ["att_first"],
-    };
-    const attempt = {
-      id: "att_first",
-      missionId: "mis_alpha",
-      taskId: "tsk_contracts",
-      agent: "worker",
-      harness: "generic",
-      status: "approved",
-      outcome: "approved",
-      startedAt: "2026-01-01T00:00:00.000Z",
-      updatedAt: "2026-01-01T00:00:01.000Z",
-      proofIds: ["prf_tests"],
-    };
-
-    expect(MissionTaskSchemaZ.parse(task)).toEqual(task);
-    expect(MissionAttemptSchemaZ.parse(attempt)).toEqual(attempt);
-    expect(
-      MissionSnapshotSchemaZ.parse({
-        id: "mis_alpha",
-        title: "Alpha",
-        objective: "Ship",
-        acceptanceCriteria: [],
-        constraints: [],
-        labels: [],
-        source: { type: "user" },
-        status: "completed",
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:01.000Z",
-        tasks: { tsk_contracts: task },
-        attempts: { att_first: attempt },
-        proofs: { prf_tests: { noProofReason: "manual acceptance" } },
-      }),
-    ).toMatchObject({ tasks: { tsk_contracts: { status: "completed" } } });
-
-    expect(MissionTaskSchemaZ.safeParse({ ...task, extra: true }).success).toBe(false);
-    expect(MissionAttemptSchemaZ.safeParse({ ...attempt, provider: "claude" }).success).toBe(false);
-  });
-
-  it("rejects projected state with broken keys, references, or duplicate reference arrays", () => {
-    const validTask = {
-      id: "tsk_contracts",
-      missionId: "mis_alpha",
-      title: "Contracts",
-      priority: 1,
-      dependencies: [],
-      status: "completed",
-      createdAt: "2026-01-01T00:00:00.000Z",
-      updatedAt: "2026-01-01T00:00:01.000Z",
-      proofIds: ["prf_tests"],
-      attemptIds: ["att_first"],
-    };
-    const validAttempt = {
-      id: "att_first",
-      missionId: "mis_alpha",
-      taskId: "tsk_contracts",
-      agent: "worker",
-      harness: "generic",
-      status: "approved",
-      outcome: "approved",
-      startedAt: "2026-01-01T00:00:00.000Z",
-      updatedAt: "2026-01-01T00:00:01.000Z",
-      proofIds: ["prf_tests"],
-    };
-    const validMission = {
-      id: "mis_alpha",
-      title: "Alpha",
-      objective: "Ship",
-      acceptanceCriteria: [],
-      constraints: [],
-      labels: [],
-      source: { type: "user" },
-      status: "completed",
-      createdAt: "2026-01-01T00:00:00.000Z",
-      updatedAt: "2026-01-01T00:00:01.000Z",
-      tasks: { tsk_contracts: validTask },
-      attempts: { att_first: validAttempt },
-      proofs: { prf_tests: { noProofReason: "manual acceptance" } },
-    };
-
-    expect(
-      MissionProjectStateSchemaZ.safeParse({
-        sequence: 1,
-        missions: { mis_other: validMission },
-      }).success,
-    ).toBe(false);
-    expect(
-      MissionSnapshotSchemaZ.safeParse({
-        ...validMission,
-        tasks: { tsk_wrong: validTask },
-      }).success,
-    ).toBe(false);
-    expect(
-      MissionSnapshotSchemaZ.safeParse({
-        ...validMission,
-        tasks: {
-          tsk_contracts: {
-            ...validTask,
-            proofIds: ["prf_tests", "prf_tests"],
-          },
-        },
-      }).success,
-    ).toBe(false);
-    expect(
-      MissionSnapshotSchemaZ.safeParse({
-        ...validMission,
-        attempts: { att_first: { ...validAttempt, taskId: "tsk_missing" } },
-      }).success,
-    ).toBe(false);
-    expect(
-      MissionSnapshotSchemaZ.safeParse({
-        ...validMission,
-        tasks: {
-          tsk_contracts: {
-            ...validTask,
-            attemptIds: ["att_first"],
-          },
-        },
-        attempts: { att_first: { ...validAttempt, taskId: "tsk_missing" } },
-      }).success,
-    ).toBe(false);
-    expect(
-      MissionSnapshotSchemaZ.safeParse({
-        ...validMission,
-        attempts: { att_first: { ...validAttempt, proofIds: ["prf_missing"] } },
-      }).success,
-    ).toBe(false);
-  });
-});

package/packages/contracts/src/__tests__/multiplexer-verbs.test.ts

@@ -1,242 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { ActionContractsZ } from "../actions-contract.ts";
-import { AppWindowMutationCommandSchemaZ } from "../app-window-mutation.ts";
-import {
-  MULTIPLEXER_VERB_IDS,
-  MULTIPLEXER_VERB_TABLE,
-  MultiplexerVerbEntrySchemaZ,
-  isMultiplexerVerbId,
-  multiplexerVerb,
-  multiplexerVerbAvailability,
-  multiplexerVerbsForScope,
-  type MultiplexerVerbEntry,
-} from "../multiplexer-verbs.ts";
-
-const verb = (id: string): MultiplexerVerbEntry => {
-  const found = MULTIPLEXER_VERB_TABLE.find((entry) => entry.id === id);
-  if (!found) throw new Error(`missing verb ${id}`);
-  return found;
-};
-
-describe("the multiplexer verb table", () => {
-  it("carries every verb the milestone declares, and no others", () => {
-    expect([...MULTIPLEXER_VERB_IDS]).toEqual([
-      "window.link.select",
-      "window.link.unlink",
-      "session.new",
-      "session.kill",
-      "session.rename",
-      "session.detach",
-      "window.new",
-      "window.kill",
-      "window.rename",
-      "window.zoom.toggle",
-      "pane.split.right",
-      "pane.split.down",
-      "pane.kill",
-      "pane.select",
-      "pane.swap",
-      "pane.resize",
-      "stack.activate",
-    ]);
-  });
-
-  it("conforms to its own schema", () => {
-    for (const entry of MULTIPLEXER_VERB_TABLE) {
-      expect(() => MultiplexerVerbEntrySchemaZ.parse(entry)).not.toThrow();
-    }
-  });
-
-  it("is deeply frozen so no surface can edit the shared table", () => {
-    expect(Object.isFrozen(MULTIPLEXER_VERB_TABLE)).toBe(true);
-    for (const entry of MULTIPLEXER_VERB_TABLE) {
-      expect(Object.isFrozen(entry)).toBe(true);
-      expect(Object.isFrozen(entry.execution)).toBe(true);
-      expect(Object.isFrozen(entry.availabilityInputs)).toBe(true);
-    }
-  });
-
-  it("has unique ids", () => {
-    expect(new Set(MULTIPLEXER_VERB_IDS).size).toBe(MULTIPLEXER_VERB_IDS.length);
-  });
-
-  it("names only daemon actions that actually exist", () => {
-    for (const entry of MULTIPLEXER_VERB_TABLE) {
-      if (entry.execution.kind !== "daemon-action") continue;
-      expect(Object.keys(ActionContractsZ)).toContain(entry.execution.action);
-    }
-  });
-
-  it("names only AppWindow commands that actually exist", () => {
-    const commands = AppWindowMutationCommandSchemaZ.options.map(
-      (option) => option.shape.type.value,
-    );
-    for (const entry of MULTIPLEXER_VERB_TABLE) {
-      if (entry.execution.kind !== "app-window") continue;
-      expect(commands).toContain(entry.execution.command);
-    }
-  });
-
-  it("marks exactly the verbs that destroy something as destructive", () => {
-    const destructive = MULTIPLEXER_VERB_TABLE.filter((entry) => entry.destructive).map(
-      (entry) => entry.id,
-    );
-    expect(destructive).toEqual(["window.link.unlink", "session.kill", "window.kill", "pane.kill"]);
-  });
-
-  it("leaves every tmux key hint unfilled until the keybinding bridge exists", () => {
-    for (const entry of MULTIPLEXER_VERB_TABLE) {
-      expect(entry.tmuxKeyHint).toBeNull();
-    }
-  });
-
-  it("groups verbs by the object they act on", () => {
-    expect(multiplexerVerbsForScope("pane").map((entry) => entry.id)).toEqual([
-      "pane.split.right",
-      "pane.split.down",
-      "pane.kill",
-      "pane.select",
-      "pane.swap",
-      "pane.resize",
-    ]);
-  });
-
-  it("offers pane resize only where there is a border to move", () => {
-    const resize = verb("pane.resize");
-    expect(
-      multiplexerVerbAvailability(resize, { workspaceConnected: true, windowPaneCount: 2 }),
-    ).toEqual({ available: true });
-    // A one-pane window has no border: tmux would grow nothing, so the rule is
-    // stated up front rather than discovered by a drag that does nothing.
-    expect(
-      multiplexerVerbAvailability(resize, { workspaceConnected: true, windowPaneCount: 1 }),
-    ).toMatchObject({ available: false });
-  });
-
-  it("offers pane swap only when another pane exists in the window", () => {
-    const swap = verb("pane.swap");
-    expect(
-      multiplexerVerbAvailability(swap, { workspaceConnected: true, windowPaneCount: 2 }),
-    ).toEqual({ available: true });
-    expect(
-      multiplexerVerbAvailability(swap, { workspaceConnected: true, windowPaneCount: 1 }),
-    ).toMatchObject({ available: false });
-    expect(swap.execution).toEqual({
-      kind: "daemon-action",
-      action: "workspace.pane.swap",
-    });
-  });
-
-  it("recognises its own ids and rejects others", () => {
-    expect(isMultiplexerVerbId("pane.kill")).toBe(true);
-    expect(isMultiplexerVerbId("pane.obliterate")).toBe(false);
-    expect(isMultiplexerVerbId(7)).toBe(false);
-    expect(() => multiplexerVerb("pane.kill")).not.toThrow();
-  });
-
-  it("routes pane focus to tmux and stack activation to the layout document", () => {
-    // The distinction gap 10 turns on: one of these reaches the multiplexer.
-    expect(verb("pane.select").execution).toEqual({
-      kind: "daemon-action",
-      action: "workspace.pane.select",
-    });
-    expect(verb("stack.activate").execution).toEqual({
-      kind: "app-window",
-      command: "stack.activate",
-    });
-  });
-});
-
-describe("verb availability", () => {
-  const connected = { workspaceConnected: true } as const;
-
-  it("refuses a verb whose declared facts the surface did not gather", () => {
-    const result = multiplexerVerbAvailability(verb("pane.kill"), connected);
-    expect(result).toEqual({ available: false, reason: "windowPaneCount is unknown" });
-  });
-
-  it("offers nothing on a disconnected workspace", () => {
-    const result = multiplexerVerbAvailability(verb("window.rename"), {
-      workspaceConnected: false,
-    });
-    expect(result).toEqual({ available: false, reason: "the workspace is not connected" });
-  });
-
-  it("refuses to close a session's last window", () => {
-    expect(
-      multiplexerVerbAvailability(verb("window.kill"), { ...connected, sessionWindowCount: 1 }),
-    ).toEqual({ available: false, reason: "this is the session's last window" });
-    expect(
-      multiplexerVerbAvailability(verb("window.kill"), { ...connected, sessionWindowCount: 2 }),
-    ).toEqual({ available: true });
-  });
-
-  it("refuses to close a session's last pane but allows any other", () => {
-    const facts = { ...connected, windowPaneCount: 1, sessionWindowCount: 1 };
-    expect(multiplexerVerbAvailability(verb("pane.kill"), facts)).toEqual({
-      available: false,
-      reason: "this is the session's last pane",
-    });
-    // A split window's pane is closable, and so is a lone pane in a session
-    // that still has another window to fall back to.
-    expect(
-      multiplexerVerbAvailability(verb("pane.kill"), { ...facts, windowPaneCount: 2 }),
-    ).toEqual({ available: true });
-    expect(
-      multiplexerVerbAvailability(verb("pane.kill"), { ...facts, sessionWindowCount: 2 }),
-    ).toEqual({ available: true });
-  });
-
-  it("offers zoom for a split window, and for unzooming whatever the pane count says", () => {
-    expect(
-      multiplexerVerbAvailability(verb("window.zoom.toggle"), {
-        ...connected,
-        windowPaneCount: 1,
-        windowZoomed: false,
-      }),
-    ).toEqual({ available: false, reason: "this window has only one pane" });
-    expect(
-      multiplexerVerbAvailability(verb("window.zoom.toggle"), {
-        ...connected,
-        windowPaneCount: 2,
-        windowZoomed: false,
-      }),
-    ).toEqual({ available: true });
-    expect(
-      multiplexerVerbAvailability(verb("window.zoom.toggle"), {
-        ...connected,
-        windowPaneCount: 1,
-        windowZoomed: true,
-      }),
-    ).toEqual({ available: true });
-  });
-
-  it("does not offer focus on the pane that already has it", () => {
-    expect(
-      multiplexerVerbAvailability(verb("pane.select"), {
-        ...connected,
-        targetIsActivePane: true,
-      }),
-    ).toEqual({ available: false, reason: "this pane is already active" });
-    expect(
-      multiplexerVerbAvailability(verb("pane.select"), {
-        ...connected,
-        targetIsActivePane: false,
-      }),
-    ).toEqual({ available: true });
-  });
-
-  it("offers stack activation only inside a docked stack", () => {
-    expect(
-      multiplexerVerbAvailability(verb("stack.activate"), { targetIsDockedStackMember: true }),
-    ).toEqual({ available: true });
-    expect(
-      multiplexerVerbAvailability(verb("stack.activate"), { targetIsDockedStackMember: false }),
-    ).toEqual({ available: false, reason: "this window is not in a docked stack" });
-  });
-
-  it("offers a verb with no declared inputs unconditionally", () => {
-    expect(multiplexerVerbAvailability(verb("session.new"), {})).toEqual({ available: true });
-  });
-});

package/packages/contracts/src/__tests__/pane-appearance.test.ts

@@ -1,146 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  resolvePaneAppearance,
-  statusToneForDomainStatus,
-  type PaneVisualStateV1,
-} from "../pane-appearance.ts";
-
-const baseState = (): PaneVisualStateV1 => ({
-  structure: "docked",
-  applicationFocus: { pane: false, terminalInput: false, windowActive: true },
-  agentActivity: "idle",
-  domainStatus: "idle",
-  attention: "none",
-  layoutInteraction: {
-    editable: true,
-    selected: false,
-    dragging: false,
-    resizing: false,
-    previewing: false,
-  },
-  controlInteraction: {
-    hover: false,
-    focusVisible: false,
-    pressed: false,
-    disabled: false,
-    loading: false,
-  },
-});
-
-describe("pane appearance composition", () => {
-  it("maps canonical domain statuses to stable tones", () => {
-    expect(
-      Object.fromEntries(
-        (
-          ["idle", "running", "blocked", "review", "done", "disconnected", "recovering"] as const
-        ).map((status) => [status, statusToneForDomainStatus(status)]),
-      ),
-    ).toEqual({
-      idle: "neutral",
-      running: "info",
-      blocked: "warning",
-      review: "info",
-      done: "success",
-      disconnected: "danger",
-      recovering: "danger",
-    });
-  });
-
-  it("preserves focus, selection, attention, and action states in separate slots", () => {
-    const state: PaneVisualStateV1 = {
-      ...baseState(),
-      structure: "floating",
-      applicationFocus: { pane: true, terminalInput: true, windowActive: true },
-      agentActivity: "running",
-      domainStatus: "blocked",
-      attention: "destructive",
-      layoutInteraction: {
-        editable: true,
-        selected: true,
-        dragging: true,
-        resizing: false,
-        previewing: true,
-      },
-      controlInteraction: {
-        hover: true,
-        focusVisible: true,
-        pressed: true,
-        disabled: true,
-        loading: true,
-      },
-    };
-    const appearance = resolvePaneAppearance(state);
-
-    expect(appearance.header).toEqual(
-      expect.objectContaining({ surface: "headerActive", focused: true, attention: "destructive" }),
-    );
-    expect(appearance.border).toEqual({
-      role: "focused",
-      strength: "decisive",
-      ownsApplicationFocus: true,
-    });
-    expect(appearance.outerOutline).toEqual({
-      visible: true,
-      role: "selected",
-      intent: "layout-selection",
-    });
-    expect(appearance.status).toEqual({
-      domainStatus: "blocked",
-      domainTone: "warning",
-      attentionTone: "danger",
-      tone: "danger",
-      attention: "destructive",
-    });
-    expect(appearance.action).toEqual(
-      expect.objectContaining({
-        background: "disabled",
-        focusOutline: "focused",
-        hover: true,
-        pressed: true,
-        disabled: true,
-        loading: true,
-        interactive: false,
-      }),
-    );
-    expect(appearance.accessibility).toEqual(
-      expect.objectContaining({
-        focused: true,
-        terminalInputOwner: true,
-        layoutSelected: true,
-        hasAttention: true,
-        busy: true,
-        disabled: true,
-      }),
-    );
-  });
-
-  it("does not confuse terminal input ownership with application focus styling", () => {
-    const state = baseState();
-    state.applicationFocus = { pane: true, terminalInput: false, windowActive: true };
-    const appFocused = resolvePaneAppearance(state);
-    state.applicationFocus = { pane: true, terminalInput: true, windowActive: true };
-    const terminalFocused = resolvePaneAppearance(state);
-
-    expect(terminalFocused.border).toEqual(appFocused.border);
-    expect(terminalFocused.header).toEqual(appFocused.header);
-    expect(terminalFocused.accessibility.terminalInputOwner).toBe(true);
-  });
-
-  it("renders inactive-window focus quietly and remains pure", () => {
-    const state = baseState();
-    state.applicationFocus = { pane: true, terminalInput: true, windowActive: false };
-    state.attention = "warning";
-    const before = JSON.stringify(state);
-    const first = resolvePaneAppearance(state);
-    const second = resolvePaneAppearance(state);
-
-    expect(first).toEqual(second);
-    expect(JSON.stringify(state)).toBe(before);
-    expect(first.header).toEqual(expect.objectContaining({ surface: "header", text: "muted" }));
-    expect(first.border).toEqual({
-      role: "attention",
-      strength: "decisive",
-      ownsApplicationFocus: false,
-    });
-  });
-});