@stigmer/server 3.18.1-dev.20260919070736 → 3.19.1-dev.20260920100552

package/src/query/search/__tests__/query-store.test.ts

@@ -6,7 +6,7 @@
  * #439 newly-searchable-kind arm), plus the scope-filter matrix
  * (org strict / crossOrgPublic / excludePublic) and RebuildIndex —
  * including the DD-D proof: rebuilding over an ADOPTED Go-created
- * database re-indexes its project rows. The escaping and
+ * database re-indexes the rows it already holds. The escaping and
  * score-normalization tables moved with their code into the sqlite
  * driver (DD-009 seam redraw): see store/sqlite/__tests__/fts5.test.ts.
  * These tests still run the REAL driver through tempStore — the
@@ -18,9 +18,9 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
 import { AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { SessionSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import { SkillSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/api_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
-import { ProjectSchema } from "@stigmer/protos/ai/stigmer/tenancy/project/v1/api_pb";
 
 import type { DescMessage, MessageShape } from "@bufbuild/protobuf";
 
@@ -426,33 +426,33 @@ describe("rebuildIndex", () => {
     expect(after.results[0]?.id).toBe("ses-1");
   });
 
-  it("re-indexes project rows on an ADOPTED Go-created database (DD-D)", async () => {
+  it("re-indexes existing rows on an ADOPTED Go-created database (DD-D)", async () => {
     // The committed Go-v6 fixture, opened through the driver (migrates
-    // v6→v7 — real adoption), then given a project row the way a Go
+    // v6→current — real adoption), then given a skill row the way a Go
     // server would have written one: raw resource bytes.
     const fixture = materializeGoFixture();
     const adopted = SqliteStore.open(fixture.dbPath);
     try {
-      const project = create(ProjectSchema, {
+      const skill = create(SkillSchema, {
         metadata: {
-          id: "prj_1",
+          id: "skl_1",
           name: "billing",
           slug: "billing",
           org: "acme",
         },
-        spec: { description: "the billing project" },
+        spec: { description: "the billing skill" },
         status: {
           audit: { specAudit: { createdAt: { seconds: 1_700_000_000n } } },
         },
       });
       await adopted.saveResource(
-        ApiResourceKind.project,
-        "prj_1",
-        ProjectSchema,
-        project,
+        ApiResourceKind.skill,
+        "skl_1",
+        SkillSchema,
+        skill,
       );
-      // Boot state: the TS server wipes and rebuilds — a 12-kind registry
-      // would erase this row from search forever.
+      // Boot state: the TS server wipes and rebuilds — a registry without
+      // the kind would erase this row from search forever.
       const adoptedQueryStore = new SqliteSearchQueryStore(
         adopted,
         registry,
@@ -461,21 +461,21 @@ describe("rebuildIndex", () => {
       await adoptedQueryStore.rebuildIndex();
 
       const result = await adoptedQueryStore.search(
-        criteria({ kinds: [ApiResourceKind.project], org: "acme" }),
+        criteria({ kinds: [ApiResourceKind.skill], org: "acme" }),
       );
       expect(result.totalCount).toBe(1);
-      expect(result.results[0]?.id).toBe("prj_1");
-      expect(result.results[0]?.description).toBe("the billing project");
+      expect(result.results[0]?.id).toBe("skl_1");
+      expect(result.results[0]?.description).toBe("the billing skill");
 
       // toBinary sanity: the row loaded back is byte-equal to what a Go
       // server holds (protobuf wire format is shared).
       const raw = await adopted.getResource(
-        ApiResourceKind.project,
-        "prj_1",
-        ProjectSchema,
+        ApiResourceKind.skill,
+        "skl_1",
+        SkillSchema,
       );
-      expect(toBinary(ProjectSchema, raw)).toEqual(
-        toBinary(ProjectSchema, project),
+      expect(toBinary(SkillSchema, raw)).toEqual(
+        toBinary(SkillSchema, skill),
       );
     } finally {
       await adopted.close();

package/src/query/search/registry.ts

@@ -12,11 +12,9 @@
  * (registry.go ValidateExpectedKinds; server.go:509): a missing extractor
  * degrades that kind to unsearchable, never refuses boot.
  *
- * The project extractor is registered here by THIS sub-project (#14)
- * although the project DOMAIN ports with #16 — boot RebuildIndex re-indexes
- * every registered kind from the resources table, and an adopted Go
- * database may already hold projects; without the extractor those rows
- * would silently vanish from search (D4 #14 DD-D, owner-ratified).
+ * Boot RebuildIndex re-indexes every registered kind from the resources
+ * table, so a kind with no extractor here is a kind whose rows vanish from
+ * search on the next boot; a domain and its extractor land together.
  */
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 
@@ -28,7 +26,6 @@ import { executionContextSearchExtractor } from "../../domain/executioncontext/s
 import { mcpServerSearchExtractor } from "../../domain/mcpserver/search-extractor.js";
 import { organizationSearchExtractor } from "../../domain/organization/search-extractor.js";
 import { pluginSearchExtractor } from "../../domain/plugin/search-extractor.js";
-import { projectSearchExtractor } from "../../domain/project/search-extractor.js";
 import { sessionSearchExtractor } from "../../domain/session/search-extractor.js";
 import { skillSearchExtractor } from "../../domain/skill/search-extractor.js";
 import { workflowSearchExtractor } from "../../domain/workflow/search-extractor.js";
@@ -116,7 +113,6 @@ export function newSearchableResourceRegistry(): SearchableResourceRegistry {
     mcpServerSearchExtractor,
     organizationSearchExtractor,
     pluginSearchExtractor,
-    projectSearchExtractor,
     sessionSearchExtractor,
     skillSearchExtractor,
     workflowSearchExtractor,

package/src/sandbox/__tests__/docker.integration.test.ts

@@ -68,6 +68,7 @@ describe.skipIf(!optedIn || !dockerAnswers())(
       await driver.ensureSessionSandbox(sessionId, {
         taskQueue: `session:${sessionId}`,
         stigmerToken: "tok-docker-smoke",
+        callerClass: "user",
       });
       expect(await driver.probe("session", sessionId)).toBe("running");
 
@@ -91,6 +92,7 @@ describe.skipIf(!optedIn || !dockerAnswers())(
       await driver.ensureSessionSandbox(sessionId, {
         taskQueue: `session:${sessionId}`,
         stigmerToken: "tok-docker-smoke",
+        callerClass: "user",
       });
       expect(await driver.probe("session", sessionId)).toBe("running");
 

package/src/sandbox/__tests__/kubernetes.test.ts

@@ -89,7 +89,11 @@ function fakeGateway(
   };
 }
 
-const env = { taskQueue: "session:ses_1", stigmerToken: "tok-1" };
+const env = {
+  taskQueue: "session:ses_1",
+  stigmerToken: "tok-1",
+  callerClass: "user",
+};
 
 describe("the ensure state machine", () => {
   it("absent → Secret, PVC, Deployment — in that order, no readiness wait", async () => {
@@ -211,7 +215,11 @@ describe("the manifest shapes (the Java SandboxManifestFactory pins)", () => {
   });
 
   it("a token-less sandbox omits the token env but keeps the (empty) Secret", () => {
-    const tokenless = { taskQueue: "session:ses_1", stigmerToken: "" };
+    const tokenless = {
+      taskQueue: "session:ses_1",
+      stigmerToken: "",
+      callerClass: "user",
+    };
     const deployment = buildSandboxDeployment(
       "session",
       "ses_1",

package/src/sandbox/__tests__/local-process.integration.test.ts

@@ -81,6 +81,7 @@ describe.skipIf(process.platform === "win32")(
       await driver.ensureSessionSandbox("ses_smoke", {
         taskQueue: "session:ses_smoke",
         stigmerToken: "tok-smoke",
+        callerClass: "user",
       });
       await vi.waitFor(() => expect(spawnCount()).toBe(1), {
         timeout: CHILD_SETTLE_TIMEOUT_MS,
@@ -91,6 +92,7 @@ describe.skipIf(process.platform === "win32")(
       await driver.ensureSessionSandbox("ses_smoke", {
         taskQueue: "session:ses_smoke",
         stigmerToken: "tok-smoke",
+        callerClass: "user",
       });
       expect(spawnCount()).toBe(1);
 
@@ -124,6 +126,7 @@ describe.skipIf(process.platform === "win32")(
       await driver.ensureSessionSandbox("ses_smoke", {
         taskQueue: "session:ses_smoke",
         stigmerToken: "",
+        callerClass: "user",
       });
       await vi.waitFor(() => expect(spawnCount()).toBe(2), {
         timeout: CHILD_SETTLE_TIMEOUT_MS,

package/src/sandbox/__tests__/steps.test.ts

@@ -11,7 +11,10 @@
  *   - the terminal observer deprovisions exactly on transitions INTO a
  *     terminal phase, fire-and-forget, and swallows (logs) teardown
  *     failures;
- *   - a disabled mint lane launches token-less rather than failing.
+ *   - a disabled mint lane launches token-less rather than failing;
+ *   - the caller splits two ways on both lanes: the identity id reaches
+ *     the credential mint, the caller class reaches the driver's
+ *     environment unchanged (a composed lane such as `guest` included).
  */
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -53,14 +56,25 @@ import {
   ensureWorkflowSandboxForExecution,
   newWorkflowSandboxTerminalObserver,
   SANDBOX_PROVISIONING_FAILED_PREFIX,
+  type SandboxCaller,
 } from "../steps.js";
 
 /**
- * The caller identity the ensure bodies thread into the credential mint
- * (C4): the OSS execution-scoped mint ignores it, so these tests pass a
- * fixed value and the token assertions stay binding-shaped.
+ * The caller the ensure bodies split two ways: the identity id into the
+ * credential mint (C4 — the OSS execution-scoped mint ignores it, so the
+ * token assertions stay binding-shaped) and the class onto the driver's
+ * environment. `user` is the plain lane; the class-propagation cases hand
+ * in a composed lane's word to prove the body copies, never normalises.
  */
 const TEST_CALLER_IDENTITY_ID = "ida_test_caller";
+const TEST_CALLER: SandboxCaller = {
+  identityId: TEST_CALLER_IDENTITY_ID,
+  callerClass: "user",
+};
+const GUEST_CALLER: SandboxCaller = {
+  identityId: "ida_guest_caller",
+  callerClass: "guest",
+};
 
 const silentLogger = createLogger({
   level: "error",
@@ -235,7 +249,7 @@ describe("the session lane (ensureSessionSandboxForExecution)", () => {
         temporalConfig: sessionRoutingCloudDefault,
       },
       execution,
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     expect(provisioner.ensured).toEqual([
       {
@@ -244,11 +258,32 @@ describe("the session lane (ensureSessionSandboxForExecution)", () => {
         env: {
           taskQueue: `session:${sessionId}`,
           stigmerToken: `tok-${execution.metadata?.id ?? ""}`,
+          callerClass: "user",
         },
       },
     ]);
   });
 
+  it("hands the caller's class to the driver unchanged and the caller's id to the mint", async () => {
+    const provisioner = fakeProvisioner();
+    const credentials = capabilityCredentials();
+    const { execution } = await seed(ExecutionTarget.CLOUD);
+    await ensureSessionSandboxForExecution(
+      {
+        store,
+        logger: silentLogger,
+        lane: lane(provisioner, credentials),
+        temporalConfig: sessionRoutingCloudDefault,
+      },
+      execution,
+      GUEST_CALLER,
+    );
+    expect(provisioner.ensured[0]?.env.callerClass).toBe("guest");
+    expect(credentials.minted[0]?.callerIdentityId).toBe(
+      GUEST_CALLER.identityId,
+    );
+  });
+
   it("delegates the mint to the capability provider with the full provisioning context (C4)", async () => {
     const provisioner = fakeProvisioner();
     const credentials = capabilityCredentials();
@@ -277,7 +312,7 @@ describe("the session lane (ensureSessionSandboxForExecution)", () => {
         temporalConfig: sessionRoutingCloudDefault,
       },
       execution,
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
 
     expect(credentials.minted).toEqual([
@@ -303,7 +338,7 @@ describe("the session lane (ensureSessionSandboxForExecution)", () => {
         temporalConfig: sessionRoutingCloudDefault,
       },
       execution,
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     expect(provisioner.ensured).toEqual([]);
   });
@@ -327,7 +362,7 @@ describe("the session lane (ensureSessionSandboxForExecution)", () => {
         temporalConfig: sessionRoutingCloudDefault,
       },
       execution,
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
   });
 
@@ -345,7 +380,7 @@ describe("the session lane (ensureSessionSandboxForExecution)", () => {
         temporalConfig: sessionRoutingCloudDefault,
       },
       execution,
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     expect(provisioner.ensured).toEqual([]);
   });
@@ -366,7 +401,7 @@ describe("the session lane (ensureSessionSandboxForExecution)", () => {
         ),
       },
       execution,
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     expect(provisioner.ensured).toEqual([]);
   });
@@ -382,7 +417,7 @@ describe("the session lane (ensureSessionSandboxForExecution)", () => {
         temporalConfig: sessionRoutingCloudDefault,
       },
       execution,
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     expect(provisioner.ensured[0]?.env.stigmerToken).toBe("");
   });
@@ -401,7 +436,7 @@ describe("the session lane (ensureSessionSandboxForExecution)", () => {
         temporalConfig: sessionRoutingCloudDefault,
       },
       execution,
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     const stamped = await store.getResource(
       ApiResourceKind.agent_execution,
@@ -439,7 +474,7 @@ describe("the session lane (ensureSessionSandboxForExecution)", () => {
         temporalConfig: sessionRoutingCloudDefault,
       },
       execution,
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     const after = await store.getResource(
       ApiResourceKind.agent_execution,
@@ -467,17 +502,35 @@ describe("the workflow lane (ensureWorkflowSandboxForExecution)", () => {
         temporalConfig: executionRoutingConfig,
       },
       workflowExecution(ExecutionTarget.CLOUD),
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     expect(provisioner.ensured).toEqual([
       {
         scope: "workflow",
         id: "wfx_sbx_1",
-        env: { taskQueue: "wfexec:wfx_sbx_1", stigmerToken: "tok-wfx_sbx_1" },
+        env: {
+          taskQueue: "wfexec:wfx_sbx_1",
+          stigmerToken: "tok-wfx_sbx_1",
+          callerClass: "user",
+        },
       },
     ]);
   });
 
+  it("hands the caller's class to the driver unchanged on the workflow lane", async () => {
+    const provisioner = fakeProvisioner();
+    await ensureWorkflowSandboxForExecution(
+      {
+        logger: silentLogger,
+        lane: lane(provisioner),
+        temporalConfig: executionRoutingConfig,
+      },
+      workflowExecution(ExecutionTarget.CLOUD),
+      GUEST_CALLER,
+    );
+    expect(provisioner.ensured[0]?.env.callerClass).toBe("guest");
+  });
+
   it("delegates the mint to the capability provider on the workflow scope (C4)", async () => {
     const provisioner = fakeProvisioner();
     const credentials = capabilityCredentials();
@@ -491,7 +544,7 @@ describe("the workflow lane (ensureWorkflowSandboxForExecution)", () => {
         metadata: { id: "wfx_sbx_cap", name: "wfx_sbx_cap", org: "org-test" },
         spec: { executionTarget: ExecutionTarget.CLOUD },
       }),
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     expect(credentials.minted).toEqual([
       {
@@ -514,7 +567,7 @@ describe("the workflow lane (ensureWorkflowSandboxForExecution)", () => {
         temporalConfig: executionRoutingConfig,
       },
       workflowExecution(ExecutionTarget.LOCAL),
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     await ensureWorkflowSandboxForExecution(
       {
@@ -528,7 +581,7 @@ describe("the workflow lane (ensureWorkflowSandboxForExecution)", () => {
         ),
       },
       workflowExecution(ExecutionTarget.CLOUD),
-      TEST_CALLER_IDENTITY_ID,
+      TEST_CALLER,
     );
     expect(provisioner.ensured).toEqual([]);
   });
@@ -545,7 +598,7 @@ describe("the workflow lane (ensureWorkflowSandboxForExecution)", () => {
           temporalConfig: executionRoutingConfig,
         },
         workflowExecution(ExecutionTarget.CLOUD),
-        TEST_CALLER_IDENTITY_ID,
+        TEST_CALLER,
       );
       expect.unreachable("the workflow lane must throw on failure");
     } catch (error) {

package/src/sandbox/kubernetes.ts

@@ -85,7 +85,14 @@ const RUNNER_RESOURCES = {
   limits: { cpu: "2", memory: "2Gi" },
 } as const;
 
-/** The persistent-workspace scopes (SandboxScope.persistentWorkspace). */
+/**
+ * The persistent-workspace scopes (SandboxScope.persistentWorkspace).
+ * Durability here is decided by SCOPE alone: this driver reads neither the
+ * environment's caller class nor any per-session policy, so every session
+ * keeps its PVC whoever asked. A driver that gives some caller classes a
+ * workspace that dies with the conversation is a composition's choice
+ * built on SandboxEnvironment.callerClass, not a built-in behaviour.
+ */
 const PERSISTENT_SCOPES: ReadonlySet<SandboxScope> = new Set([
   "session",
   "workflow",

package/src/sandbox/provisioner.ts

@@ -39,13 +39,16 @@
  * runner process polls the queues.
  */
 import type { Logger } from "../boot/logger.js";
+import type { CallerClass } from "../extensions/identity.js";
 
 /**
- * The runtime handed to a provisioner for one sandbox: which queue the
- * sandboxed runner must poll and the credential it authenticates with.
- * Deliberately minimal (the Java SandboxEnvironment carries the same two
- * load-bearing fields plus cloud-only accounting) — endpoints, images,
- * and resource shapes are DRIVER configuration, not per-sandbox state.
+ * What is TRUE about one provisioning request, handed to a driver: which
+ * queue the sandboxed runner must poll, the credential it authenticates
+ * with, and the class of the caller whose request is being served. Facts
+ * only — what a driver DOES with them (the workspace's durability, the
+ * pod's shape, whether a warm pool is consulted) is driver policy and
+ * never travels here. Endpoints, images and resource shapes are driver
+ * configuration, not per-sandbox state.
  */
 export interface SandboxEnvironment {
   /** The Temporal task queue the sandboxed runner polls (session:{id} / wfexec:{id}). */
@@ -56,6 +59,18 @@ export interface SandboxEnvironment {
    * and EC decrypt falls back to redaction, the oss#535 posture.
    */
   readonly stigmerToken: string;
+  /**
+   * The class of the caller whose request provisioned this sandbox — the
+   * identity interceptor's word for it (`user`, `internal`, a composed
+   * verifier's own lane such as a guest or a scheduled fire). A driver
+   * that gives some session classes a workspace that does not outlive the
+   * conversation reads it here; the built-in drivers (`local-process`,
+   * `docker`, `kubernetes`) ignore it and keep every session persistent.
+   * Required rather than optional so a construction site that forgets it
+   * fails to compile instead of silently reading as a persistent user
+   * session to every driver.
+   */
+  readonly callerClass: CallerClass;
 }
 
 /** One sandbox's observed live state (the Q5 probe result). */

package/src/sandbox/steps.ts

@@ -50,6 +50,7 @@ import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/
 
 import type { Logger } from "../boot/logger.js";
 import type { AgentExecutionTemporalConfig } from "../domain/agentexecution/temporal/config.js";
+import type { CallerIdentity } from "../extensions/identity.js";
 import {
   WORKFLOW_ROUTING_EXECUTION,
   type WorkflowExecutionTemporalConfig,
@@ -72,6 +73,17 @@ import { mintSandboxToken, type SandboxLane } from "./lane.js";
 export const SANDBOX_PROVISIONING_FAILED_PREFIX =
   "Sandbox provisioning failed: ";
 
+/**
+ * The two facts about the requesting caller a sandbox ensure carries, cut
+ * from the chain's CallerIdentity (the domain/identityaccount/actor.ts
+ * shape): the id rides into the credential mint, so the session token is
+ * minted FOR the caller; the class rides onto the driver's environment,
+ * so a driver can decide the workspace's durability by who asked. A step
+ * hands `ctx.callerIdentity` in whole; the pick keeps a test's fixture to
+ * the two fields the body reads.
+ */
+export type SandboxCaller = Pick<CallerIdentity, "identityId" | "callerClass">;
+
 type AgentExecutionCreateDesc = typeof AgentExecutionSchema;
 
 export interface EnsureSessionSandboxDeps {
@@ -101,7 +113,7 @@ export function newEnsureSessionSandboxStep(
       await ensureSessionSandboxForExecution(
         deps,
         ctx.newState,
-        ctx.callerIdentity.identityId,
+        ctx.callerIdentity,
       );
     },
   };
@@ -114,15 +126,18 @@ export function newEnsureSessionSandboxStep(
  * chains' differing context shapes (newState vs loaded execution) meet
  * at this seam instead.
  *
- * `callerIdentityId` rides into the credential mint (lane.ts): the Java
- * ensure step mints session tokens FOR the requesting caller, so the
- * capability mint needs the identity the OSS execution-scoped mint never
- * did. Empty when the invoking site has no caller.
+ * The caller splits two ways (SandboxCaller): `identityId` rides into the
+ * credential mint (lane.ts) — the Java ensure step mints session tokens
+ * FOR the requesting caller, so the capability mint needs the identity
+ * the OSS execution-scoped mint never did — and `callerClass` rides onto
+ * the driver's environment as the one request fact a driver may decide
+ * durability by. The chain always has a caller: the in-process transport
+ * mints `internal` for the server's own calls.
  */
 export async function ensureSessionSandboxForExecution(
   deps: EnsureSessionSandboxDeps,
   execution: AgentExecution,
-  callerIdentityId: string,
+  caller: SandboxCaller,
 ): Promise<void> {
   if (!deps.lane.enabled) {
     return;
@@ -167,10 +182,11 @@ export async function ensureSessionSandboxForExecution(
           sessionId,
           executionId,
           org: execution.metadata?.org ?? "",
-          callerIdentityId,
+          callerIdentityId: caller.identityId,
         },
         deps.logger,
       ),
+      callerClass: caller.callerClass,
     });
   } catch (error) {
     // Non-critical: never fail the launch — but never silent either
@@ -247,7 +263,7 @@ export function newEnsureWorkflowSandboxStep(
       await ensureWorkflowSandboxForExecution(
         deps,
         ctx.newState,
-        ctx.callerIdentity.identityId,
+        ctx.callerIdentity,
       );
     },
   };
@@ -258,13 +274,13 @@ export function newEnsureWorkflowSandboxStep(
  * re-provision (lifecycle.ts — the previous sandbox was deprovisioned at
  * the terminal FAILED, so a recovered execution needs a fresh one before
  * its fresh workflow starts). Throws Unavailable on provisioning failure
- * — the critical posture in both chains. `callerIdentityId` rides into
- * the credential mint exactly as on the session body.
+ * — the critical posture in both chains. The caller splits exactly as on
+ * the session body: id to the mint, class to the environment.
  */
 export async function ensureWorkflowSandboxForExecution(
   deps: EnsureWorkflowSandboxDeps,
   execution: WorkflowExecution,
-  callerIdentityId: string,
+  caller: SandboxCaller,
 ): Promise<void> {
   if (!deps.lane.enabled) {
     return;
@@ -296,10 +312,11 @@ export async function ensureWorkflowSandboxForExecution(
           sessionId: "",
           executionId,
           org: execution.metadata?.org ?? "",
-          callerIdentityId,
+          callerIdentityId: caller.identityId,
         },
         deps.logger,
       ),
+      callerClass: caller.callerClass,
     });
   } catch (error) {
     deps.logger.error(

package/src/store/postgres/__tests__/migrations.test.ts

@@ -91,24 +91,43 @@ describe.skipIf(testDatabaseAdminUrl() === undefined)(
       }
     });
 
-    it("a v1 database resumes the chain on reopen: the v2/v3 indexes arrive", async () => {
+    it("a v1 database resumes the chain on reopen: the v2/v3 indexes arrive and v4 removes the Project rows", async () => {
       const store = await PostgresStore.open(db.databaseUrl);
       await store.close();
 
-      // Rewind to a v1 database: drop exactly what v2+v3 created and their
-      // version rows — the state any pre-v2 deployment is actually in.
+      // Rewind to a v1 database: drop exactly what v2+v4 created and their
+      // version rows — the state any pre-v2 deployment is actually in —
+      // and seed one row of the Project kind an earlier release wrote
+      // (the kind column holds the enum NAME) beside a row v4 must keep.
       const client = new pg.Client({ connectionString: db.databaseUrl });
       await client.connect();
       try {
         await client.query(`DROP INDEX idx_wfee_created_at`);
         await client.query(`DROP INDEX idx_oauth_grant_resource`);
         await client.query(
-          `DELETE FROM schema_version WHERE version IN (2, 3)`,
+          `DELETE FROM schema_version WHERE version IN (2, 3, 4)`,
+        );
+        await client.query(
+          `INSERT INTO resources (kind, id, data) VALUES ('project', 'prj_seeded', '\\x00'), ('organization', 'acme', '\\x00')`,
+        );
+        await client.query(
+          `INSERT INTO resource_audit (kind, resource_id, data, version_hash, tag) VALUES ('project', 'prj_seeded', '\\x00', '', '')`,
         );
 
         const reopened = await PostgresStore.open(db.databaseUrl);
         await reopened.close();
 
+        const remaining = await client.query(
+          `SELECT kind, id FROM resources ORDER BY kind`,
+        );
+        expect(remaining.rows, "v4 removed the Project row and kept the rest").toEqual([
+          { kind: "organization", id: "acme" },
+        ]);
+        const projectAudit = await client.query(
+          `SELECT count(*)::int AS n FROM resource_audit WHERE kind = 'project'`,
+        );
+        expect((projectAudit.rows[0] as { n: number }).n).toBe(0);
+
         const sweepIndex = await client.query(
           `SELECT indexname FROM pg_indexes
            WHERE tablename = 'workflow_execution_events'