@stigmer/runner 3.40.1 → 3.41.0

package/src/workflows/human-input-orchestrator.ts

@@ -2,18 +2,15 @@
  * 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.
  */
@@ -22,17 +19,20 @@ import { defineSignal, setHandler, condition } from "@temporalio/workflow";
 
 import type {
   HumanInputExecutionConfig,
+  HumanInputResponse,
   HumanInputResult,
-  HumanInputTimeoutPolicy,
+  HumanInputTimeout,
 } from "../workflow-engine/types.js";
 
+const TIMED_OUT: HumanInputTimeout = { timedOut: true };
+
 /**
  * Orchestrates a human_input task — blocks until signal or timeout.
  */
 export async function orchestrateHumanInput(
   config: HumanInputExecutionConfig,
-): Promise<HumanInputResult> {
-  const { signalName, timeoutSeconds, onTimeout } = config;
+): Promise<HumanInputResponse> {
+  const { signalName, timeoutSeconds } = config;
 
   let payload: HumanInputResult | undefined;
   let received = false;
@@ -44,52 +44,11 @@ export async function orchestrateHumanInput(
   });
 
   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: string,
-  policy: HumanInputTimeoutPolicy,
-): HumanInputResult {
-  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}'`,
-      );
-  }
-}