@stigmer/server 3.37.1 → 3.38.1

package/src/domain/organization/__tests__/organization-delete.test.ts

@@ -0,0 +1,266 @@
+/**
+ * Pins the organization delete's order through a composed server in the
+ * trusted-local posture: everything that names the organization goes
+ * before its row, and a fault stops the delete with the organization in
+ * place. An organization's id is its slug and the delete frees the slug for
+ * anyone, so a row left behind would belong to the slug's next holder.
+ *
+ *   - the `org-delete:pre-delete` slot runs with the organization loaded
+ *     and still stored, and its rows still in place;
+ *   - a slot step's refusal answers its own code and copy, and leaves the
+ *     organization and its rows;
+ *   - the organization's policy rows are revoked before its row, as
+ *     principal and as resource: a revocation fault answers Internal with
+ *     fixed copy, leaves the organization and its owner row, and a retry
+ *     completes the delete;
+ *   - a slug freed by the delete and created again carries none of the old
+ *     organization's rows.
+ *
+ * The policy store is the library's in-memory double, composed as the
+ * IamPolicy store driver so a test can make one row's delete fault; the
+ * grant path, the role lifecycle and the chain are the library's own.
+ */
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import type { DescMessage } from "@bufbuild/protobuf";
+import { Code, ConnectError, createClient } from "@connectrpc/connect";
+import type { Client, Transport } from "@connectrpc/connect";
+import { createGrpcTransport } from "@connectrpc/connect-node";
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+import { IamPolicyCommandController } from "@stigmer/protos/ai/stigmer/iam/iampolicy/v1/command_pb";
+import type { IamPolicy } from "@stigmer/protos/ai/stigmer/iam/iampolicy/v1/api_pb";
+import type { Organization } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/api_pb";
+import { OrganizationCommandController } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/command_pb";
+import { OrganizationQueryController } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/query_pb";
+
+import { loadConfig } from "../../../boot/config.js";
+import { composeServer } from "../../../boot/compose.js";
+import type { ComposedServer } from "../../../boot/compose.js";
+import { createLogger } from "../../../boot/logger.js";
+import type { GateSlotName } from "../../../extensions/gate-slots.js";
+import type { ServerExtension } from "../../../extensions/registry.js";
+import type { PipelineStep } from "../../../pipeline/pipeline.js";
+import { EXISTING_RESOURCE_KEY } from "../../../pipeline/steps/load-existing.js";
+import {
+  resetOperatorIdentityForTests,
+  setOperatorIdentity,
+} from "../../../pipeline/steps/defaults.js";
+import {
+  fakeIamPolicyStore,
+  orgRole,
+  triple,
+} from "../../iampolicy/__tests__/support.js";
+
+const OPERATOR_EMAIL = "operator@example.com";
+const REFUSED_SLUG = "delete-refused";
+const OUTSIDER = "ida_0byc5k14t1e7b7kdxft7hwz1f7";
+const AGENT = "agt_01hzzzzzzzzzzzzzzzzzzzzzzz";
+
+async function grpcError(run: () => Promise<unknown>): Promise<ConnectError> {
+  try {
+    await run();
+  } catch (error) {
+    if (error instanceof ConnectError) {
+      return error;
+    }
+    throw error;
+  }
+  throw new Error("expected the call to fail");
+}
+
+describe("organization delete (composed server, trusted-local posture)", () => {
+  const policies = fakeIamPolicyStore();
+  /** A policy id whose delete faults while set: the store answering an error mid-revocation. */
+  let faultingDelete: string | undefined;
+  const faultablePolicies = {
+    ...policies,
+    async deleteById(id: string): Promise<void> {
+      if (id === faultingDelete) {
+        throw new Error("policy store unavailable");
+      }
+      await policies.deleteById(id);
+    },
+  };
+
+  /** What the slot's step saw, per organization, while it ran. */
+  const seenBySlot = new Map<string, { loaded: string; rowsNaming: number }>();
+  const slotStep: PipelineStep<DescMessage> = {
+    name: "FakeOrgDeleteStep",
+    execute: (ctx) => {
+      const organization = ctx.get(EXISTING_RESOURCE_KEY) as
+        | Organization
+        | undefined;
+      const id = organization?.metadata?.id ?? "";
+      seenBySlot.set(id, { loaded: id, rowsNaming: rowsNaming(id).length });
+      if (id === REFUSED_SLUG) {
+        throw new ConnectError(
+          "fake edition keeps something for this organization",
+          Code.FailedPrecondition,
+        );
+      }
+    },
+  };
+  const unit: ServerExtension = {
+    name: "fake-org-delete",
+    gateSteps: new Map<GateSlotName, ReadonlyArray<PipelineStep<DescMessage>>>([
+      ["org-delete:pre-delete", [slotStep]],
+    ]),
+    drivers: { iamPolicyStore: faultablePolicies },
+  };
+
+  let dir: string;
+  let server: ComposedServer;
+  let transport: Transport;
+  let organizations: Client<typeof OrganizationCommandController>;
+  let organizationQuery: Client<typeof OrganizationQueryController>;
+  /** The platform's own pipeline: the in-process transport's `internal` caller. */
+  let platform: Client<typeof IamPolicyCommandController>;
+
+  function rowsNaming(org: string): IamPolicy[] {
+    return [...policies.rows.values()].filter(
+      (policy) =>
+        (policy.spec?.resource?.kind === "organization" &&
+          policy.spec.resource.id === org) ||
+        (policy.spec?.principal?.kind === "organization" &&
+          policy.spec.principal.id === org),
+    );
+  }
+
+  /** An organization with its creator's owner row, an outsider's member row, and an agent's scope link to it. */
+  async function organizationWithRows(slug: string): Promise<void> {
+    await organizations.create({
+      apiVersion: "tenancy.stigmer.ai/v1",
+      kind: "Organization",
+      metadata: { name: slug, slug, org: "" },
+      spec: { description: "created by the organization delete test" },
+    });
+    await platform.bootstrapPolicy(orgRole(OUTSIDER, "member", slug));
+    await platform.bootstrapPolicy(
+      triple({ kind: "organization", id: slug }, "organization", {
+        kind: "agent",
+        id: AGENT,
+      }),
+    );
+  }
+
+  beforeAll(async () => {
+    dir = mkdtempSync(path.join(tmpdir(), "organization-delete-test-"));
+    setOperatorIdentity(OPERATOR_EMAIL, "The Operator");
+    server = await composeServer({
+      config: loadConfig({
+        STIGMER_MODEL_REGISTRY_REFRESH: "off",
+        TEMPORAL_HOST_PORT: "127.0.0.1:1",
+        DB_PATH: path.join(dir, "stigmer.db"),
+        STORAGE_PATH: path.join(dir, "storage"),
+        ARTIFACT_LOCAL_BASE_PATH: path.join(dir, "artifacts"),
+        STIGMER_OPERATOR_EMAIL: OPERATOR_EMAIL,
+      }),
+      logger: createLogger({ level: "error", pretty: false, write: () => {} }),
+      extensions: [unit],
+      portOverride: 0,
+      host: "127.0.0.1",
+    });
+    const port = await server.start();
+    transport = createGrpcTransport({ baseUrl: `http://127.0.0.1:${port}` });
+    organizations = createClient(OrganizationCommandController, transport);
+    organizationQuery = createClient(OrganizationQueryController, transport);
+    platform = createClient(
+      IamPolicyCommandController,
+      server.inProcessTransport,
+    );
+  });
+
+  afterAll(async () => {
+    await server.shutdown();
+    resetOperatorIdentityForTests();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  beforeEach(() => {
+    faultingDelete = undefined;
+  });
+
+  it("runs the slot with the organization and its rows in place, then removes every row naming it", async () => {
+    await organizationWithRows("delete-clean");
+    expect(rowsNaming("delete-clean")).toHaveLength(3);
+
+    await organizations.delete({ value: "delete-clean" });
+
+    expect(seenBySlot.get("delete-clean")).toEqual({
+      loaded: "delete-clean",
+      rowsNaming: 3,
+    });
+    expect(rowsNaming("delete-clean")).toEqual([]);
+    const gone = await grpcError(() =>
+      organizationQuery.get({ value: "delete-clean" }),
+    );
+    expect(gone.code).toBe(Code.NotFound);
+  });
+
+  it("a slot step's refusal answers its own copy and leaves the organization and its rows", async () => {
+    await organizationWithRows(REFUSED_SLUG);
+
+    const refused = await grpcError(() =>
+      organizations.delete({ value: REFUSED_SLUG }),
+    );
+
+    expect(refused.code).toBe(Code.FailedPrecondition);
+    expect(refused.rawMessage).toBe(
+      "fake edition keeps something for this organization",
+    );
+    expect(
+      (await organizationQuery.get({ value: REFUSED_SLUG })).metadata?.id,
+    ).toBe(REFUSED_SLUG);
+    expect(rowsNaming(REFUSED_SLUG)).toHaveLength(3);
+  });
+
+  it("a revocation fault fails the delete with the organization and its owner in place, and the retry completes it", async () => {
+    await organizationWithRows("delete-faults");
+    const member = rowsNaming("delete-faults").find(
+      (row) => row.spec?.relation === "member",
+    );
+    faultingDelete = member?.metadata?.id;
+
+    const failed = await grpcError(() =>
+      organizations.delete({ value: "delete-faults" }),
+    );
+
+    expect(failed.code).toBe(Code.Internal);
+    expect(failed.rawMessage).toBe(
+      "failed to remove the organization's access policies",
+    );
+    expect(
+      (await organizationQuery.get({ value: "delete-faults" })).metadata?.id,
+    ).toBe("delete-faults");
+    // The agent's scope link went first; the revocation stopped at the
+    // member row, before the owner row the retry needs.
+    expect(
+      rowsNaming("delete-faults")
+        .map((row) => row.spec?.relation)
+        .sort(),
+    ).toEqual(["member", "owner"]);
+
+    faultingDelete = undefined;
+    await organizations.delete({ value: "delete-faults" });
+    expect(rowsNaming("delete-faults")).toEqual([]);
+  });
+
+  it("a slug freed by the delete and created again carries none of the old organization's rows", async () => {
+    await organizationWithRows("delete-reborn");
+    await organizations.delete({ value: "delete-reborn" });
+
+    await organizations.create({
+      apiVersion: "tenancy.stigmer.ai/v1",
+      kind: "Organization",
+      metadata: { name: "delete-reborn", slug: "delete-reborn", org: "" },
+      spec: { description: "the slug, taken again" },
+    });
+
+    expect(
+      rowsNaming("delete-reborn").map((row) => row.spec?.relation),
+    ).toEqual(["owner"]);
+  });
+});

package/src/domain/organization/controller.ts

@@ -54,6 +54,7 @@ import type { ResolvedGateSteps } from "../../extensions/gate-slots.js";
 import { stepsForSlot } from "../../extensions/gate-slots.js";
 import { ALL_ORGANIZATIONS } from "../../extensions/organization-directory.js";
 import type { OrganizationDirectory } from "../../extensions/organization-directory.js";
+import type { IamPolicyGrantPath } from "../iampolicy/grant-path.js";
 import type { ResourceAuthorizationLifecycle } from "../../extensions/resource-authorization.js";
 import { apiResourceKindKey } from "../../pipeline/interceptors/apiresource.js";
 import {
@@ -105,15 +106,21 @@ import { newValidateVisibilityStep } from "../../pipeline/steps/validate-visibil
 import { ResourceNotFoundError } from "../../store/interface.js";
 import type { Store } from "../../store/interface.js";
 import { organizationSearchExtractor } from "./search-extractor.js";
-import { newCheckOrgDuplicateStep, newCopySlugToIdStep } from "./steps.js";
+import {
+  newCheckOrgDuplicateStep,
+  newCopySlugToIdStep,
+  newRevokeOrganizationPoliciesStep,
+} from "./steps.js";
 
 export interface OrganizationControllerDeps {
   readonly store: Store;
   readonly logger: Logger;
   /** The composed authorization seam — the Authorize step at position 1 of every chain calls it (O2, DD-007 §3). */
   readonly authorizer: Authorizer;
-  /** The composed slot registrations — this domain's post-persist slot (O4). */
+  /** The composed slot registrations — this domain's create and delete slots (O4). */
   readonly gateSteps: ResolvedGateSteps;
+  /** The one grant path: the delete revokes the organization's rows through it before its row goes. */
+  readonly grantPath: IamPolicyGrantPath;
   /** The composed tuple-lifecycle driver — undefined = the shared steps no-op (C2). */
   readonly authorizationLifecycle: ResourceAuthorizationLifecycle | undefined;
   /** The composed query directory — undefined = OSS single-tenant behavior (C2). */
@@ -319,22 +326,38 @@ async function apply(
     : update(deps, withResolvedApplyId(OrganizationSchema, org, reqCtx), ctx);
 }
 
-/** Delete — returns the deleted organization (gRPC audit-trail convention). */
+/**
+ * Delete — returns the deleted organization (gRPC audit-trail convention).
+ *
+ * Everything that names the organization goes before its row, and a fault
+ * stops the delete with the organization intact: an organization's id is
+ * its slug, the delete frees the slug for anyone, and whatever outlived
+ * the row would belong to the slug's next holder. So, after the load:
+ *
+ *   1. the `org-delete:pre-delete` slot, where an edition refuses or
+ *      removes the rows it keeps for the organization (empty in OSS);
+ *   2. RevokeOrganizationPolicies, every policy row naming the
+ *      organization, through the grant path, never caught;
+ *   3. the row;
+ *   4. CleanupIamPolicies, the lifecycle's post-delete event: best-effort
+ *      like every delete chain's, it revokes whatever a concurrent write
+ *      named the organization with after step 2, and runs a composed
+ *      driver's post-delete companions;
+ *   5. the search entry.
+ */
 async function deleteOrganization(
   deps: OrganizationControllerDeps,
   orgId: OrganizationId,
   ctx: HandlerContext,
 ): Promise<Organization> {
+  type DeleteInput = typeof OrganizationCommandController.method.delete.input;
   const reqCtx = new RequestContext(
     OrganizationCommandController.method.delete.input,
     orgId,
     callerIdentityOf(ctx),
     kindOf(ctx),
   );
-  await newPipeline<typeof OrganizationCommandController.method.delete.input>(
-    "organization-delete",
-    deps.logger,
-  )
+  const builder = newPipeline<DeleteInput>("organization-delete", deps.logger)
     .addStep(
       newAuthorizeStep(
         OrganizationCommandController.method.delete,
@@ -343,7 +366,16 @@ async function deleteOrganization(
     )
     .addStep(newValidateProtoStep())
     .addStep(newExtractResourceIdStep())
-    .addStep(newLoadExistingForDeleteStep(deps.store, OrganizationSchema))
+    .addStep(newLoadExistingForDeleteStep(deps.store, OrganizationSchema));
+  // The pre-delete gate slot (see the doc comment above). Empty in OSS.
+  for (const step of stepsForSlot<DeleteInput>(
+    deps.gateSteps,
+    "org-delete:pre-delete",
+  )) {
+    builder.addStep(step);
+  }
+  await builder
+    .addStep(newRevokeOrganizationPoliciesStep<DeleteInput>(deps.grantPath))
     .addStep(newDeleteResourceStep(deps.store))
     .addStep(
       newCleanupIamPoliciesStep(deps.authorizationLifecycle, deps.logger),

package/src/domain/organization/steps.ts

@@ -10,16 +10,28 @@
  * uniqueness guarantee, mirroring cloud's OrganizationCreateHandler
  * (CheckDuplicate + CopySlugToId) step-for-step.
  *
- * Proven by organization.conformance.test.ts (CONFORMANCE_TARGET=local)
- * and __tests__/organization.test.ts.
+ * The same deviation shapes the delete: a freed slug is anyone's to take,
+ * so newRevokeOrganizationPoliciesStep revokes the organization's policy
+ * rows BEFORE its row is deleted, and fails the delete when it cannot.
+ *
+ * Proven by organization.conformance.test.ts (CONFORMANCE_TARGET=local),
+ * __tests__/organization.test.ts and __tests__/organization-delete.test.ts.
  */
+import { create } from "@bufbuild/protobuf";
+import type { DescMessage } from "@bufbuild/protobuf";
+
 import { ResourceNotFoundError } from "../../store/interface.js";
 import type { Store } from "../../store/interface.js";
 import { alreadyExistsError, internalError } from "../../pipeline/errors.js";
 import type { PipelineStep } from "../../pipeline/pipeline.js";
 import type { RequestContext } from "../../pipeline/request-context.js";
+import { EXISTING_RESOURCE_KEY } from "../../pipeline/steps/load-existing.js";
 import { metadataOf } from "../../pipeline/steps/shapes.js";
+import type { IamPolicyGrantPath } from "../iampolicy/grant-path.js";
 
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import { ApiResourceRefSchema } from "@stigmer/protos/ai/stigmer/iam/iampolicy/v1/spec_pb";
+import type { Organization } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/api_pb";
 import { OrganizationSchema } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/api_pb";
 
 /**
@@ -98,3 +110,55 @@ export function newCopySlugToIdStep(): PipelineStep<typeof OrganizationSchema> {
     },
   };
 }
+
+/**
+ * Revokes every policy row that names the organization, as principal or as
+ * resource, before the delete removes its row: the rows its members hold
+ * on it, and the scope link every organization-scoped resource holds to
+ * it. Runs after the `org-delete:pre-delete` slot and before
+ * DeleteResource.
+ *
+ * The generic delete chains clean up after the row and log a fault,
+ * because a deleted resource's rows grant nothing once it is gone. An
+ * organization is the exception: its id is its slug, the delete frees the
+ * slug, and a row left behind would grant whoever creates the slug next.
+ * So this step does not catch. A fault fails the delete with the
+ * organization in place, and a retry resumes where the revocation stopped
+ * (the grant path revokes the organization's owners last, so the owner
+ * who retries still can). The grant path fires the composed driver's
+ * `onPolicyRevoked` before each row, so a composition's tuples go with
+ * their rows. The post-delete CleanupIamPolicies still runs: it catches
+ * whatever a concurrent write named the organization with in between.
+ */
+export function newRevokeOrganizationPoliciesStep<Desc extends DescMessage>(
+  grantPath: IamPolicyGrantPath,
+): PipelineStep<Desc> {
+  return {
+    name: "RevokeOrganizationPolicies",
+    async execute(ctx: RequestContext<Desc>): Promise<void> {
+      const organization = ctx.get(EXISTING_RESOURCE_KEY) as
+        | Organization
+        | undefined;
+      const id = organization?.metadata?.id ?? "";
+      if (id === "") {
+        throw internalError(
+          new Error("organization delete reached RevokeOrganizationPolicies without its loaded row"),
+          "failed to remove the organization's access policies",
+        );
+      }
+      try {
+        await grantPath.cleanupResource(
+          create(ApiResourceRefSchema, {
+            kind: ApiResourceKind[ApiResourceKind.organization],
+            id,
+          }),
+        );
+      } catch (error) {
+        throw internalError(
+          error,
+          "failed to remove the organization's access policies",
+        );
+      }
+    },
+  };
+}

package/src/domain/platform/__tests__/platform.test.ts

@@ -14,7 +14,9 @@
  *     executioncontext decrypt lane uses, bound to exactly the named
  *     execution id;
  *   - getRunnerBootstrapConfig echoes the configured Temporal coordinates
- *     with the token fields empty (minting a proxy token is cloud-only);
+ *     with the token fields empty (minting a proxy token is cloud-only),
+ *     and publishes the runner-bootstrap address rather than the one the
+ *     server dials when the two differ (stigmer#1357);
  *   - getServerInfo reports the build stamp by default and the release a
  *     library consumer states through ComposeOptions.version otherwise
  *     (stigmer#1168: unbundled, the stamp is always "dev"), and a
@@ -278,11 +280,61 @@ describe("platform domain (composed with a stated version)", () => {
   });
 });
 
+/**
+ * stigmer#1357 through the real stack: a server that dials Temporal by a
+ * name its runners cannot resolve publishes the address they can, from
+ * the environment through loadConfig and the composition root to the
+ * wire. The composed-server arm above is the default: with no override,
+ * the published address is the server's own.
+ */
+describe("platform domain (composed for runners off the server's network)", () => {
+  let server: ComposedServer;
+  let client: PlatformClient;
+  let dir: string;
+
+  beforeAll(async () => {
+    dir = mkdtempSync(
+      path.join(tmpdir(), "platform-domain-runner-address-test-"),
+    );
+    vi.stubEnv("STIGMER_ENCRYPTION_KEY", ENC_KEY.toString("base64"));
+    server = await composeServer({
+      config: loadConfig({
+        STIGMER_MODEL_REGISTRY_REFRESH: "off",
+        DB_PATH: path.join(dir, "stigmer.db"),
+        ARTIFACT_LOCAL_BASE_PATH: path.join(dir, "artifacts"),
+        TEMPORAL_HOST_PORT: "127.0.0.1:7777",
+        TEMPORAL_NAMESPACE: "conformance-ns",
+        STIGMER_RUNNER_BOOTSTRAP_TEMPORAL_ADDRESS: "temporal.example.test:7233",
+      }),
+      logger: silentLogger,
+      portOverride: 0,
+      host: "127.0.0.1",
+    });
+    const port = await server.start();
+    client = createClient(
+      PlatformQueryController,
+      createGrpcTransport({ baseUrl: `http://127.0.0.1:${port}` }),
+    );
+  });
+
+  afterAll(async () => {
+    await server.shutdown();
+    rmSync(dir, { recursive: true, force: true });
+    vi.unstubAllEnvs();
+  });
+
+  it("getRunnerBootstrapConfig publishes the runner-bootstrap address, with the server's namespace", async () => {
+    const config = await client.getRunnerBootstrapConfig({});
+    expect(config.temporalAddress).toBe("temporal.example.test:7233");
+    expect(config.temporalNamespace).toBe("conformance-ns");
+  });
+});
+
 describe("platform domain (keyless runner-token service)", () => {
   it("a keyless service answers not-minted — fail-soft, never an error", async () => {
     const transport = createRouterTransport((router) => {
       registerPlatformServices(router, {
-        temporalHostPort: "localhost:7233",
+        runnerBootstrapTemporalAddress: "localhost:7233",
         temporalNamespace: "default",
         runnerAuthService: newExecutionScopedRunnerCredentialProvider(
           RunnerAuthService.create(undefined),
@@ -318,7 +370,7 @@ describe("platform domain (license status)", () => {
   function clientWith(provider: LicenseStatusProvider) {
     const transport = createRouterTransport((router) => {
       registerPlatformServices(router, {
-        temporalHostPort: "localhost:7233",
+        runnerBootstrapTemporalAddress: "localhost:7233",
         temporalNamespace: "default",
         runnerAuthService: newExecutionScopedRunnerCredentialProvider(
           RunnerAuthService.create(undefined),

package/src/domain/platform/controller.ts

@@ -78,12 +78,14 @@ import { TOKEN_TYPE_EXECUTION_SCOPED } from "../../runnerauth/runnerauth.js";
 
 export interface PlatformControllerDeps {
   /**
-   * Temporal coordinates this server runs against, published to embedded
-   * runners. In OSS the server and its runners are co-located, so the
-   * address the server itself dials is the one runners should dial too —
-   * no internal/external split (unlike Stigmer Cloud).
+   * The Temporal coordinates published to embedded runners. The address
+   * is the one a runner should dial, which is not always the one this
+   * server dials: a clustered server reaches Temporal by an internal name
+   * its desktop runners cannot resolve (stigmer#1357). The composition
+   * root passes config.runnerBootstrapTemporalAddress, which defaults to
+   * the server's own address; the namespace is the server's.
    */
-  readonly temporalHostPort: string;
+  readonly runnerBootstrapTemporalAddress: string;
   readonly temporalNamespace: string;
   /**
    * Mints the execution-scoped tokens getRunnerScopedToken hands to
@@ -202,7 +204,9 @@ async function getLicenseStatus(
 
 /**
  * Go GetRunnerBootstrapConfig: the Temporal coordinates an embedded runner
- * should connect to so it can self-bootstrap from a token alone. The
+ * should connect to so it can self-bootstrap from a token alone: the
+ * address deps name for runners, never assumed to be the server's own
+ * (the proto's "the one reachable by the caller"). The
  * RunnerAccessToken / TokenType / RunnerAccessTokenExpiresInSeconds fields
  * are intentionally left empty in OSS: minting an iss=stigmer proxy token
  * is a cloud-only capability (OSS has no Cursor BiDi proxy to authenticate
@@ -221,7 +225,7 @@ async function getRunnerBootstrapConfig(
   ctx: HandlerContext,
 ): Promise<GetRunnerBootstrapConfigOutput> {
   const output = create(GetRunnerBootstrapConfigOutputSchema, {
-    temporalAddress: deps.temporalHostPort,
+    temporalAddress: deps.runnerBootstrapTemporalAddress,
     temporalNamespace: deps.temporalNamespace,
   });
   const bootstrapCredentials =

package/src/domain/workflowexecution/__tests__/store-faults.test.ts

@@ -45,7 +45,12 @@ import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/
 
 import { createLogger } from "../../../boot/logger.js";
 import { callerIdentityKey } from "../../../pipeline/interceptors/auth.js";
-import { testCallerIdentity } from "../../../pipeline/__tests__/support.js";
+import {
+  errorOf,
+  failingStore,
+  testCallerIdentity,
+  untouchable,
+} from "../../../pipeline/__tests__/support.js";
 import { RequestContext } from "../../../pipeline/request-context.js";
 import { newPermissiveSingleTeamAuthorizer } from "../../../pipeline/steps/authorize.js";
 import { ResourceNotFoundError } from "../../../store/interface.js";
@@ -80,35 +85,10 @@ const WORKFLOW_ID = "wfl_storefault";
 const EXECUTION_FAULT_COPY = "failed to load workflow execution";
 const WORKFLOW_FAULT_COPY = "failed to load workflow";
 
-/** A dependency the call must never reach once its load has failed. */
-function untouchable<T extends object>(name: string): T {
-  return new Proxy({} as T, {
-    get(_target, prop) {
-      throw new Error(`${name}.${String(prop)} reached after a failed load`);
-    },
-  });
-}
-
-/** A store whose every read fails with the given error. */
-function failingStore(error: Error): Store {
-  return {
-    getResource: () => Promise.reject(error),
-  } as unknown as Store;
-}
-
 const MISSING = (): Error =>
   new ResourceNotFoundError(`workflow_execution/${EXECUTION_ID}`);
 const LOCKED = (): Error => new Error("SQLITE_BUSY: database is locked");
 
-async function errorOf(call: () => Promise<unknown>): Promise<ConnectError> {
-  const error = await call().then(
-    () => undefined,
-    (e: unknown) => e,
-  );
-  expect(error, "the call must fail").toBeInstanceOf(ConnectError);
-  return error as ConnectError;
-}
-
 function handlerContext(): HandlerContext {
   const values = createContextValues();
   values.set(callerIdentityKey, testCallerIdentity());

package/src/extensions/__tests__/registry.test.ts

@@ -491,6 +491,9 @@ describe("resolveExtensions — loud-fail throws (DD-006 §2b)", () => {
       // The ninth: the organization create chain before Persist, where a
       // limit on which organizations may exist refuses with nothing written.
       "org-create:pre-side-effect-gate",
+      // The tenth: the organization delete chain before any write, where an
+      // edition removes or refuses what it keeps for the organization.
+      "org-delete:pre-delete",
       "sandbox-acquisition:gate",
       "session-create:pre-side-effect-gate",
     ]);

package/src/extensions/gate-slots.ts

@@ -53,6 +53,19 @@
  * limit belongs here too. `apply` delegates to create on its create arm,
  * so the slot fires there as well.
  *
+ * The tenth, `org-delete:pre-delete`: the organization delete chain after
+ * LoadExistingForDelete and before any write, so the organization exists
+ * and is loaded (EXISTING_RESOURCE_KEY) while its steps run. An
+ * organization's id is its slug and its delete frees the slug for anyone,
+ * so whatever an edition keeps for the organization must go before the row
+ * does, or be refused: a row left behind would belong to whoever creates
+ * the slug next. Its steps may refuse (Enterprise refuses while an
+ * identity provider still signs in platform-managed organizations) or
+ * remove the edition's own rows; either way a throw fails the delete with
+ * the organization intact, and the retry re-runs every step, so each owns
+ * its idempotency. After the slot the chain revokes the organization's own
+ * policy rows, also before the row and also failing closed.
+ *
  * Two enforcement layers, deliberately redundant, both derived from the
  * ONE literal tuple below (lockstep by construction):
  *   - GateSlotName (compile time): the union of declared slot literals.
@@ -92,6 +105,7 @@ export const GATE_SLOT_NAMES = [
   "identity-account-provision:post-persist",
   "iam-policy-create:pre-side-effect-gate",
   "org-create:pre-side-effect-gate",
+  "org-delete:pre-delete",
 ] as const;
 
 /** The declared slot-name union — a registration outside it fails tsc. */

package/src/pipeline/__tests__/blind-not-found.test.ts

@@ -44,11 +44,6 @@ const PENDING: ReadonlyMap<string, number> = new Map([
   ["domain/artifact/controller.ts", 1],
   ["domain/environment/controller.ts", 1],
   ["domain/environment/steps.ts", 1],
-  ["domain/mcpserver/complete-oauth-connect.ts", 1],
-  ["domain/mcpserver/connect.ts", 1],
-  ["domain/mcpserver/controller.ts", 1],
-  ["domain/mcpserver/initiate-oauth-connect.ts", 1],
-  ["domain/mcpserver/start-connect.ts", 2],
   ["domain/plugin/controller.ts", 1],
   ["domain/skill/controller.ts", 1],
   ["domain/workflow/controller.ts", 1],