tmux-ide 2.7.0 → 2.9.0-beta.5

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

@@ -0,0 +1,400 @@
+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 = {
+      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({
+        ...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({
+        ...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

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,117 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import {
+  CanonicalDaemonInfoSchema,
+  DAEMON_WIRE_PROTOCOL_VERSION,
+  DaemonHealthSchema,
+  DaemonHealthzSchema,
+  DaemonIdentitySchema,
+  DaemonInstanceIdentitySchemaZ,
+  isDaemonWireProtocolCompatible,
+} from "../daemon-wire.ts";
+import { WorkspaceCatalogResourceV1SchemaZ } from "../workspace-catalog-resource.ts";
+
+const fixturePath = fileURLToPath(new URL("./fixtures/daemon-wire-v2.json", import.meta.url));
+
+describe("daemon wire protocol", () => {
+  it("validates the shared desktop/TypeScript v2 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);
+  });
+});