@stigmer/runner 3.40.0 → 3.41.0

package/dist/workflows/human-input-orchestrator.js

@@ -2,27 +2,25 @@
  * Human input orchestrator — Temporal workflow-layer HITL signal handler.
  *
  * Registers a signal handler for the human_input task, then blocks until
- * either the signal arrives or the timeout fires. Timeout behavior is
- * determined by the `onTimeout` policy:
- * - "fail": throws an error
- * - "approve": returns auto-approved output
- * - "deny": returns auto-denied output
- * - "escalate": returns the "escalate" outcome — by the outcome-by-name
- *   contract (stigmer/stigmer#781) the loader guarantees the gate declares
- *   an outcome with that exact name and a `then` branch, so the executor's
- *   ordinary outcome routing takes the escalation path.
+ * either the signal arrives or the timeout fires, and reports which one
+ * happened: the reviewer's payload, or a timeout. It applies no timeout
+ * policy. What a timeout means (fail the task, or resolve the gate to a
+ * declared outcome) is decided in the kernel (`workflow-engine/tasks/
+ * human-input.ts`), which also logs how the approval ended, so the two
+ * cannot drift apart across layers.
  *
  * Signal payload shape:
- * { outcome, form_data?, reviewer, reviewer_actor?, responded_at }
+ * { outcome, form_data?, comment?, reviewer, reviewer_actor?, responded_at }
  *
  * TEMPORAL SANDBOX: This file runs inside the deterministic workflow isolate.
  */
 import { defineSignal, setHandler, condition } from "@temporalio/workflow";
+const TIMED_OUT = { timedOut: true };
 /**
  * Orchestrates a human_input task — blocks until signal or timeout.
  */
 export async function orchestrateHumanInput(config) {
-    const { signalName, timeoutSeconds, onTimeout } = config;
+    const { signalName, timeoutSeconds } = config;
     let payload;
     let received = false;
     const signal = defineSignal(signalName);
@@ -31,43 +29,13 @@ export async function orchestrateHumanInput(config) {
         received = true;
     });
     if (timeoutSeconds > 0) {
-        const timeoutMs = timeoutSeconds * 1000;
-        const completed = await condition(() => received, timeoutMs);
-        if (!completed) {
-            return handleTimeout(signalName, onTimeout);
-        }
+        const completed = await condition(() => received, timeoutSeconds * 1000);
+        if (!completed)
+            return TIMED_OUT;
     }
     else {
         await condition(() => received);
     }
     return payload;
 }
-function handleTimeout(signalName, policy) {
-    switch (policy) {
-        case "approve":
-            return {
-                outcome: "approve",
-                auto_resolved: true,
-                reason: "timeout",
-            };
-        case "deny":
-            return {
-                outcome: "deny",
-                auto_resolved: true,
-                reason: "timeout",
-            };
-        case "escalate":
-            // The outcome word IS the declared outcome's name (loader-enforced),
-            // so no positional remapping happens downstream — the executor's name
-            // lookup routes the escalation branch directly.
-            return {
-                outcome: "escalate",
-                auto_resolved: true,
-                reason: "timeout",
-            };
-        case "fail":
-        default:
-            throw new Error(`human_input task timed out waiting for signal '${signalName}'`);
-    }
-}
 //# sourceMappingURL=human-input-orchestrator.js.map

package/dist/workflows/human-input-orchestrator.js.map

@@ -1 +1 @@
-{"version":3,"file":"human-input-orchestrator.js","sourceRoot":"","sources":["../../src/workflows/human-input-orchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAQ3E;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAiC;IAEjC,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;IAEzD,IAAI,OAAqC,CAAC;IAC1C,IAAI,QAAQ,GAAG,KAAK,CAAC;IAErB,MAAM,MAAM,GAAG,YAAY,CAAqB,UAAU,CAAC,CAAC;IAC5D,UAAU,CAAC,MAAM,EAAE,CAAC,IAAsB,EAAE,EAAE;QAC5C,OAAO,GAAG,IAAI,CAAC;QACf,QAAQ,GAAG,IAAI,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,SAAS,GAAG,cAAc,GAAG,IAAI,CAAC;QACxC,MAAM,SAAS,GAAG,MAAM,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;QAE7D,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO,aAAa,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;SAAM,CAAC;QACN,MAAM,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;IAED,OAAO,OAAQ,CAAC;AAClB,CAAC;AAED,SAAS,aAAa,CACpB,UAAkB,EAClB,MAA+B;IAE/B,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,SAAS;YACZ,OAAO;gBACL,OAAO,EAAE,SAAS;gBAClB,aAAa,EAAE,IAAI;gBACnB,MAAM,EAAE,SAAS;aAClB,CAAC;QAEJ,KAAK,MAAM;YACT,OAAO;gBACL,OAAO,EAAE,MAAM;gBACf,aAAa,EAAE,IAAI;gBACnB,MAAM,EAAE,SAAS;aAClB,CAAC;QAEJ,KAAK,UAAU;YACb,qEAAqE;YACrE,sEAAsE;YACtE,gDAAgD;YAChD,OAAO;gBACL,OAAO,EAAE,UAAU;gBACnB,aAAa,EAAE,IAAI;gBACnB,MAAM,EAAE,SAAS;aAClB,CAAC;QAEJ,KAAK,MAAM,CAAC;QACZ;YACE,MAAM,IAAI,KAAK,CACb,kDAAkD,UAAU,GAAG,CAChE,CAAC;IACN,CAAC;AACH,CAAC"}
+{"version":3,"file":"human-input-orchestrator.js","sourceRoot":"","sources":["../../src/workflows/human-input-orchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAS3E,MAAM,SAAS,GAAsB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAExD;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAiC;IAEjC,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,GAAG,MAAM,CAAC;IAE9C,IAAI,OAAqC,CAAC;IAC1C,IAAI,QAAQ,GAAG,KAAK,CAAC;IAErB,MAAM,MAAM,GAAG,YAAY,CAAqB,UAAU,CAAC,CAAC;IAC5D,UAAU,CAAC,MAAM,EAAE,CAAC,IAAsB,EAAE,EAAE;QAC5C,OAAO,GAAG,IAAI,CAAC;QACf,QAAQ,GAAG,IAAI,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,SAAS,GAAG,MAAM,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC,CAAC;QACzE,IAAI,CAAC,SAAS;YAAE,OAAO,SAAS,CAAC;IACnC,CAAC;SAAM,CAAC;QACN,MAAM,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;IAED,OAAO,OAAQ,CAAC;AAClB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stigmer/runner",
-  "version": "3.40.0",
+  "version": "3.41.0",
   "description": "Embeddable Temporal worker for the Stigmer AI agent platform — handles agent execution, workflow orchestration, and MCP server management",
   "license": "Apache-2.0",
   "type": "module",
@@ -109,10 +109,10 @@
     "@opentelemetry/sdk-metrics": "^2.0.0",
     "@opentelemetry/sdk-trace-base": "^2.0.0",
     "@opentelemetry/sdk-trace-node": "^2.0.0",
-    "@stigmer/outbound": "3.40.0",
-    "@stigmer/protos": "3.40.0",
-    "@stigmer/temporal-codecs": "3.40.0",
-    "@stigmer/zip-structure": "3.40.0",
+    "@stigmer/outbound": "3.41.0",
+    "@stigmer/protos": "3.41.0",
+    "@stigmer/temporal-codecs": "3.41.0",
+    "@stigmer/zip-structure": "3.41.0",
     "@temporalio/activity": "1.16.2",
     "@temporalio/common": "1.16.2",
     "@temporalio/interceptors-opentelemetry": "1.16.2",

package/src/__test-utils__/config-fixture.ts

@@ -45,6 +45,7 @@ export function testConfig(overrides: Partial<Config> = {}): Config {
     stigmerBackendEndpoint: INERT_ENDPOINT,
     stigmerTokenRef: { current: null },
     mcpBridgeEndpoint: null,
+    mcpPublicEndpoint: null,
     cursorApiKey: "",
     workspaceRootDir: join(tmpdir(), "stigmer-runner-test-workspaces"),
     mode: "local",

package/src/__test-utils__/execution-record-fixture.ts

@@ -65,7 +65,8 @@ export interface ExecutionRecordOptions {
   readonly maxCostUsd?: number;
   /**
    * `ExecutionConfig.max_tool_rounds`: the hard tool-round budget the engine
-   * enforces (native: LangGraph's `recursionLimit`, `shared/tool-rounds.ts`).
+   * enforces (native: the execution budget middleware's round count,
+   * `shared/tool-rounds.ts`).
    * Omitted or 0 = unlimited, the proto's default. Clamped to the floor of 10
    * by the runner, so a scenario that wants the limit reached scripts a model
    * that keeps calling tools (`repeatLast`).

package/src/__test-utils__/harness-contract/runtime-contract.ts

@@ -482,7 +482,7 @@ export async function assertNonExecutingDecisionSettlesSkipped(
  *
  * The execution SETS the budget it exhausts: the record carries the smallest
  * valid `max_tool_rounds` (an unbounded execution has no limit to reach — on
- * native `resolveRecursionLimit(0)` is unlimited, and the first run of this
+ * native `resolveToolRoundLimit(0)` is unlimited, and the first run of this
  * arm against it spun until the test timed out). The fake
  * exhausts whatever budget it is given; a real engine spins its cheapest
  * ungated tool until the graph stops it.
@@ -877,8 +877,10 @@ export async function assertResolutionErrorFailsBeforeEngine(harness: RuntimeCon
   expect(slimOf(subject, invocation).phase).toBe("EXECUTION_FAILED");
   expect(driver.record.persistedPhases, `${subject.name}: nothing was persisted before the failure`).toEqual([ExecutionPhase.EXECUTION_FAILED]);
   const final = finalStatusOf(harness, driver);
-  expect(final.error).toBe("Execution failed: [Error] runtime fault injected at getAgent");
-  expect(systemMessages(final)).toEqual([TERMINAL_COPY.internalFailure.row, "Error details: [Error] runtime fault injected at getAgent"]);
+  // One grammar for a FAILED `status.error` (stigmer#1122): the described
+  // fault, unframed, exactly what the details row carries.
+  expect(final.error).toBe("[Error] runtime fault injected at getAgent");
+  expect(systemMessages(final)).toEqual([TERMINAL_COPY.internalFailure.row, `Error details: ${final.error}`]);
   expect(driver.record.setupProgress).toEqual(["Fetching execution", "Resolving agent blueprint"]);
   expect(driver.record.sessionUpdates).toHaveLength(0);
   return { driver, invocations: [invocation], final };

package/src/__test-utils__/test-gate.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether this run is a test gate: `STIGMER_TEST_GATE=1`, set by the CI lanes
+ * and the local gates. A gate provides every dependency a suite needs, so a
+ * suite that would skip because a dependency is missing (the Temporal test
+ * server cannot boot, say) fails there instead. Outside a gate the same suite
+ * skips by name with its reason.
+ */
+export const IN_TEST_GATE = process.env.STIGMER_TEST_GATE === "1";

package/src/__tests__/exit-backstop.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { EXIT_BACKSTOP_MS, armExitBackstop, describeResources } from "../exit-backstop.js";
+
+/**
+ * The exit backstop's contract (exit-backstop.ts): it never holds the loop,
+ * it stays silent before its bound, and at the bound it names what is still
+ * alive and exits 0, once. The real-process behaviour (a healthy runner
+ * exits in milliseconds, a leaked handle is cut at the bound) is proven
+ * against the built runner and by the execution conformance harness's
+ * slow-exit line; these pin the logic.
+ */
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+function arm(overrides: { boundMs?: number; resources?: string[] } = {}) {
+  const exit = vi.fn<(code: number) => void>();
+  const log = vi.fn<(line: string) => void>();
+  const timer = armExitBackstop({
+    boundMs: overrides.boundMs,
+    exit,
+    log,
+    activeResources: () => overrides.resources ?? ["TCPSocketWrap", "Timeout", "TCPSocketWrap"],
+  });
+  return { exit, log, timer };
+}
+
+describe("armExitBackstop", () => {
+  it("does not hold the event loop", () => {
+    const { timer } = arm();
+    try {
+      expect(timer.hasRef()).toBe(false);
+    } finally {
+      clearTimeout(timer);
+    }
+  });
+
+  it("stays silent before the bound", () => {
+    vi.useFakeTimers();
+    const { exit, log } = arm();
+
+    vi.advanceTimersByTime(EXIT_BACKSTOP_MS - 1);
+
+    expect(exit).not.toHaveBeenCalled();
+    expect(log).not.toHaveBeenCalled();
+  });
+
+  it("at the bound, names what is still alive and exits 0, once", () => {
+    vi.useFakeTimers();
+    const { exit, log } = arm();
+
+    vi.advanceTimersByTime(EXIT_BACKSTOP_MS);
+    vi.advanceTimersByTime(EXIT_BACKSTOP_MS);
+
+    expect(log).toHaveBeenCalledTimes(1);
+    expect(log.mock.calls[0]?.[0]).toBe(
+      `[runner] Process still alive ${EXIT_BACKSTOP_MS}ms after shutdown; forcing exit. ` +
+        "Active resources: TCPSocketWrap×2, Timeout×1",
+    );
+    expect(exit).toHaveBeenCalledTimes(1);
+    expect(exit).toHaveBeenCalledWith(0);
+  });
+
+  it("honours an explicit bound", () => {
+    vi.useFakeTimers();
+    const { exit } = arm({ boundMs: 250 });
+
+    vi.advanceTimersByTime(249);
+    expect(exit).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(1);
+    expect(exit).toHaveBeenCalledWith(0);
+  });
+
+  it("keeps the bound above the conformance harness's 2 s slow-exit line", () => {
+    // Below it, the harness would stop reporting the very leaks this cuts.
+    expect(EXIT_BACKSTOP_MS).toBeGreaterThan(2_000);
+  });
+});
+
+describe("describeResources", () => {
+  it("groups and sorts, so the same leak reads the same on every exit", () => {
+    expect(describeResources(["Timeout", "TCPSocketWrap", "PipeWrap", "TCPSocketWrap"])).toBe(
+      "PipeWrap×1, TCPSocketWrap×2, Timeout×1",
+    );
+  });
+
+  it("says so when Node reports nothing", () => {
+    expect(describeResources([])).toBe("none reported");
+  });
+});

package/src/__tests__/golden-e2e.test.ts

@@ -7,14 +7,21 @@
  * - Expression evaluation via local activities (jq-wasm)
  * - Timer handling (sleep/wait)
  *
- * Prerequisites:
- * - @temporalio/testing ephemeral server binary (installed via npm)
- * - Temporal CLI (`temporal`) on PATH
+ * Prerequisites: none beyond `npm install`. `TestWorkflowEnvironment.createTimeSkipping()`
+ * downloads and runs Temporal's own test server, which skips a timer as soon as
+ * the workflow waits on it, so the goldens that wait minutes (#16 wait-delay,
+ * #21 retry-backoff) finish inside the per-test budget.
  *
  * The workflow-engine uses `deepClone` from `clone.ts` which falls
  * back to JSON round-trip when `structuredClone` is unavailable in
- * the Temporal deterministic V8 sandbox. Tests are skipped if the
- * environment can't start a Temporal test server.
+ * the Temporal deterministic V8 sandbox.
+ *
+ * Only one failure skips: the Temporal test server cannot boot (no network
+ * for the download, say). Each golden then skips by name with the boot
+ * error. Anything after the boot (the worker, the workflow bundle, a
+ * golden itself) fails. The suite once swallowed every error and returned
+ * early from each test, which vitest counts as a pass, so it reported
+ * sixteen passes without running a golden (stigmer#1300).
  *
  * Run with: npx vitest run src/__tests__/golden-e2e.test.ts
  */
@@ -24,8 +31,9 @@ import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadWorkflowFromYaml } from "../workflow-engine/loader.js";
+import { IN_TEST_GATE } from "../__test-utils__/test-gate.js";
 import { evaluateExpressionBatch } from "../workflow-engine/expression.js";
-import type { ExecuteServerlessWorkflowInput } from "../workflows/engine-core.js";
+import type { EngineActivities, ExecuteServerlessWorkflowInput } from "../workflows/engine-core.js";
 import type { WorkflowModel } from "../workflow-engine/types.js";
 import { INLINE_MODEL_WORKFLOW_TYPE } from "../__test-utils__/workflows/inline-model.js";
 
@@ -48,7 +56,8 @@ type Worker = import("@temporalio/worker").Worker;
 let env: TestWorkflowEnvironment | null = null;
 let worker: Worker | null = null;
 let workerRunPromise: Promise<void> | null = null;
-let envReady = false;
+/** Why the Temporal test server could not boot; `null` once it has. */
+let bootError: string | null = "not attempted";
 
 function createMockActivities() {
   return {
@@ -81,7 +90,12 @@ function createMockActivities() {
     ClearWorkflowApprovalStatus: async (): Promise<void> => {},
     UpdateWorkflowFileReviewStatus: async (): Promise<void> => {},
     GetAwaitingFileReviewChangeSetIds: async (): Promise<string[]> => [],
-  };
+    GetAgentExecutionProgress: async (): Promise<null> => null,
+    ResetEventSequence: async (): Promise<number> => 0,
+    EmitWorkflowEvents: async (): Promise<void> => {},
+    LoadRecoveryContext: async (): Promise<unknown[]> => [],
+    PromoteTaskOutput: async (): Promise<void> => {},
+  } satisfies Record<keyof EngineActivities, unknown>;
 }
 
 async function runGoldenWorkflow(model: WorkflowModel, workflowInput: unknown = null): Promise<unknown> {
@@ -96,34 +110,36 @@ async function runGoldenWorkflow(model: WorkflowModel, workflowInput: unknown =
     taskQueue: TASK_QUEUE,
     workflowId: `golden-e2e-${Date.now()}-${Math.random().toString(36).slice(2)}`,
     args: [input],
-    workflowExecutionTimeout: "30s",
+    // Workflow time, which the test server skips through: #16 alone waits 96s of
+    // timers. Real time stays bounded by vitest's per-test timeout.
+    workflowExecutionTimeout: "10m",
   });
 }
 
 describe("Golden E2E — Temporal TestWorkflowEnvironment", () => {
   beforeAll(async () => {
+    const { TestWorkflowEnvironment: TWE } = await import("@temporalio/testing");
+    const { Worker: W } = await import("@temporalio/worker");
+
     try {
-      const { TestWorkflowEnvironment: TWE } = await import("@temporalio/testing");
-      const { Worker: W } = await import("@temporalio/worker");
-
-      env = await TWE.createLocal();
-      worker = await W.create({
-        connection: env.nativeConnection,
-        taskQueue: TASK_QUEUE,
-        workflowsPath: WORKFLOWS_PATH,
-        activities: createMockActivities(),
-      });
-      workerRunPromise = worker.run();
-
-      // Smoke test: execute simplest workflow to verify sandbox compatibility
-      const smokeModel = loadWorkflowFromYaml(loadGolden("01-operation-basic.yaml"));
-      await runGoldenWorkflow(smokeModel);
-      envReady = true;
+      env = await TWE.createTimeSkipping();
     } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.warn(`Temporal E2E smoke test failed (tests will be skipped): ${msg}`);
-      envReady = false;
+      // Inside a gate the test server is a provided dependency: not booting is a failure.
+      if (IN_TEST_GATE) throw err;
+      bootError = err instanceof Error ? err.message : String(err);
+      console.warn(`Temporal test server cannot boot; every golden skips: ${bootError}`);
+      return;
     }
+    bootError = null;
+
+    // Past the boot, a failure is the suite's to report, not to skip.
+    worker = await W.create({
+      connection: env.nativeConnection,
+      taskQueue: TASK_QUEUE,
+      workflowsPath: WORKFLOWS_PATH,
+      activities: createMockActivities(),
+    });
+    workerRunPromise = worker.run();
   }, 60_000);
 
   afterAll(async () => {
@@ -135,117 +151,119 @@ describe("Golden E2E — Temporal TestWorkflowEnvironment", () => {
   }, 30_000);
 
   // ─────────────────────────────────────────────────────────────────
-  // Each test skips gracefully if the Temporal test server
-  // cannot start or the smoke test fails.
+  // Each golden skips by name when the test server could not boot.
   // ─────────────────────────────────────────────────────────────────
 
-  it("#01 operation-basic — sequential set tasks", async () => {
-    if (!envReady) return;
+  it("#01 operation-basic — sequential set tasks", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("01-operation-basic.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toEqual({ workflow_completed: true });
   });
 
-  it("#14 try-catch-raise — error handling pipeline", async () => {
-    if (!envReady) return;
+  it("#14 try-catch-raise — error handling pipeline", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("14-try-catch-raise.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toEqual({ phase: "completed" });
   });
 
-  it("#15 fork-parallel — non-compete branches", async () => {
-    if (!envReady) return;
+  it("#15 fork-parallel — non-compete branches", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("15-fork-parallel.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toBeDefined();
   });
 
-  it("#02 switch-conditional — HTTP + conditional branching", async () => {
-    if (!envReady) return;
+  it("#02 switch-conditional — HTTP + conditional branching", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("02-switch-conditional.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toBeDefined();
   });
 
-  it("#03 foreach-loop — iteration with HTTP calls", async () => {
-    if (!envReady) return;
+  it("#03 foreach-loop — iteration with HTTP calls", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("03-foreach-loop.yaml"));
     const result = await runGoldenWorkflow(model, { items: ["a", "b", "c"] });
     expect(result).toBeDefined();
   });
 
-  it("#04 parallel-concurrent — fork with HTTP branches", async () => {
-    if (!envReady) return;
+  it("#04 parallel-concurrent — fork with HTTP branches", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("04-parallel-concurrent.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toBeDefined();
   });
 
-  it("#06 sleep-delay — wait + HTTP calls", async () => {
-    if (!envReady) return;
+  it("#06 sleep-delay — wait + HTTP calls", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("06-sleep-delay.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toBeDefined();
   });
 
-  it("#07 inject-transform — expressions + HTTP", async () => {
-    if (!envReady) return;
+  it("#07 inject-transform — expressions + HTTP", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("07-inject-transform.yaml"));
     const result = await runGoldenWorkflow(model, { a: 10, b: 20 });
     expect(result).toBeDefined();
   });
 
-  it("#08 error-retry — try/catch with HTTP", async () => {
-    if (!envReady) return;
+  it("#08 error-retry — try/catch with HTTP", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("08-error-retry.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toBeDefined();
   });
 
-  it("#11 claimcheck-large-payload — sequential HTTP calls", async () => {
-    if (!envReady) return;
+  it("#11 claimcheck-large-payload — sequential HTTP calls", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("11-claimcheck-large-payload.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toBeDefined();
   });
 
-  it("#12 claimcheck-between-steps — HTTP chain", async () => {
-    if (!envReady) return;
+  it("#12 claimcheck-between-steps — HTTP chain", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("12-claimcheck-between-steps.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toBeDefined();
   });
 
-  it("#16 wait-delay — timer durations", async () => {
-    if (!envReady) return;
+  it("#16 wait-delay — timer durations", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("16-wait-delay.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toEqual({ completed: true });
   });
 
-  it("#18 run-task — script + shell + workflow", async () => {
-    if (!envReady) return;
+  // quarantined: stigmer#1322 — `run.workflow` starts its child by the workflow's
+  // name, which no worker registers; the kind is refused at save until that issue
+  // lands, and this golden is its end-to-end reproduction.
+  it.skip("#18 run-task — script + shell + workflow", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("18-run-task.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toEqual({ all_runs_done: true });
   });
 
-  it("#19 emit-event — CloudEvents envelope", async () => {
-    if (!envReady) return;
+  it("#19 emit-event — CloudEvents envelope", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("19-emit-event.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toEqual({ events_emitted: true });
   });
 
-  it("#21 retry-backoff — catch-level retry", async () => {
-    if (!envReady) return;
+  it("#21 retry-backoff — catch-level retry", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("21-retry-backoff.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toEqual({ phase: "completed" });
   });
 
-  it("#23 notification — webhook notification", async () => {
-    if (!envReady) return;
+  it("#23 notification — webhook notification", async (testCtx) => {
+    if (bootError !== null) return testCtx.skip(`Temporal test server cannot boot: ${bootError}`);
     const model = loadWorkflowFromYaml(loadGolden("23-notification.yaml"));
     const result = await runGoldenWorkflow(model);
     expect(result).toEqual({ notifications_sent: true });