tmux-ide 2.9.2 → 2.9.3

package/packages/contracts/src/__tests__/daemon-events.test.ts

@@ -1,405 +0,0 @@
-import { scopedReceiptFixture } from "./fixtures/scoped-receipt.ts";
-import { describe, expect, it } from "vitest";
-import { DaemonEventClientFrameSchemaZ, DaemonEventServerFrameSchemaZ } from "../daemon-events.ts";
-
-describe("daemon event contracts", () => {
-  it("accepts strict privacy-safe interaction receipts and rejects literal input", () => {
-    const receipt = scopedReceiptFixture({
-      type: "interaction.receipt",
-      sequence: 8,
-      operationId: "10000000-0000-4000-8000-000000000001",
-      origin: "sdk",
-      workspaceName: "workspace.alpha",
-      sourceSemanticPaneId: null,
-      target: { kind: "pane", semanticPaneId: "pane.editor" },
-      operationKind: "workspace.pane.send",
-      phase: "observed",
-      summary: {
-        operationKind: "workspace.pane.send",
-        characterCount: 14,
-        byteCount: 14,
-        submitted: true,
-      },
-      proof: {
-        operationKind: "workspace.pane.send",
-        observed: true,
-        semanticPaneId: "pane.editor",
-      },
-      at: "2026-08-10T10:00:00.000Z",
-      resourceRevision: null,
-    } as const);
-    expect(DaemonEventServerFrameSchemaZ.parse(receipt)).toEqual(receipt);
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({ ...receipt, text: "private prompt" }).success,
-    ).toBe(false);
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        ...receipt,
-        summary: { ...receipt.summary, prefix: "private" },
-      }).success,
-    ).toBe(false);
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse(
-        scopedReceiptFixture({
-          ...receipt,
-          origin: "external",
-          operationKind: "workspace.pane.read",
-          phase: "observed",
-          summary: { operationKind: "workspace.pane.read", observedOnly: true },
-          proof: {
-            operationKind: "workspace.pane.read",
-            observed: true,
-            semanticPaneId: "pane.editor",
-          },
-        }),
-      ).success,
-    ).toBe(true);
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        ...receipt,
-        operationKind: "workspace.pane.read",
-        summary: receipt.summary,
-        proof: {
-          operationKind: "workspace.pane.read",
-          observed: true,
-          semanticPaneId: "pane.editor",
-        },
-      }).success,
-    ).toBe(false);
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse(
-        scopedReceiptFixture({
-          ...receipt,
-          origin: "external",
-          phase: "observed",
-          summary: { operationKind: "workspace.pane.send", observedOnly: true },
-        }),
-      ).success,
-    ).toBe(true);
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        ...receipt,
-        origin: "external",
-        sourceSemanticPaneId: "pane.source",
-        phase: "observed",
-        summary: { observedOnly: true },
-      }).success,
-    ).toBe(false);
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        ...receipt,
-        sourceSemanticPaneId: "pane.source",
-        phase: "accepted",
-      }).success,
-    ).toBe(false);
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        ...receipt,
-        summary: { observedOnly: true, characterCount: 14 },
-      }).success,
-    ).toBe(false);
-  });
-  const daemon = {
-    protocolVersion: 1,
-    productVersion: "2.8.0",
-    instanceId: "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-    startedAt: "2026-07-21T00:00:00.000Z",
-  } as const;
-
-  it("accepts every client frame and rejects missing or extra fields", () => {
-    expect(
-      DaemonEventClientFrameSchemaZ.parse({ type: "subscribe", sessions: ["tmux-ide"] }),
-    ).toEqual({ type: "subscribe", sessions: ["tmux-ide"] });
-    expect(
-      DaemonEventClientFrameSchemaZ.parse({
-        type: "subscribe",
-        sessions: ["tmux-ide"],
-        afterSequence: 41,
-        legacyEvents: false,
-        interestRevision: 7,
-        interests: [
-          { resource: "application-shell", workspaceName: "tmux-ide" },
-          { resource: "fleet-catalog", workspaceName: null },
-        ],
-      }),
-    ).toEqual({
-      type: "subscribe",
-      sessions: ["tmux-ide"],
-      afterSequence: 41,
-      legacyEvents: false,
-      interestRevision: 7,
-      interests: [
-        { resource: "application-shell", workspaceName: "tmux-ide" },
-        { resource: "fleet-catalog", workspaceName: null },
-      ],
-    });
-    expect(
-      DaemonEventClientFrameSchemaZ.safeParse({ type: "unsubscribe", sessions: [] }).success,
-    ).toBe(true);
-    expect(
-      DaemonEventClientFrameSchemaZ.safeParse({
-        type: "unsubscribe",
-        sessions: [],
-        legacyEvents: true,
-        interestRevision: 8,
-      }).success,
-    ).toBe(true);
-    expect(DaemonEventClientFrameSchemaZ.safeParse({ type: "ping" }).success).toBe(true);
-
-    expect(DaemonEventClientFrameSchemaZ.safeParse({ type: "subscribe" }).success).toBe(false);
-    expect(
-      DaemonEventClientFrameSchemaZ.safeParse({
-        type: "subscribe",
-        sessions: [],
-        afterSequence: -1,
-      }).success,
-    ).toBe(false);
-    expect(
-      DaemonEventClientFrameSchemaZ.safeParse({
-        type: "subscribe",
-        sessions: [],
-        typo: true,
-      }).success,
-    ).toBe(false);
-    expect(DaemonEventClientFrameSchemaZ.safeParse({ type: "ping", sessions: [] }).success).toBe(
-      false,
-    );
-    expect(
-      DaemonEventClientFrameSchemaZ.safeParse({
-        type: "subscribe",
-        sessions: [],
-        interests: [{ resource: "workspace-files", workspaceName: null }],
-      }).success,
-    ).toBe(false);
-    expect(
-      DaemonEventClientFrameSchemaZ.safeParse({
-        type: "subscribe",
-        sessions: [],
-        interests: [{ resource: "fleet-catalog", workspaceName: "tmux-ide" }],
-      }).success,
-    ).toBe(false);
-  });
-
-  it("strictly parses replayable resource invalidations and gap recovery", () => {
-    const changed = {
-      type: "resource.changed",
-      sequence: 42,
-      workspaceName: "tmux-ide",
-      resource: "application-shell",
-      revision: 8,
-      causeOperationId: "10000000-0000-4000-8000-000000000001",
-    } as const;
-    expect(DaemonEventServerFrameSchemaZ.parse(changed)).toEqual(changed);
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...changed, sequence: 0 }).success).toBe(
-      false,
-    );
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({ ...changed, resource: "everything" }).success,
-    ).toBe(false);
-    expect(
-      DaemonEventServerFrameSchemaZ.parse({ type: "resource.observed", sequence: 43 }),
-    ).toEqual({ type: "resource.observed", sequence: 43 });
-    const ack = {
-      type: "resource.interests-ack",
-      interestRevision: 9,
-      sequence: 43,
-      unavailableInterests: [{ resource: "workspace-missions", workspaceName: "tmux-ide" }],
-    } as const;
-    expect(DaemonEventServerFrameSchemaZ.parse(ack)).toEqual(ack);
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...ack, interestRevision: 0 }).success).toBe(
-      false,
-    );
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({ ...changed, causeOperationId: null }).success,
-    ).toBe(true);
-
-    const gap = {
-      type: "snapshot-required",
-      afterSequence: 1,
-      oldestAvailableSequence: 20,
-      currentSequence: 42,
-      reason: "journal-gap",
-    } as const;
-    expect(DaemonEventServerFrameSchemaZ.parse(gap)).toEqual(gap);
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...gap, reason: "unknown" }).success).toBe(
-      false,
-    );
-  });
-
-  it("strictly parses snapshots and protocol errors", () => {
-    const snapshot = {
-      type: "snapshot",
-      sessionName: "tmux-ide",
-      data: {
-        project: {
-          session: "tmux-ide",
-          dir: "/repo/tmux-ide",
-          panes: [],
-        },
-      },
-    } as const;
-    expect(DaemonEventServerFrameSchemaZ.parse(snapshot)).toEqual(snapshot);
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...snapshot, unexpected: true }).success).toBe(
-      false,
-    );
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        ...snapshot,
-        data: { project: { ...snapshot.data.project, unexpected: true } },
-      }).success,
-    ).toBe(false);
-
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        type: "protocol.error",
-        code: "invalid-frame",
-        message: "Client frame does not match the daemon event protocol.",
-      }).success,
-    ).toBe(true);
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        type: "protocol.error",
-        code: "unknown",
-        message: "nope",
-      }).success,
-    ).toBe(false);
-  });
-
-  it("keeps every historical server discriminator parseable", () => {
-    const frames = [
-      { type: "hello", daemon, sessions: [] },
-      { type: "sessions.changed" },
-      { type: "projects.changed" },
-      { type: "init.output", jobId: "job-1", chunk: "working", done: false },
-      { type: "init.error", jobId: "job-1", message: "failed" },
-      { type: "pong" },
-      { type: "action.complete", name: "project.launch", result: { ok: true } },
-      { type: "config.changed", sessionName: "tmux-ide" },
-      { type: "terminals.changed", sessionName: "tmux-ide" },
-      { type: "agent-status.changed", sessionName: "tmux-ide" },
-      {
-        type: "agent.turn-completed",
-        sessionName: "tmux-ide",
-        agentId: "agent.0123456789abcdef0123",
-        fromStatus: "working",
-        toStatus: "done",
-        at: "2026-07-23T12:00:00.000Z",
-      },
-      {
-        type: "workspace.promotion-completed",
-        workspaceName: "tmux-ide",
-        outcome: "promoted",
-        at: "2026-07-23T12:00:00.000Z",
-      },
-      {
-        type: "workspace.added",
-        workspace: {
-          name: "tmux-ide",
-          sessionName: "tmux-ide",
-          projectDir: "/repo/tmux-ide",
-          ideConfigPath: null,
-          addedAt: "2026-07-21T12:00:00.000Z",
-        },
-      },
-      { type: "workspace.removed", name: "tmux-ide" },
-    ];
-
-    for (const frame of frames) {
-      expect(DaemonEventServerFrameSchemaZ.safeParse(frame).success, frame.type).toBe(true);
-    }
-  });
-
-  it("requires a strict non-secret daemon generation on hello", () => {
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({ type: "hello", daemon, sessions: [] }).success,
-    ).toBe(true);
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ type: "hello", sessions: [] }).success).toBe(
-      false,
-    );
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        type: "hello",
-        daemon: { ...daemon, authToken: "must-not-cross-wire" },
-        sessions: [],
-      }).success,
-    ).toBe(false);
-  });
-
-  it("strictly parses agent.turn-completed and rejects unsafe or unbounded shapes", () => {
-    const receipt = {
-      type: "agent.turn-completed",
-      sessionName: "tmux-ide",
-      agentId: "agent.0123456789abcdef0123",
-      fromStatus: "working",
-      toStatus: "idle",
-      at: "2026-07-23T12:00:00.000Z",
-    } as const;
-    expect(DaemonEventServerFrameSchemaZ.parse(receipt)).toEqual(receipt);
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...receipt, agentId: null }).success).toBe(
-      true,
-    );
-
-    // A raw tmux pane id, a raw durable stamp, or any non-digest value is
-    // rejected — only the minted `agent.<digest>` identity crosses the wire.
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...receipt, agentId: "%1" }).success).toBe(
-      false,
-    );
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        ...receipt,
-        agentId: "pane.promoted.0123456789abcdef0123",
-      }).success,
-    ).toBe(false);
-    // Completion is bounded to a finished turn: from working, to done|idle.
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({ ...receipt, fromStatus: "blocked" }).success,
-    ).toBe(false);
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({ ...receipt, toStatus: "blocked" }).success,
-    ).toBe(false);
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...receipt, at: "yesterday" }).success).toBe(
-      false,
-    );
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...receipt, unexpected: true }).success).toBe(
-      false,
-    );
-  });
-
-  it("strictly parses workspace.promotion-completed", () => {
-    const receipt = {
-      type: "workspace.promotion-completed",
-      workspaceName: "tmux-ide",
-      outcome: "replayed",
-      at: "2026-07-23T12:00:00.000Z",
-    } as const;
-    expect(DaemonEventServerFrameSchemaZ.parse(receipt)).toEqual(receipt);
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...receipt, outcome: "failed" }).success).toBe(
-      false,
-    );
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...receipt, workspaceName: "" }).success).toBe(
-      false,
-    );
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ ...receipt, unexpected: true }).success).toBe(
-      false,
-    );
-  });
-
-  it("strictly parses agent-status.changed and rejects missing or extra fields", () => {
-    expect(
-      DaemonEventServerFrameSchemaZ.parse({
-        type: "agent-status.changed",
-        sessionName: "tmux-ide",
-      }),
-    ).toEqual({ type: "agent-status.changed", sessionName: "tmux-ide" });
-    expect(DaemonEventServerFrameSchemaZ.safeParse({ type: "agent-status.changed" }).success).toBe(
-      false,
-    );
-    expect(
-      DaemonEventServerFrameSchemaZ.safeParse({
-        type: "agent-status.changed",
-        sessionName: "tmux-ide",
-        unexpected: true,
-      }).success,
-    ).toBe(false);
-  });
-});

package/packages/contracts/src/__tests__/daemon-resources.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  DaemonPanesResponseSchemaZ,
-  DaemonProjectResponseSchemaZ,
-  DaemonProjectsResponseSchemaZ,
-  DaemonProjectTemplatesResponseSchemaZ,
-  DaemonSessionsResponseSchemaZ,
-  DaemonWorkspacesResponseSchemaZ,
-} from "../daemon-resources.ts";
-import {
-  WORKSPACE_CATALOG_RESOURCE_VERSION,
-  WorkspaceCatalogResourceV1SchemaZ,
-} from "../workspace-catalog-resource.ts";
-
-const daemon = {
-  protocolVersion: 1,
-  productVersion: "2.8.0",
-  instanceId: "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-  startedAt: "2026-07-21T12:00:00.000Z",
-};
-
-const pane = {
-  id: "%7",
-  index: 0,
-  title: "Codex",
-  currentCommand: "codex",
-  width: 120,
-  height: 40,
-  active: true,
-  role: "teammate" as const,
-  name: "Implementer",
-  type: null,
-};
-
-describe("daemon REST resources", () => {
-  it("parses the current session, project, and pane response shapes", () => {
-    expect(
-      DaemonSessionsResponseSchemaZ.parse({
-        sessions: [{ name: "tmux-ide", dir: "/repo/tmux-ide" }],
-      }),
-    ).toEqual({ sessions: [{ name: "tmux-ide", dir: "/repo/tmux-ide" }] });
-
-    expect(
-      DaemonProjectResponseSchemaZ.parse({
-        session: "tmux-ide",
-        dir: "/repo/tmux-ide",
-        panes: [pane],
-      }).panes,
-    ).toEqual([pane]);
-    expect(DaemonPanesResponseSchemaZ.parse({ panes: [pane] })).toEqual({ panes: [pane] });
-  });
-
-  it("parses workspace, registry, and project-template envelopes", () => {
-    expect(
-      DaemonWorkspacesResponseSchemaZ.safeParse({
-        workspaces: [
-          {
-            name: "tmux-ide",
-            sessionName: "tmux-ide",
-            projectDir: "/repo/tmux-ide",
-            ideConfigPath: null,
-            configKind: "workspace",
-            configPath: "/repo/tmux-ide/.tmux-ide/workspace.yml",
-            hasWorkspaceConfig: true,
-            addedAt: "2026-07-21T12:00:00.000Z",
-          },
-        ],
-      }).success,
-    ).toBe(true);
-
-    expect(
-      DaemonProjectsResponseSchemaZ.safeParse({
-        projects: [
-          {
-            name: "tmux-ide",
-            dir: "/repo/tmux-ide",
-            hasIdeYml: false,
-            hasWorkspaceConfig: true,
-            configKind: "workspace",
-            configPath: "/repo/tmux-ide/.tmux-ide/workspace.yml",
-            ideConfigPath: null,
-            gitOrigin: "git@github.com:wavyrai/tmux-ide.git",
-            gitBranch: "main",
-            registeredAt: "2026-07-21T12:00:00.000Z",
-          },
-        ],
-      }).success,
-    ).toBe(true);
-
-    expect(
-      DaemonProjectTemplatesResponseSchemaZ.parse({
-        templates: [{ id: "default", label: "Default", description: "A balanced workspace" }],
-      }).templates[0]?.id,
-    ).toBe("default");
-  });
-
-  it("rejects unknown envelope and nested resource fields", () => {
-    expect(DaemonSessionsResponseSchemaZ.safeParse({ sessions: [], typo: true }).success).toBe(
-      false,
-    );
-    expect(
-      DaemonSessionsResponseSchemaZ.safeParse({
-        sessions: [{ name: "tmux-ide", dir: "/repo", typo: true }],
-      }).success,
-    ).toBe(false);
-    expect(DaemonPanesResponseSchemaZ.safeParse({ panes: [{ ...pane, typo: true }] }).success).toBe(
-      false,
-    );
-    expect(
-      DaemonProjectsResponseSchemaZ.safeParse({
-        projects: [
-          {
-            name: "tmux-ide",
-            dir: "/repo",
-            hasIdeYml: false,
-            gitOrigin: null,
-            gitBranch: null,
-            registeredAt: "now",
-            typo: true,
-          },
-        ],
-      }).success,
-    ).toBe(false);
-  });
-
-  it("strictly parses the generation-stamped workspace catalog resource", () => {
-    const resource = {
-      version: WORKSPACE_CATALOG_RESOURCE_VERSION,
-      daemon,
-      workspaces: [{ workspaceName: "tmux-ide", sessionName: "tmux-ide-live" }],
-    };
-    expect(WorkspaceCatalogResourceV1SchemaZ.parse(resource)).toEqual(resource);
-    expect(
-      WorkspaceCatalogResourceV1SchemaZ.safeParse({ ...resource, apiBaseUrl: "secret" }).success,
-    ).toBe(false);
-    expect(
-      WorkspaceCatalogResourceV1SchemaZ.safeParse({
-        ...resource,
-        workspaces: [{ ...resource.workspaces[0], projectDir: "/private/project" }],
-      }).success,
-    ).toBe(false);
-  });
-});

package/packages/contracts/src/__tests__/daemon-wire.test.ts

@@ -1,149 +0,0 @@
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-import {
-  CanonicalDaemonInfoSchema,
-  DAEMON_WIRE_PROTOCOL_VERSION,
-  DaemonProvenanceSchema,
-  DaemonHealthSchema,
-  DaemonHealthzSchema,
-  DaemonIdentitySchema,
-  DaemonInstanceIdentitySchemaZ,
-  isDaemonWireProtocolCompatible,
-} from "../daemon-wire.ts";
-import { WorkspaceCatalogResourceV1SchemaZ } from "../workspace-catalog-resource.ts";
-
-const fixturePath = fileURLToPath(new URL("./fixtures/daemon-wire-v4.json", import.meta.url));
-
-describe("daemon wire protocol", () => {
-  it("validates the shared desktop/TypeScript v4 fixture", () => {
-    const fixture = JSON.parse(readFileSync(fixturePath, "utf8")) as Record<string, unknown>;
-
-    expect(CanonicalDaemonInfoSchema.parse(fixture.canonical).protocolVersion).toBe(
-      DAEMON_WIRE_PROTOCOL_VERSION,
-    );
-    expect(DaemonHealthSchema.parse(fixture.health).protocolVersion).toBe(
-      DAEMON_WIRE_PROTOCOL_VERSION,
-    );
-    expect(DaemonHealthzSchema.parse(fixture.healthz).productVersion).toBe("0.0.1");
-    const identity = DaemonIdentitySchema.parse(fixture.identity);
-    expect(identity.instanceId).toBe(CanonicalDaemonInfoSchema.parse(fixture.canonical).instanceId);
-  });
-
-  it("retains an unknown positive wire version for a separate compatibility decision", () => {
-    const fixture = JSON.parse(readFileSync(fixturePath, "utf8")) as {
-      canonical: Record<string, unknown>;
-      health: Record<string, unknown>;
-    };
-    const unknownVersion = DAEMON_WIRE_PROTOCOL_VERSION + 1;
-    const health = DaemonHealthSchema.parse({
-      ...fixture.health,
-      protocolVersion: unknownVersion,
-    });
-    const canonical = CanonicalDaemonInfoSchema.parse({
-      ...fixture.canonical,
-      protocolVersion: unknownVersion,
-    });
-
-    expect(health.protocolVersion).toBe(unknownVersion);
-    expect(canonical.protocolVersion).toBe(unknownVersion);
-    expect(isDaemonWireProtocolCompatible(unknownVersion)).toBe(false);
-    expect(isDaemonWireProtocolCompatible(DAEMON_WIRE_PROTOCOL_VERSION)).toBe(true);
-  });
-});
-
-describe("environment identity (additive, both directions)", () => {
-  const ENVIRONMENT_ID = "0f4e9a7c-2f4a-4d55-9d2e-1f6cf3a3b210";
-  const fixture = JSON.parse(readFileSync(fixturePath, "utf8")) as {
-    canonical: Record<string, unknown>;
-    identity: Record<string, unknown>;
-  };
-  const identityFields = {
-    protocolVersion: DAEMON_WIRE_PROTOCOL_VERSION,
-    productVersion: "0.0.1",
-    instanceId: "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-    startedAt: "2026-07-20T12:34:56.123Z",
-  };
-
-  it("parses pre-environment payloads unchanged (old daemon, new client)", () => {
-    expect(CanonicalDaemonInfoSchema.parse(fixture.canonical).environmentId).toBeUndefined();
-    expect(DaemonIdentitySchema.parse(fixture.identity).environmentId).toBeUndefined();
-    expect(DaemonInstanceIdentitySchemaZ.parse(identityFields).environmentId).toBeUndefined();
-  });
-
-  it("carries the environment id on every identity surface when present", () => {
-    const canonical = CanonicalDaemonInfoSchema.parse({
-      ...fixture.canonical,
-      environmentId: ENVIRONMENT_ID,
-    });
-    const identity = DaemonIdentitySchema.parse({
-      ...fixture.identity,
-      environmentId: ENVIRONMENT_ID,
-    });
-    const instanceIdentity = DaemonInstanceIdentitySchemaZ.parse({
-      ...identityFields,
-      environmentId: ENVIRONMENT_ID,
-    });
-    expect(canonical.environmentId).toBe(ENVIRONMENT_ID);
-    expect(identity.environmentId).toBe(ENVIRONMENT_ID);
-    expect(instanceIdentity.environmentId).toBe(ENVIRONMENT_ID);
-  });
-
-  it("rejects a non-UUID environment id but keeps other unknown-key strictness", () => {
-    expect(
-      DaemonInstanceIdentitySchemaZ.safeParse({ ...identityFields, environmentId: "nope" }).success,
-    ).toBe(false);
-    expect(
-      DaemonInstanceIdentitySchemaZ.safeParse({ ...identityFields, machineId: ENVIRONMENT_ID })
-        .success,
-    ).toBe(false);
-  });
-
-  it("stamps generation-checked resource envelopes with and without the id", () => {
-    const envelope = (daemon: Record<string, unknown>) => ({
-      version: 1,
-      daemon,
-      workspaces: [{ workspaceName: "alpha", sessionName: "alpha" }],
-    });
-    const without = WorkspaceCatalogResourceV1SchemaZ.parse(envelope(identityFields));
-    const withId = WorkspaceCatalogResourceV1SchemaZ.parse(
-      envelope({ ...identityFields, environmentId: ENVIRONMENT_ID }),
-    );
-    expect(without.daemon.environmentId).toBeUndefined();
-    expect(withId.daemon.environmentId).toBe(ENVIRONMENT_ID);
-    // Generation identity is untouched by the additive field.
-    expect(withId.daemon.instanceId).toBe(identityFields.instanceId);
-    expect(withId.daemon.startedAt).toBe(identityFields.startedAt);
-  });
-});
-
-describe("daemon provenance (additive)", () => {
-  const fixture = JSON.parse(readFileSync(fixturePath, "utf8")) as {
-    canonical: Record<string, unknown>;
-  };
-  const provenance = {
-    launcher: "headless",
-    supervisor: "systemd",
-    parentPid: 1,
-    stdout: { kind: "file", path: "/var/log/tmux-ide.out", dev: 1, ino: 2 },
-    stderr: { kind: "socket" },
-    warnings: ["stderr: path unresolved"],
-  };
-
-  it("parses records with and without provenance", () => {
-    expect(CanonicalDaemonInfoSchema.parse(fixture.canonical).provenance).toBeUndefined();
-    expect(
-      CanonicalDaemonInfoSchema.parse({ ...fixture.canonical, provenance }).provenance,
-    ).toEqual(provenance);
-    expect(DaemonProvenanceSchema.parse(provenance)).toEqual(provenance);
-  });
-
-  it("rejects unknown supervisors and stream kinds", () => {
-    expect(DaemonProvenanceSchema.safeParse({ ...provenance, supervisor: "cron" }).success).toBe(
-      false,
-    );
-    expect(
-      DaemonProvenanceSchema.safeParse({ ...provenance, stdout: { kind: "journal" } }).success,
-    ).toBe(false);
-  });
-});