tmux-ide 2.9.2 → 2.9.4

package/packages/contracts/src/__tests__/interaction-evidence.test.ts

@@ -1,288 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  InteractionEvidenceSchemaZ,
-  InteractionObservationGapSchemaZ,
-  InteractionObservationStatusSchemaZ,
-  NativeInteractionSequenceSchemaZ,
-} from "../interaction-evidence.ts";
-
-const id = "00000000-0000-4000-8000-000000000001";
-const endpoint = {
-  kind: "pane",
-  environmentId: id,
-  serverScope: { serverId: `tmux-server.${"a".repeat(32)}`, generation: id },
-  paneLifetimeId: id,
-  workspaceName: "workspace.project",
-  semanticPaneId: "pane.editor",
-};
-const stock = {
-  schemaVersion: 1,
-  interactionId: id,
-  revision: 0,
-  endpoints: { destination: endpoint, 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 = {
-  ...stock,
-  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("interaction evidence", () => {
-  it("preserves truthful stock and bound native facts through strict round trips", () => {
-    for (const value of [stock, native])
-      expect(InteractionEvidenceSchemaZ.parse(JSON.parse(JSON.stringify(value)))).toEqual(value);
-  });
-  it("retains unresolved targets without recyclable native ids", () => {
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({
-        ...stock,
-        endpoints: {
-          source: null,
-          destination: {
-            kind: "unresolved-pane",
-            environmentId: id,
-            serverScope: endpoint.serverScope,
-            observationRef: id,
-          },
-        },
-      }).success,
-    ).toBe(true);
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({
-        ...stock,
-        endpoints: { source: null, destination: { ...endpoint, runtimePaneId: "%0" } },
-      }).success,
-    ).toBe(false);
-  });
-  it.each(["text", "argv", "pid", "credential", "contentHash"])(
-    "rejects unsolicited %s metadata",
-    (key) => {
-      expect(
-        InteractionEvidenceSchemaZ.safeParse({
-          ...native,
-          actor: { ...native.actor, [key]: "secret" },
-        }).success,
-      ).toBe(false);
-    },
-  );
-  it("rejects guessed actors, effects, viewer classification and wrong correlation", () => {
-    for (const value of [
-      { ...stock, effect: { kind: "input-enqueued" } },
-      { ...stock, endpoints: { ...stock.endpoints, source: endpoint } },
-      { ...native, actor: { ...native.actor, identity: "advertised-process" } },
-      { ...native, actor: { ...native.actor, sourceBindingId: id } },
-      { ...native, observation: { ...native.observation, command: "capture-pane" } },
-      {
-        ...native,
-        observation: {
-          ...native.observation,
-          correlatedOperationId: "00000000-0000-4000-8000-000000000002",
-        },
-      },
-      { ...stock, occurredAt: stock.receivedAt },
-    ])
-      expect(InteractionEvidenceSchemaZ.safeParse(value).success).toBe(false);
-  });
-  it("requires a resolved bound source for cooperative observations and matching completion evidence", () => {
-    const value = {
-      ...stock,
-      endpoints: { ...stock.endpoints, source: endpoint },
-      actor: { kind: "cooperative", bindingId: id, agentRunId: null },
-      observation: {
-        kind: "cooperative-completion",
-        operationId: id,
-        verification: "daemon-snapshot",
-      },
-      effect: { kind: "snapshot-produced" },
-    };
-    expect(InteractionEvidenceSchemaZ.safeParse(value).success).toBe(true);
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({ ...value, effect: { kind: "input-enqueued" } })
-        .success,
-    ).toBe(false);
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({ ...value, endpoints: stock.endpoints }).success,
-    ).toBe(false);
-  });
-});
-
-describe("observation coverage", () => {
-  it.each(["", "-1", "01", "abc", "18446744073709551616", "9".repeat(100)])(
-    "rejects unsafe cursor %s without throwing",
-    (sequence) => {
-      expect(NativeInteractionSequenceSchemaZ.safeParse(sequence).success).toBe(false);
-    },
-  );
-  it("retains uint64 precision and rejects reversed or malformed loss ranges", () => {
-    expect(NativeInteractionSequenceSchemaZ.parse("18446744073709551615")).toBe(
-      "18446744073709551615",
-    );
-    const gap = {
-      reason: "native-range-dropped",
-      at: stock.receivedAt,
-      range: { epoch: id, from: "2", to: "1" },
-    };
-    expect(InteractionObservationGapSchemaZ.safeParse(gap).success).toBe(false);
-    expect(
-      InteractionObservationGapSchemaZ.safeParse({ ...gap, range: { ...gap.range, from: "bad" } })
-        .success,
-    ).toBe(false);
-    expect(InteractionObservationGapSchemaZ.safeParse({ ...gap, range: null }).success).toBe(true);
-  });
-  it("does not advertise stock effect proof or complete coverage", () => {
-    const value = {
-      schemaVersion: 1,
-      environmentId: id,
-      serverScope: endpoint.serverScope,
-      method: "stock-hooks",
-      capabilityVersion: 1,
-      commands: ["send-keys", "capture-pane"],
-      effects: [],
-      coverage: "partial",
-      cursor: null,
-      lastGap: null,
-      droppedCount: null,
-    };
-    expect(InteractionObservationStatusSchemaZ.safeParse(value).success).toBe(true);
-    for (const change of [
-      { coverage: "declared-capabilities" },
-      { effects: ["input-enqueued"] },
-      { commands: ["paste-buffer"] },
-      { commands: ["send-keys", "send-keys"] },
-      { method: "unavailable" },
-    ])
-      expect(InteractionObservationStatusSchemaZ.safeParse({ ...value, ...change }).success).toBe(
-        false,
-      );
-  });
-});
-
-describe("native send-prefix evidence", () => {
-  it("preserves command kind and forbids stock claims of send-prefix coverage", () => {
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({
-        ...native,
-        observation: { ...native.observation, command: "send-prefix" },
-      }).success,
-    ).toBe(true);
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({
-        ...stock,
-        observation: { kind: "stock-hook", command: "send-prefix" },
-      }).success,
-    ).toBe(false);
-  });
-});
-
-describe("native orphan effects", () => {
-  it("retains direct effects without inventing a command identity", () => {
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({
-        ...native,
-        observation: { ...native.observation, command: "unknown", commandId: null },
-        effect: { kind: "input-enqueued" },
-      }).success,
-    ).toBe(true);
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({
-        ...native,
-        observation: { ...native.observation, command: "unknown", commandId: null },
-        effect: { kind: "snapshot-produced" },
-      }).success,
-    ).toBe(true);
-  });
-});
-
-describe("immutable native pane identity", () => {
-  const physical = {
-    kind: "native-pane",
-    environmentId: id,
-    serverScope: endpoint.serverScope,
-    serverEpoch: id,
-    paneBirthId: "9007199254740993",
-  };
-  it("retains physical birth without a semantic placement claim", () => {
-    const value = { ...native, endpoints: { source: null, destination: physical } };
-    expect(InteractionEvidenceSchemaZ.parse(value)).toEqual(value);
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({
-        ...value,
-        endpoints: { source: null, destination: { ...physical, workspaceName: "invented" } },
-      }).success,
-    ).toBe(false);
-  });
-  it.each(["0", "-1", "01", "18446744073709551616", "1.5"])(
-    "rejects invalid birth %s",
-    (paneBirthId) => {
-      expect(
-        InteractionEvidenceSchemaZ.safeParse({
-          ...native,
-          endpoints: { source: null, destination: { ...physical, paneBirthId } },
-        }).success,
-      ).toBe(false);
-    },
-  );
-  it("requires native observation with exactly matching server epoch", () => {
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({
-        ...stock,
-        endpoints: { source: null, destination: physical },
-      }).success,
-    ).toBe(false);
-    expect(
-      InteractionEvidenceSchemaZ.safeParse({
-        ...native,
-        endpoints: {
-          source: null,
-          destination: { ...physical, serverEpoch: "22222222-2222-4222-8222-222222222222" },
-        },
-      }).success,
-    ).toBe(false);
-  });
-});
-
-it("keeps immutable server birth independent from journal resets", () => {
-  const destination = {
-    kind: "native-pane",
-    environmentId: id,
-    serverScope: endpoint.serverScope,
-    serverEpoch: id,
-    paneBirthId: "3",
-  };
-  for (const journalEpoch of [
-    "22222222-2222-4222-8222-222222222222",
-    "33333333-3333-4333-8333-333333333333",
-  ]) {
-    const parsed = InteractionEvidenceSchemaZ.parse({
-      ...native,
-      endpoints: { source: null, destination },
-      observation: {
-        ...native.observation,
-        serverEpoch: id,
-        cursor: { epoch: journalEpoch, sequence: "1" },
-      },
-    });
-    expect(parsed.endpoints.destination).toEqual(destination);
-  }
-});

package/packages/contracts/src/__tests__/interaction-receipt-v2.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  InteractionReceiptV1SchemaZ,
-  InteractionReceiptV2SchemaZ,
-} from "../interaction-receipts.ts";
-const id = "00000000-0000-4000-8000-000000000001";
-const time = "2026-09-28T10:00:00.000Z";
-const receipt = {
-  type: "interaction.receipt",
-  sequence: 1,
-  operationId: id,
-  origin: "external",
-  workspaceName: "alpha",
-  sourceSemanticPaneId: null,
-  target: { kind: "pane", semanticPaneId: "pane.alpha" },
-  operationKind: "workspace.pane.send",
-  phase: "observed",
-  summary: { operationKind: "workspace.pane.send", observedOnly: true },
-  proof: { operationKind: "workspace.pane.send", observed: true, semanticPaneId: "pane.alpha" },
-  at: time,
-  resourceRevision: null,
-};
-const evidence = {
-  schemaVersion: 1,
-  interactionId: id,
-  revision: 0,
-  endpoints: {
-    destination: {
-      kind: "pane",
-      environmentId: id,
-      serverScope: { serverId: `tmux-server.${"a".repeat(32)}`, generation: id },
-      paneLifetimeId: id,
-      workspaceName: "alpha",
-      semanticPaneId: "pane.alpha",
-    },
-    source: null,
-  },
-  actor: { kind: "unknown", reason: "stock-hook" },
-  observation: { kind: "stock-hook", command: "send-keys" },
-  effect: { kind: "unknown" },
-  occurredAt: null,
-  timeBasis: "unknown",
-  receivedAt: time,
-};
-describe("versioned receipt scoped evidence", () => {
-  it("requires pane evidence while preserving an explicit strict legacy contract", () => {
-    expect(InteractionReceiptV1SchemaZ.safeParse(receipt).success).toBe(true);
-    expect(InteractionReceiptV1SchemaZ.safeParse({ ...receipt, evidence }).success).toBe(false);
-    expect(InteractionReceiptV2SchemaZ.safeParse(receipt).success).toBe(false);
-    expect(InteractionReceiptV2SchemaZ.safeParse({ ...receipt, evidence: null }).success).toBe(
-      false,
-    );
-    expect(InteractionReceiptV2SchemaZ.safeParse({ ...receipt, evidence }).success).toBe(true);
-  });
-  it("rejects mismatched target, operation correlation and command; stock cannot assert effects", () => {
-    for (const changed of [
-      { ...evidence, interactionId: "00000000-0000-4000-8000-000000000002" },
-      {
-        ...evidence,
-        endpoints: {
-          ...evidence.endpoints,
-          destination: { ...evidence.endpoints.destination, workspaceName: "other" },
-        },
-      },
-      { ...evidence, observation: { kind: "stock-hook", command: "capture-pane" } },
-      { ...evidence, effect: { kind: "input-enqueued" } },
-    ])
-      expect(InteractionReceiptV2SchemaZ.safeParse({ ...receipt, evidence: changed }).success).toBe(
-        false,
-      );
-  });
-});

package/packages/contracts/src/__tests__/issue-error.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  LEGACY_TERMINAL_ISSUE_ERROR_CODES,
-  PaneStreamIssueErrorSchemaZ,
-  PaneStreamIssueResultSchemaZ,
-  TERMINAL_ISSUE_ERROR_CODES,
-  TerminalAttachmentIssueErrorCodeSchemaZ,
-  TerminalAttachmentIssueErrorSchemaZ,
-  TerminalIssueErrorCodeSchemaZ,
-  TerminalIssueErrorSchemaZ,
-} from "../index.ts";
-
-describe("the shared issue-error vocabulary", () => {
-  it("is one enum wearing two names", () => {
-    expect(TerminalAttachmentIssueErrorCodeSchemaZ).toBe(TerminalIssueErrorCodeSchemaZ);
-    expect(TerminalAttachmentIssueErrorSchemaZ).toBe(TerminalIssueErrorSchemaZ);
-    for (const code of TERMINAL_ISSUE_ERROR_CODES) {
-      expect(TerminalIssueErrorCodeSchemaZ.parse(code)).toBe(code);
-    }
-  });
-
-  it("gives the pane-stream path the members it used to lack", () => {
-    for (const code of [
-      "daemon-degraded",
-      "request-timeout",
-      "response-too-large",
-      "invalid-response",
-      "pane-not-attachable",
-      "preview-only",
-    ]) {
-      expect(
-        PaneStreamIssueErrorSchemaZ.parse({
-          code,
-          reason: "A pane stream could not be issued.",
-          retryable: false,
-        }).code,
-      ).toBe(code);
-    }
-  });
-
-  it("accepts a pre-merge daemon's legacy pane-stream literal and normalizes it", () => {
-    expect(LEGACY_TERMINAL_ISSUE_ERROR_CODES["stream-unavailable"]).toBe("attachment-unavailable");
-    expect(
-      PaneStreamIssueResultSchemaZ.parse({
-        status: "error",
-        error: {
-          code: "stream-unavailable",
-          reason: "Pane streaming is unavailable.",
-          retryable: true,
-        },
-      }),
-    ).toMatchObject({ error: { code: "attachment-unavailable" } });
-    // The attachment path never spoke the legacy literal, so it never accepts it.
-    expect(
-      TerminalAttachmentIssueErrorSchemaZ.safeParse({
-        code: "stream-unavailable",
-        reason: "Pane streaming is unavailable.",
-        retryable: true,
-      }).success,
-    ).toBe(false);
-  });
-
-  it("keeps one credential-redaction discipline for both lease families", () => {
-    for (const reason of [
-      "Authorization was Bearer owner-secret",
-      `The redemptionTicket was ta1_${"A".repeat(43)}`,
-      `The redemptionTicket was ps2_${"A".repeat(43)}`,
-      "ownerToken=secret",
-    ]) {
-      for (const schema of [TerminalAttachmentIssueErrorSchemaZ, PaneStreamIssueErrorSchemaZ]) {
-        expect(schema.safeParse({ code: "request-failed", reason, retryable: false }).success).toBe(
-          false,
-        );
-      }
-    }
-  });
-});

package/packages/contracts/src/__tests__/mission-projections.test.ts

@@ -1,186 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  MissionBoardViewSchemaZ,
-  MissionDetailViewSchemaZ,
-  MissionHistorySummarySchemaZ,
-  MissionTimelineEntrySchemaZ,
-  type MissionCardView,
-  type MissionProofSummary,
-} from "../mission-projections.ts";
-
-const proofSummary: MissionProofSummary = {
-  proofIds: ["prf_one"],
-  hasProof: true,
-  noProofReasons: [],
-  notesCount: 1,
-  tests: { suites: 1, passed: 1, failed: 0, skipped: 0, total: 3 },
-  commits: ["abcdef1"],
-  diff: {
-    summaries: ["Added read models"],
-    urls: ["https://example.test/diff"],
-    filesChanged: 2,
-    insertions: 10,
-    deletions: 1,
-  },
-  prs: [{ number: 116, url: "https://example.test/pr/116", status: "open" }],
-  artifacts: [{ name: "log", uri: "artifact://log", kind: "text" }],
-};
-
-const missionCard: MissionCardView = {
-  version: 1,
-  id: "mis_alpha",
-  title: "Alpha",
-  summary: "Ship alpha",
-  status: "completed",
-  column: "done",
-  labels: ["m27"],
-  createdAt: "2026-01-01T00:00:00.000Z",
-  updatedAt: "2026-01-01T00:00:10.000Z",
-  startedAt: "2026-01-01T00:00:01.000Z",
-  finishedAt: "2026-01-01T00:00:10.000Z",
-  durationMs: 9000,
-  progress: {
-    total: 1,
-    planned: 0,
-    running: 0,
-    blocked: 0,
-    review: 0,
-    completed: 1,
-    failed: 0,
-    cancelled: 0,
-    done: 1,
-  },
-  blockedBy: [],
-  latestAttempt: {
-    id: "att_one",
-    taskId: "tsk_one",
-    status: "approved",
-    outcome: "approved",
-    agent: "agent/a",
-    harness: "generic",
-    startedAt: "2026-01-01T00:00:02.000Z",
-    updatedAt: "2026-01-01T00:00:09.000Z",
-    finishedAt: "2026-01-01T00:00:09.000Z",
-    durationMs: 7000,
-    proofIds: ["prf_one"],
-  },
-  proofSummary,
-  refs: {
-    missionId: "mis_alpha",
-    taskIds: ["tsk_one"],
-    attemptIds: ["att_one"],
-    proofIds: ["prf_one"],
-  },
-};
-
-describe("mission projection contracts", () => {
-  it("strictly parses versioned board, detail, history, and timeline views", () => {
-    const task = {
-      version: 1,
-      id: "tsk_one",
-      missionId: "mis_alpha",
-      title: "Task",
-      summary: "Task",
-      status: "completed",
-      column: "done",
-      priority: 1,
-      dependencies: [],
-      blockedBy: [],
-      createdAt: "2026-01-01T00:00:01.000Z",
-      updatedAt: "2026-01-01T00:00:09.000Z",
-      startedAt: "2026-01-01T00:00:02.000Z",
-      finishedAt: "2026-01-01T00:00:09.000Z",
-      durationMs: 7000,
-      latestAttempt: missionCard.latestAttempt,
-      proofSummary,
-      refs: {
-        missionId: "mis_alpha",
-        taskId: "tsk_one",
-        attemptIds: ["att_one"],
-        proofIds: ["prf_one"],
-      },
-    };
-    const timeline = {
-      version: 1,
-      sequence: 1,
-      timestamp: "2026-01-01T00:00:00.000Z",
-      missionId: "mis_alpha",
-      type: "mission.created",
-      label: "Mission created",
-      actor: { type: "user", id: "pm" },
-      refs: { missionId: "mis_alpha" },
-    };
-
-    expect(
-      MissionBoardViewSchemaZ.parse({
-        version: 1,
-        columns: { planned: [], running: [], blocked: [], review: [], done: [missionCard] },
-        counts: { planned: 0, running: 0, blocked: 0, review: 0, done: 1, total: 1 },
-      }),
-    ).toMatchObject({ counts: { total: 1 } });
-    expect(
-      MissionDetailViewSchemaZ.parse({
-        version: 1,
-        mission: missionCard,
-        taskBoard: {
-          columns: { planned: [], running: [], blocked: [], review: [], done: [task] },
-          counts: { planned: 0, running: 0, blocked: 0, review: 0, done: 1, total: 1 },
-        },
-        attempts: [missionCard.latestAttempt],
-        proofSummary,
-        progress: missionCard.progress,
-        timeline: [timeline],
-      }),
-    ).toMatchObject({ mission: { id: "mis_alpha" } });
-    expect(MissionTimelineEntrySchemaZ.parse(timeline)).toEqual(timeline);
-    expect(
-      MissionHistorySummarySchemaZ.parse({
-        version: 1,
-        mission: missionCard,
-        outcome: "completed",
-        startedAt: "2026-01-01T00:00:01.000Z",
-        finishedAt: "2026-01-01T00:00:10.000Z",
-        durationMs: 9000,
-        taskTotals: missionCard.progress,
-        attemptTotals: {
-          total: 1,
-          submitted: 0,
-          approved: 1,
-          rejected: 0,
-          failed: 0,
-          interrupted: 0,
-          running: 0,
-        },
-        proofSummary,
-        lastEvent: timeline,
-      }),
-    ).toMatchObject({ outcome: "completed" });
-  });
-
-  it("rejects stale versions, arbitrary raw fields, and duplicate navigation references", () => {
-    expect(MissionBoardViewSchemaZ.safeParse({ version: 2, columns: {}, counts: {} }).success).toBe(
-      false,
-    );
-    expect(MissionBoardViewSchemaZ.safeParse({ ...missionCard, rawEvidence: {} }).success).toBe(
-      false,
-    );
-    expect(
-      MissionBoardViewSchemaZ.safeParse({
-        version: 1,
-        columns: {
-          planned: [],
-          running: [],
-          blocked: [],
-          review: [],
-          done: [
-            {
-              ...missionCard,
-              refs: { ...missionCard.refs, proofIds: ["prf_one", "prf_one"] },
-            },
-          ],
-        },
-        counts: { planned: 0, running: 0, blocked: 0, review: 0, done: 1, total: 1 },
-      }).success,
-    ).toBe(false);
-  });
-});