@stigmer/server 3.14.0 → 3.15.0

package/src/domain/workflowexecution/controller.ts

@@ -49,6 +49,7 @@ import { newPipeline } from "../../pipeline/pipeline.js";
 import { callerIdentityOf } from "../../pipeline/interceptors/auth.js";
 import { RequestContext } from "../../pipeline/request-context.js";
 import { newAuthorizeStep } from "../../pipeline/steps/authorize.js";
+import { newAuthorizeRunTargetStep } from "../../pipeline/steps/authorize-run-target.js";
 import { newGuardReservedLabelsStep } from "../../pipeline/steps/guard-reserved-labels.js";
 import { newBuildUpdateStateStep } from "../../pipeline/steps/build-update-state.js";
 import { newBuildNewStateStep } from "../../pipeline/steps/defaults.js";
@@ -116,6 +117,7 @@ import { getEventLog } from "./get-event-log.js";
 import { getExecutionSummary } from "./get-execution-summary.js";
 import { listPendingApprovals } from "./list-pending-approvals.js";
 import { loadAllWorkflowExecutions } from "./queries.js";
+import { workflowExecutionRunTarget } from "./run-target.js";
 import { workflowExecutionSearchExtractor } from "./search-extractor.js";
 import type { SandboxLane } from "../../sandbox/lane.js";
 import type { WorkflowSandboxTerminalObserver } from "../../sandbox/steps.js";
@@ -243,6 +245,11 @@ export function registerWorkflowExecutionServices(
  * Create — create.go buildCreatePipeline, step-for-step (the numbered
  * 15-step chain): validation (proto → visibility → slug →
  * workflow-or-instance presence, the #196 InvalidArgument contrast) →
+ * the run gate (AuthorizeRunTarget, P1 sp.run-gate: the first step after
+ * the target reference is guaranteed, asking workflow_instance#can_execute
+ * or workflow#can_execute by request shape — before the engine gate so a
+ * denied caller learns nothing about engine state, and before the workflow
+ * lookup, so a denial reads nothing) →
  * the ENGINE GATE at its pinned position (before every side effect — a
  * down engine orphans nothing; Go's unit test pins that it precedes even
  * the workflow lookup) → default-instance resolution → the standard
@@ -276,6 +283,9 @@ async function createExecution(
     .addStep(newValidateVisibilityStep())
     .addStep(newResolveSlugStep())
     .addStep(newValidateWorkflowOrInstanceStep())
+    .addStep(
+      newAuthorizeRunTargetStep(deps.authorizer, workflowExecutionRunTarget),
+    )
     .addStep(newEnsureEngineAvailableStep(deps.engineState))
     .addStep(
       newCreateDefaultInstanceIfNeededStep({

package/src/domain/workflowexecution/run-target.ts

@@ -0,0 +1,47 @@
+/**
+ * The workflow-execution run-target resolver (P1 sp.run-gate): the chain's
+ * own precedence — an explicit workflow_instance_id fully names the target
+ * (CreateDefaultInstanceIfNeeded returns early on it):
+ * workflow_instance#can_execute; else workflow_id names the blueprint whose
+ * default instance the chain resolves (or mints) only AFTER the gate:
+ * workflow#can_execute (the model derives the default instance's viewers
+ * from the blueprint's, so asking the blueprint's question is what lets the
+ * gate precede the side effect).
+ *
+ * Neither set is ValidateWorkflowOrInstance's INVALID_ARGUMENT, thrown
+ * before this resolver runs — never a check. Pure over the record being
+ * built.
+ */
+import type { WorkflowExecution } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
+
+import {
+  RUN_GATE_CHECKS,
+  type RunTarget,
+} from "../../pipeline/steps/authorize-run-target.js";
+import {
+  runWorkflowDeniedMessage,
+  runWorkflowInstanceDeniedMessage,
+} from "./constants.js";
+
+export function workflowExecutionRunTarget(
+  execution: WorkflowExecution,
+): RunTarget | undefined {
+  const spec = execution.spec;
+  const workflowInstanceId = spec?.workflowInstanceId ?? "";
+  if (workflowInstanceId !== "") {
+    return {
+      ...RUN_GATE_CHECKS.workflowInstance,
+      resourceId: workflowInstanceId,
+      deniedMessage: runWorkflowInstanceDeniedMessage(workflowInstanceId),
+    };
+  }
+  const workflowId = spec?.workflowId ?? "";
+  if (workflowId !== "") {
+    return {
+      ...RUN_GATE_CHECKS.workflow,
+      resourceId: workflowId,
+      deniedMessage: runWorkflowDeniedMessage(workflowId),
+    };
+  }
+  return undefined;
+}

package/src/extensions/__tests__/extension-composition.test.ts

@@ -178,6 +178,55 @@ describe("extension composition (composed server)", () => {
   });
 });
 
+/**
+ * The third edition on the wire (editions program, sp.edition-contract):
+ * a unit declaring ServerEdition.enterprise is answered verbatim by
+ * getServerInfo. The registry is generic over concrete editions, so this
+ * pins the end-to-end path (declaration → resolved registry → platform
+ * controller → wire) for the value no composition emits yet — the day
+ * P4's Enterprise composition declares it, the wire is already proven.
+ */
+describe("extension composition (enterprise edition on the wire)", () => {
+  let server: ComposedServer;
+  let dir: string;
+  let portTransport: Transport;
+
+  const enterpriseUnit: ServerExtension = {
+    name: "fake-enterprise",
+    edition: ServerEdition.enterprise,
+  };
+
+  beforeAll(async () => {
+    dir = mkdtempSync(path.join(tmpdir(), "extension-composition-ee-test-"));
+    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"),
+      }),
+      logger: createLogger({ level: "warn", pretty: false, write: () => {} }),
+      extensions: [enterpriseUnit],
+      portOverride: 0,
+      host: "127.0.0.1",
+    });
+    const port = await server.start();
+    portTransport = createGrpcTransport({
+      baseUrl: `http://127.0.0.1:${port}`,
+    });
+  });
+
+  afterAll(async () => {
+    await server.shutdown();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("answers enterprise on getServerInfo", async () => {
+    const client = createClient(PlatformQueryController, portTransport);
+    const info = await client.getServerInfo({});
+    expect(info.edition).toBe(ServerEdition.enterprise);
+  });
+});
+
 /**
  * The caller-guard arm (entry 20260902.02 ruling Q1): a composed guard
  * is enforced on the SERVING chain and structurally absent from the