fix(a2a): isolate Peer Agent workspaces by default

apps/server/src/j5/a2a/AgentCrewProposalService.test.ts

@@ -2,6 +2,7 @@ import { assert, it } from "@effect/vitest";
 import { ThreadId } from "@t3tools/contracts";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 
 import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";
 import { AgentCrewInstanceService, layer as crewLayer } from "./AgentCrewInstanceService.ts";
@@ -26,10 +27,16 @@ const squadronId = SquadronId.make("squadron:crew-proposals");
 const captain = ParticipantId.make("agent:j5:a2a:captain-proposals");
 const captainThreadId = ThreadId.make("thread:captain-proposals");
 
-const seat = (name: string) => ({ seat: name, agentId: "scout", reason: "Holds a seat" });
+const seat = (name: string) => ({
+  workspace: { type: "shared" as const },
+  seat: name,
+  agentId: "scout",
+  reason: "Holds a seat",
+});
 
 /** A roster row minted by a launch: its identity is its own, not derived from any proposal. */
 const rosterMember = (crewId: string, name: string) => ({
+  workspace: { type: "shared" as const },
   seatName: name,
   agentId: "scout",
   participantId: ParticipantId.make(`agent:j5:a2a:thread:${crewId}:${name}`),
@@ -174,3 +181,37 @@ it.effect("a proposal resolves once: the second resolution finds it closed", ()
     );
   }).pipe(Effect.provide(testLayer)),
 );
+
+it.effect("a stored seat workspace this version can't read costs that seat its workspace", () =>
+  Effect.gen(function* () {
+    yield* runJ5A2AMigrations();
+    yield* (yield* A2ALedger).createSquadron({
+      squadron: { id: squadronId, name: "Proposal Squadron", createdAt },
+    });
+    const proposals = yield* AgentCrewProposalService;
+    yield* proposals.create({
+      ...addition("proposal:stored", "crew:stored", ["a", "b"]),
+      kind: "roster",
+      crewInstanceId: null,
+    });
+    // Written by another version: a new worktree with no base, and a type this one doesn't know.
+    const sql = yield* SqlClient.SqlClient;
+    const stored = `[
+      {"seat":"a","agentId":"scout","reason":"Holds a seat","workspace":{"type":"worktree"}},
+      {"seat":"b","agentId":"scout","reason":"Holds a seat","workspace":{"type":"sandbox"}},
+      {"seat":"c","agentId":"scout","reason":"Holds a seat","workspace":{"type":"shared"}}
+    ]`;
+    yield* sql`UPDATE j5_agent_crew_proposal SET requested_seats = ${stored} WHERE id = 'proposal:stored'`;
+    const open = yield* proposals.listOpen();
+    assert.deepStrictEqual(
+      open.map((proposal) => proposal.requestedSeats.map((seat) => [seat.seat, seat.workspace])),
+      [
+        [
+          ["a", undefined],
+          ["b", undefined],
+          ["c", { type: "shared" }],
+        ],
+      ],
+    );
+  }).pipe(Effect.provide(testLayer)),
+);

apps/server/src/j5/a2a/AgentCrewProposalService.ts

@@ -9,6 +9,7 @@ import type { SqlError } from "effect/unstable/sql/SqlError";
 
 import { CREW_NAME_MAX_CHARS, CREW_REASON_MAX_CHARS, CREW_TEXT_MAX_CHARS } from "./crewLimits.ts";
 import { ParticipantId, SquadronId } from "./contracts.ts";
+import { SpawnWorkspaceChoice } from "./spawnWorkspace.ts";
 
 // The same bounds as the MCP verbs: the human's card edits arrive over HTTP and must not be the
 // one way to store an unbounded or empty seat (Sentry S-3, 2026-09-14).
@@ -32,6 +33,15 @@ export const CrewProposalSeat = Schema.Struct({
       Schema.isMaxLength(PLAYBOOK_MAX_STEPS),
     ),
   ),
+  /**
+   * Where the seat works, as the Captain or the person chose it. Required at every door that
+   * files or approves a seat. A stored one this version can't read, such as one written by another
+   * version, reads as none: the seat stays listed and is refused at preview until one is chosen,
+   * rather than one seat failing every read of the table.
+   */
+  workspace: Schema.optionalKey(
+    SpawnWorkspaceChoice.pipe(Schema.catchDecoding(() => Effect.succeedNone)),
+  ),
   /** Recomputed by the server whenever the seats are validated; never taken from a client. */
   personaSwaps: Schema.optionalKey(Schema.Array(CrewPersonaSwap)),
 });

apps/server/src/j5/a2a/CrewLaunchReporter.test.ts

@@ -599,6 +599,17 @@ it.effect("posts one report once every seat has started or failed, with the run'
         userMessageId: brief("prosecutor"),
       });
       assert.isNull(yield* reporter.handleStoredEvent(queued));
+      // Nor is a first turn held as `preparing` while its worktree is being made, even though
+      // ThreadLaunch's own preparation item reads as activity.
+      yield* setSeat(id, "prosecutor", [
+        { status: "preparing", activity: true, userMessageId: brief("prosecutor") },
+      ]);
+      const preparing = runEvent(crewSeatThreadId(id, "prosecutor"), {
+        status: "preparing",
+        userMessageId: brief("prosecutor"),
+      });
+      assert.isNull(yield* reporter.handleStoredEvent(preparing));
+      assert.deepStrictEqual(yield* reports(), []);
       const punchlineRun = {
         id: RunId.make(`run:${crewSeatThreadId(id, "punchline")}:0`),
         threadId: crewSeatThreadId(id, "punchline"),

apps/server/src/j5/a2a/CrewLaunchReporter.ts

@@ -139,6 +139,10 @@ const verdictFor = (
   switch (run.status) {
     case "completed":
       return { kind: "started" };
+    // A new worktree's first turn waits here while ThreadLaunch prepares it, and that
+    // preparation's own items are not the seat's agent at work.
+    case "preparing":
+      return { kind: "pending" };
     case "failed":
     case "interrupted":
     case "cancelled":