@stigmer/runner 3.29.0 → 3.31.0

package/src/shared/__tests__/runner-credential-store.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { loadTemporalConnectionConfig } from "@stigmer/temporal-codecs";
 import {
   captureRunnerSecrets,
   getRunnerSecret,
@@ -87,6 +88,25 @@ describe("captureRunnerSecrets", () => {
       expect(RUNNER_SECRET_ENV_KEYS, `'${key}' must be in the scrub list`).toContain(key);
     }
   });
+
+  it("takes the Temporal API key and client key into custody, and the connection settings still read them", () => {
+    // Pinned by name, like the encryption keys: a runner that left either
+    // in process.env would hand every agent shell a credential to Temporal.
+    // Temporal's own TEMPORAL_API_KEY is the user's and stays untouched.
+    for (const key of ["STIGMER_TEMPORAL_API_KEY", "STIGMER_TEMPORAL_TLS_CLIENT_KEY_DATA"]) {
+      expect(RUNNER_CREDENTIAL_ENV_KEYS, `'${key}' must be a captured credential`).toContain(key);
+    }
+    expect(RUNNER_SECRET_ENV_KEYS).not.toContain("TEMPORAL_API_KEY");
+
+    process.env.STIGMER_TEMPORAL_API_KEY = "temporal-key";
+    captureRunnerSecrets();
+
+    expect(process.env.STIGMER_TEMPORAL_API_KEY).toBeUndefined();
+    expect(loadTemporalConnectionConfig(getRunnerSecret)).toEqual({
+      tls: {},
+      apiKey: "temporal-key",
+    });
+  });
 });
 
 describe("getRunnerSecret", () => {

package/src/shared/approval-policy.ts

@@ -18,6 +18,7 @@
 import type { ToolApprovalPolicy } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/spec_pb";
 import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { ApprovalAction, ApprovalMode, ApprovalPolicySource } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { SENSITIVE_ARG_KEYS } from "./args-preview.js";
 import { toolApprovalCategory, type ToolApprovalCategory } from "./tool-kind.js";
 import type { ResolvedMcpServer } from "./mcp-resolver.js";
 
@@ -451,6 +452,11 @@ export function lookupMcpToolPolicy(
  * - {{args.field_name}} — replaced with the argument value
  * - {{tool_name}} — replaced with the tool name
  * - Missing fields are replaced with "<unknown>"
+ * - A secret-keyed field ({@link SENSITIVE_ARG_KEYS}) is replaced with
+ *   "[REDACTED]" (stigmer#1119): the message is stored on the row and shown on
+ *   the approval card, which must carry no more than the redacted preview.
+ *   Every approval message in the runner, native and Cursor alike, resolves
+ *   here, so this is the one place the rule applies to it.
  */
 export function resolveApprovalMessage(
   template: string,
@@ -460,6 +466,7 @@ export function resolveApprovalMessage(
   return template
     .replace(/\{\{tool_name\}\}/g, toolName)
     .replace(/\{\{args\.(\w+)\}\}/g, (_match, field: string) => {
+      if (SENSITIVE_ARG_KEYS.has(field.toLowerCase())) return "[REDACTED]";
       const value = args[field];
       if (value === undefined || value === null) return "<unknown>";
       if (typeof value === "string") return value;

package/src/shared/args-preview.ts

@@ -34,8 +34,13 @@
  */
 
 /**
- * Argument keys whose values are secrets and must never appear in a preview.
- * Matched case-insensitively against the top-level key name.
+ * Argument keys whose values are secrets and must never appear in a preview,
+ * on a row's `args`, or in an approval message (stigmer#1119). Matched
+ * case-insensitively against the top-level key name. Clients mirror this set
+ * to hide the values on rows persisted before the runner redacted `args`
+ * (`@stigmer/sdk`'s `isSecretArgKey`); the shared, machine-checked contract is
+ * `test/fixtures/tool-view/secret-args.json` — keep this set and that fixture
+ * in lockstep.
  */
 export const SENSITIVE_ARG_KEYS: ReadonlySet<string> = new Set([
   "password", "token", "secret", "api_key", "apikey",
@@ -60,9 +65,11 @@ export const SALIENT_ARG_FIELDS = ["file_path", "path", "target_notebook", "comm
 /**
  * Redact secret-keyed values (see {@link SENSITIVE_ARG_KEYS}), preserving every
  * other entry verbatim. The first step of the preview builder, and the shape
- * stamped as `args` on a proposed row the harness recovered from its engine's
- * state (issue #754's header fix): full enough for the UI's path/primary-arg
- * extraction, never carrying a secret value.
+ * stamped as `args` on every row: by the transcript builder on every row with
+ * args (since stigmer#1119), and on a proposed row the harness recovered from
+ * its engine's state (issue #754's header fix). Full enough for the UI's
+ * path/primary-arg extraction and for exact-apply, never carrying a secret
+ * value.
  */
 export function redactSensitiveArgs(
   args: Record<string, unknown>,

package/src/shared/runner-credential-keys.ts

@@ -27,6 +27,11 @@
  * ambient aws/gcloud auth), and on a local backend the shell can read the
  * credential files off disk regardless (owner ruling on #385).
  */
+import {
+  TEMPORAL_API_KEY_ENV,
+  TEMPORAL_TLS_CLIENT_KEY_DATA_ENV,
+} from "@stigmer/temporal-codecs";
+
 export const RUNNER_CREDENTIAL_ENV_KEYS: readonly string[] = [
   // Derives HITL approval fingerprints (fingerprint-secret.ts) — an agent
   // that reads this could forge approval receipts.
@@ -49,6 +54,13 @@ export const RUNNER_CREDENTIAL_ENV_KEYS: readonly string[] = [
   // Bedrock backend bearer credential, read by the AWS SDK's chain
   // (llm-backend.ts documents it as a supported auth path).
   "AWS_BEARER_TOKEN_BEDROCK",
+  // The Temporal frontend's API key and the mutual-TLS client key, read by
+  // the Temporal connection settings (@stigmer/temporal-codecs'
+  // connection config). Whoever holds either can reach Temporal as this
+  // runner. Stigmer's own names, never Temporal's TEMPORAL_API_KEY, which
+  // is the user's (that module's header).
+  TEMPORAL_API_KEY_ENV,
+  TEMPORAL_TLS_CLIENT_KEY_DATA_ENV,
 ];
 
 /**

package/src/worker.ts

@@ -3,10 +3,8 @@
  *
  * Registers both activities and workflows on a single queue.
  *
- * Workflows:
- * - "stigmer/mcp-server/connect" — ConnectMcpServerWorkflow (discover + classify)
- * - "stigmer/mcp-server/discover" — Legacy discover-only workflow
- * - "stigmer/workflow/execute" — CNCF Serverless Workflow execution
+ * Workflows: exactly the types in `workflows/index.ts`, each started by
+ * the server with ids (that file's header is the list and the rule).
  *
  * Architecture:
  * - Java backend starts connect workflows on the runner's task queue
@@ -41,6 +39,7 @@ export async function startWorker(opts: StartWorkerOptions): Promise<Worker> {
 
   const connection = await NativeConnection.connect({
     address: config.temporalAddress,
+    ...config.temporalConnection,
   });
 
   const { createWorkflowMetricsSinks } = await import("./interceptors/workflow-metrics-sink.js");

package/src/workflow-engine/__tests__/tasks/run.test.ts

@@ -79,6 +79,31 @@ describe("RunTaskBuilder", () => {
       const builder = new RunTaskBuilder("task", taskDef);
       expect(() => builder.build()).toThrow("workflow.name is required");
     });
+
+    it.each([
+      "stigmer/workflow/execute",
+      "stigmer/workflow/execute-from-execution",
+      "stigmer/mcp-server/connect",
+      "stigmer/mcp-server/discover",
+      "stigmer/agent-execution/invoke",
+    ])("refuses the platform workflow type %s", (name) => {
+      const taskDef: RunTaskDef = {
+        kind: "run",
+        run: { workflow: { name, namespace: "default", version: "1.0.0" } },
+      };
+      const builder = new RunTaskBuilder("reachIn", taskDef);
+      expect(() => builder.build()).toThrow(
+        `Run task 'reachIn': '${name}' is a platform workflow type, and a workflow cannot start one`,
+      );
+    });
+
+    it("admits a name that only mentions the platform outside the prefix", () => {
+      const taskDef: RunTaskDef = {
+        kind: "run",
+        run: { workflow: { name: "my-stigmer/child", namespace: "default", version: "1.0.0" } },
+      };
+      expect(() => new RunTaskBuilder("child", taskDef).build()).not.toThrow();
+    });
   });
 
   describe("script execution", () => {

package/src/workflow-engine/tasks/run.ts

@@ -7,7 +7,9 @@
  * - `run.workflow`: Child Temporal workflow (await or fire-and-forget)
  *
  * The kernel validates configuration and delegates to `ctx.runCommand`
- * (for script/shell) or `ctx.runWorkflow` (for child workflows).
+ * (for script/shell) or `ctx.runWorkflow` (for child workflows). A child
+ * workflow's name may not be a platform workflow type
+ * ({@link PLATFORM_WORKFLOW_TYPE_PREFIX} says why).
  *
  * YAML shapes:
  *   - runScript:
@@ -42,6 +44,19 @@ import type {
 
 const SUPPORTED_LANGUAGES = ["js", "python"];
 
+/**
+ * The namespace of the platform's own Temporal workflow types. A child
+ * started by `run.workflow` runs on the parent's task queue, which is a
+ * runner's queue, so the types a name can reach are exactly the ones a
+ * runner registers (`workflows/index.ts`): work the server never
+ * dispatched, outside the run it belongs to. A workflow therefore cannot
+ * name one. `workflows/__tests__/barrel.test.ts` pins that every registered
+ * type carries this prefix, so the refusal covers each. (Server types need
+ * not carry it, `schedule/tick` does not: they run on the server's own
+ * queues, which a child here never reaches.)
+ */
+export const PLATFORM_WORKFLOW_TYPE_PREFIX = "stigmer/";
+
 export class RunTaskBuilder implements TaskBuilder {
   readonly taskName: string;
   readonly taskDef: TaskDef;
@@ -138,5 +153,10 @@ function validateRunConfig(config: RunConfig, taskName: string): void {
     if (!config.workflow.name) {
       throw new Error(`Run task '${taskName}': workflow.name is required`);
     }
+    if (config.workflow.name.startsWith(PLATFORM_WORKFLOW_TYPE_PREFIX)) {
+      throw new Error(
+        `Run task '${taskName}': '${config.workflow.name}' is a platform workflow type, and a workflow cannot start one`,
+      );
+    }
   }
 }

package/src/workflows/__tests__/barrel.test.ts

@@ -0,0 +1,52 @@
+/**
+ * The fence on what a runner registers. Every export of `workflows/index.ts`
+ * is a Temporal workflow type on every worker root, and anyone who can
+ * reach Temporal can start any of them on a runner's queue. So the set is
+ * pinned exactly: the three types the server starts, each by id, none of
+ * which takes a model to run. A new export fails here until this list, and
+ * the review that comes with changing it, admits it.
+ *
+ * It also pins the link to the `run.workflow` refusal
+ * (`workflow-engine/tasks/run.ts`): every registered type carries
+ * `PLATFORM_WORKFLOW_TYPE_PREFIX`, so a workflow can never name one as its
+ * child. And it pins the test barrel (`src/__test-utils__/workflows/`) to
+ * the production set plus its one inline entry, under the name the tests
+ * start it by, since an export alias cannot import that constant.
+ */
+
+import { describe, expect, it } from "vitest";
+
+import * as barrel from "../index.js";
+import * as testBarrel from "../../__test-utils__/workflows/index.js";
+import { INLINE_MODEL_WORKFLOW_TYPE } from "../../__test-utils__/workflows/inline-model.js";
+import { EXECUTE_FROM_EXECUTION_WORKFLOW_TYPE } from "../execute-from-execution.js";
+import { PLATFORM_WORKFLOW_TYPE_PREFIX } from "../../workflow-engine/tasks/run.js";
+
+describe("the registered workflow types", () => {
+  it("are exactly the types the server starts", () => {
+    expect(Object.keys(barrel).sort()).toEqual(
+      [
+        "stigmer/mcp-server/connect",
+        "stigmer/mcp-server/discover",
+        EXECUTE_FROM_EXECUTION_WORKFLOW_TYPE,
+      ].sort(),
+    );
+  });
+
+  it("include no type that runs a model handed to it", () => {
+    expect(Object.keys(barrel)).not.toContain("stigmer/workflow/execute");
+  });
+
+  it("all carry the platform prefix the run.workflow refusal checks", () => {
+    for (const type of Object.keys(barrel)) {
+      expect(type.startsWith(PLATFORM_WORKFLOW_TYPE_PREFIX), type).toBe(true);
+    }
+  });
+
+  it("are what the test barrel adds its inline entry to, outside the platform prefix", () => {
+    expect(Object.keys(testBarrel).sort()).toEqual(
+      [...Object.keys(barrel), INLINE_MODEL_WORKFLOW_TYPE].sort(),
+    );
+    expect(INLINE_MODEL_WORKFLOW_TYPE.startsWith(PLATFORM_WORKFLOW_TYPE_PREFIX)).toBe(false);
+  });
+});

package/src/workflows/__tests__/{execute-serverless-workflow.test.ts → engine-inline-model.test.ts}

@@ -1,7 +1,19 @@
+/**
+ * The workflow engine (`engine-core.ts`) driven with a materialized model,
+ * through the test harness's inline entry
+ * (`src/__test-utils__/workflows/inline-model.ts`), with the Temporal
+ * workflow API mocked. It pins the engine's behaviour: task output,
+ * workflow-level `input.from` and `output.as`, expression evaluation
+ * through the local activity, error handling, event sequences and flow
+ * directives. Production reaches the same engine only through the
+ * hydration workflow; `barrel.test.ts` pins that no production type takes
+ * a model from its caller.
+ */
+
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { evaluateExpressionBatch } from "../../workflow-engine/expression.js";
 import type { WorkflowModel } from "../../workflow-engine/types.js";
-import type { ExecuteServerlessWorkflowInput } from "../execute-serverless-workflow.js";
+import type { ExecuteServerlessWorkflowInput } from "../engine-core.js";
 
 const mockEvaluateExpressions = vi.fn();
 const mockResetEventSequence = vi.fn();
@@ -51,7 +63,7 @@ vi.mock("@temporalio/workflow", () => ({
   isCancellation: vi.fn(() => false),
 }));
 
-describe("executeServerlessWorkflow", () => {
+describe("the engine, on a materialized model", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockEvaluateExpressions.mockImplementation(
@@ -60,8 +72,8 @@ describe("executeServerlessWorkflow", () => {
   });
 
   async function runWorkflow(input: ExecuteServerlessWorkflowInput) {
-    const { executeServerlessWorkflow } = await import("../execute-serverless-workflow.js");
-    return executeServerlessWorkflow(input);
+    const { executeInlineModel } = await import("../../__test-utils__/workflows/inline-model.js");
+    return executeInlineModel(input);
   }
 
   describe("basic workflow execution", () => {

package/src/workflows/call-agent-orchestrator.ts

@@ -10,7 +10,7 @@
  *
  * The workflow engine's CallAgentTaskBuilder (workflow-engine/tasks/
  * call-agent.ts) calls `ctx.callAgent()`, which is wired to
- * `orchestrateAgentCall()` in execute-serverless-workflow.ts.
+ * `orchestrateAgentCall()` in engine-core.ts.
  *
  * SANDBOX RULES: Only @temporalio/workflow imports, type-only imports,
  * and pure logic. No Node.js built-ins.

package/src/workflows/engine-core.ts

@@ -2,10 +2,13 @@
  * Shared workflow engine core — runs CNCF Serverless Workflow DSL
  * tasks inside the Temporal deterministic sandbox.
  *
- * Extracted from execute-serverless-workflow.ts so that both the
- * direct workflow ("stigmer/workflow/execute") and the hydration
- * wrapper ("stigmer/workflow/execute-from-execution") can share the
- * engine without code duplication.
+ * The engine runs a fully materialized {@link ExecuteServerlessWorkflowInput}
+ * and owns that type. Production reaches it only through the hydration
+ * workflow ("stigmer/workflow/execute-from-execution"), which reads the
+ * model, env and input back from the server by id; no registered workflow
+ * accepts a materialized model from its caller (see `index.ts`). The test
+ * harness runs goldens through an inline entry of its own
+ * (`src/__test-utils__/workflows/`).
  *
  * SANDBOX RULES: This file runs inside the Temporal deterministic V8
  * isolate. No Node.js built-ins (crypto, fs, net), no non-deterministic
@@ -46,10 +49,9 @@ import type {
   HumanInputExecutionConfig,
   TaskExecutionContext,
   WorkflowEventDescriptor,
+  WorkflowModel,
 } from "../workflow-engine/types.js";
 
-import type { ExecuteServerlessWorkflowInput } from "./execute-serverless-workflow.js";
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Activity Proxies (module-level singletons — shared across all workflow
 // invocations within the same worker)
@@ -132,6 +134,30 @@ const promoteProxy = proxyLocalActivities<PromoteActivities>({
   },
 });
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Engine Input
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * What the engine runs: a parsed model, the merged env and the workflow
+ * input. Built by the hydration activity from what the server holds
+ * (`activities/hydrate-workflow-execution.ts`), never taken from a caller.
+ */
+export interface ExecuteServerlessWorkflowInput {
+  model: WorkflowModel;
+  workflow_input: unknown;
+  env: Record<string, unknown>;
+  metadata?: ExecutionMetadata;
+}
+
+export interface ExecutionMetadata {
+  execution_id?: string;
+  workflow_id?: string;
+  workflow_instance_id?: string;
+  org_id?: string;
+  execution_target?: number;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Engine Core
 // ─────────────────────────────────────────────────────────────────────────────
@@ -149,9 +175,8 @@ export interface RunWorkflowEngineOptions {
  * executes all tasks via {@link executeDoTasks}, and returns the final
  * output.
  *
- * Called by both:
- * - `executeServerlessWorkflow` (direct invocation with pre-materialized input)
- * - `executeFromExecution` (wrapper that hydrates from slim IDs first)
+ * Called by `executeFromExecution` once it has hydrated the input from
+ * slim ids, and by the test harness's inline entry.
  *
  * @param options.checkPause Optional pause yield point callback. When
  *   provided, the engine calls this between tasks and allows the

package/src/workflows/index.ts

@@ -1,13 +1,29 @@
 /**
- * Workflow barrel file — the entry point for Temporal's workflow bundler.
+ * Workflow barrel file — the entry point for Temporal's workflow bundler,
+ * and the complete list of workflow types a runner registers.
  *
  * Re-exports workflow functions with the exact Temporal workflow type
- * names that the Java/Go backend uses to start them. The Temporal TS
- * SDK derives the workflow type from the export name of the module
- * passed to `workflowsPath`.
+ * names that the server uses to start them. The Temporal TS SDK derives
+ * the workflow type from the export name of the module passed to
+ * `workflowsPath`, so every export here is a registered type on every
+ * worker root: the static worker, the manager and pool workers, and the
+ * pre-built bundle (`scripts/bundle-slim.mjs`).
  *
- * The Java backend starts workflows via:
- *   workflowClient.newUntypedWorkflowStub("stigmer/mcp-server/connect", ...)
+ * THE RULE: every export is a type the server starts, and each takes ids
+ * that the runner reads back from the server, never a model to run.
+ * Anyone who can reach Temporal can start any type registered here on a
+ * runner's queue, so a new export is a new door and is reviewed as a
+ * wire change. `__tests__/barrel.test.ts` pins the exact set. Tests that
+ * hand the engine a model directly use the test barrel
+ * (`src/__test-utils__/workflows/index.ts`).
+ *
+ * The types and their starters:
+ *   - "stigmer/mcp-server/connect" and "stigmer/mcp-server/discover": the
+ *     server's MCP connect lane (`temporal/mcpserver/names.ts` in the
+ *     server), by MCP server id.
+ *   - "stigmer/workflow/execute-from-execution": the server's workflow
+ *     execution orchestrator (`temporal/workflowexecution/names.ts`), by
+ *     execution id; it hydrates the model from the server.
  *
  * ES2022 arbitrary module export names (`export { fn as "..." }`) let
  * us map TypeScript function names to the slash-delimited Temporal
@@ -26,10 +42,6 @@ export {
   discoverMcpServerLegacy as "stigmer/mcp-server/discover",
 } from "./connect-mcp-server.js";
 
-export {
-  executeServerlessWorkflow as "stigmer/workflow/execute",
-} from "./execute-serverless-workflow.js";
-
 export {
   executeFromExecution as "stigmer/workflow/execute-from-execution",
 } from "./execute-from-execution.js";

package/src/workflows/workflow-signals.ts

@@ -1,8 +1,8 @@
 /**
  * Shared pause/resume signal definitions and handler setup for
- * workflow execution. Used by both the hydration wrapper
- * ("stigmer/workflow/execute-from-execution") and the direct
- * invocation path ("stigmer/workflow/execute").
+ * workflow execution. Used by the hydration wrapper
+ * ("stigmer/workflow/execute-from-execution") and by the test harness's
+ * inline entry (`src/__test-utils__/workflows/inline-model.ts`).
  *
  * The Java/Go orchestrators forward pause and resume signals to
  * the child workflow. The engine checks a `checkPause` callback

package/dist/workflows/execute-serverless-workflow.d.ts

@@ -1,32 +0,0 @@
-/**
- * Temporal workflow for executing CNCF Serverless Workflow definitions.
- *
- * Workflow type: "stigmer/workflow/execute"
- *
- * Accepts a fully materialized {@link ExecuteServerlessWorkflowInput}
- * (parsed WorkflowModel, merged env, workflow_input) and runs the
- * engine. Callers that already have the materialized input use this
- * workflow directly. The hydration wrapper workflow
- * ("stigmer/workflow/execute-from-execution") handles the case where
- * only slim IDs are available.
- *
- * SANDBOX RULES: This file runs inside the Temporal deterministic V8
- * isolate. No Node.js built-ins (crypto, fs, net), no non-deterministic
- * operations, no side-effecting imports. Only @temporalio/workflow APIs,
- * type-only imports, and pure JS/TS logic.
- */
-import type { WorkflowModel } from "../workflow-engine/types.js";
-export interface ExecuteServerlessWorkflowInput {
-    model: WorkflowModel;
-    workflow_input: unknown;
-    env: Record<string, unknown>;
-    metadata?: ExecutionMetadata;
-}
-export interface ExecutionMetadata {
-    execution_id?: string;
-    workflow_id?: string;
-    workflow_instance_id?: string;
-    org_id?: string;
-    execution_target?: number;
-}
-export declare function executeServerlessWorkflow(input: ExecuteServerlessWorkflowInput): Promise<unknown>;

package/dist/workflows/execute-serverless-workflow.js

@@ -1,36 +0,0 @@
-/**
- * Temporal workflow for executing CNCF Serverless Workflow definitions.
- *
- * Workflow type: "stigmer/workflow/execute"
- *
- * Accepts a fully materialized {@link ExecuteServerlessWorkflowInput}
- * (parsed WorkflowModel, merged env, workflow_input) and runs the
- * engine. Callers that already have the materialized input use this
- * workflow directly. The hydration wrapper workflow
- * ("stigmer/workflow/execute-from-execution") handles the case where
- * only slim IDs are available.
- *
- * SANDBOX RULES: This file runs inside the Temporal deterministic V8
- * isolate. No Node.js built-ins (crypto, fs, net), no non-deterministic
- * operations, no side-effecting imports. Only @temporalio/workflow APIs,
- * type-only imports, and pure JS/TS logic.
- */
-import { isCancellation } from "@temporalio/workflow";
-import { runWorkflowEngine } from "./engine-core.js";
-import { setupPauseResumeHandlers } from "./workflow-signals.js";
-// ─────────────────────────────────────────────────────────────────────────────
-// Workflow Function
-// ─────────────────────────────────────────────────────────────────────────────
-export async function executeServerlessWorkflow(input) {
-    const { checkPause } = setupPauseResumeHandlers();
-    try {
-        return await runWorkflowEngine(input, { checkPause });
-    }
-    catch (err) {
-        if (isCancellation(err)) {
-            // Let CancelledFailure propagate — parent handles cleanup
-        }
-        throw err;
-    }
-}
-//# sourceMappingURL=execute-serverless-workflow.js.map

package/dist/workflows/execute-serverless-workflow.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"execute-serverless-workflow.js","sourceRoot":"","sources":["../../src/workflows/execute-serverless-workflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAqBjE,gFAAgF;AAChF,oBAAoB;AACpB,gFAAgF;AAEhF,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAC7C,KAAqC;IAErC,MAAM,EAAE,UAAU,EAAE,GAAG,wBAAwB,EAAE,CAAC;IAElD,IAAI,CAAC;QACH,OAAO,MAAM,iBAAiB,CAAC,KAAK,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;IACxD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,0DAA0D;QAC5D,CAAC;QACD,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC"}

package/src/workflows/execute-serverless-workflow.ts

@@ -1,60 +0,0 @@
-/**
- * Temporal workflow for executing CNCF Serverless Workflow definitions.
- *
- * Workflow type: "stigmer/workflow/execute"
- *
- * Accepts a fully materialized {@link ExecuteServerlessWorkflowInput}
- * (parsed WorkflowModel, merged env, workflow_input) and runs the
- * engine. Callers that already have the materialized input use this
- * workflow directly. The hydration wrapper workflow
- * ("stigmer/workflow/execute-from-execution") handles the case where
- * only slim IDs are available.
- *
- * SANDBOX RULES: This file runs inside the Temporal deterministic V8
- * isolate. No Node.js built-ins (crypto, fs, net), no non-deterministic
- * operations, no side-effecting imports. Only @temporalio/workflow APIs,
- * type-only imports, and pure JS/TS logic.
- */
-
-import { isCancellation } from "@temporalio/workflow";
-import type { WorkflowModel } from "../workflow-engine/types.js";
-import { runWorkflowEngine } from "./engine-core.js";
-import { setupPauseResumeHandlers } from "./workflow-signals.js";
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Workflow Input/Output Types
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface ExecuteServerlessWorkflowInput {
-  model: WorkflowModel;
-  workflow_input: unknown;
-  env: Record<string, unknown>;
-  metadata?: ExecutionMetadata;
-}
-
-export interface ExecutionMetadata {
-  execution_id?: string;
-  workflow_id?: string;
-  workflow_instance_id?: string;
-  org_id?: string;
-  execution_target?: number;
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Workflow Function
-// ─────────────────────────────────────────────────────────────────────────────
-
-export async function executeServerlessWorkflow(
-  input: ExecuteServerlessWorkflowInput,
-): Promise<unknown> {
-  const { checkPause } = setupPauseResumeHandlers();
-
-  try {
-    return await runWorkflowEngine(input, { checkPause });
-  } catch (err) {
-    if (isCancellation(err)) {
-      // Let CancelledFailure propagate — parent handles cleanup
-    }
-    throw err;
-  }
-}