taskflow-core 0.2.6 → 0.2.8

package/dist/runtime.js

@@ -2360,6 +2360,7 @@ async function executePhaseInner(phase, state, deps, prior, emitProgress, _retry
     // approval — HITL pause (decision → PhaseState in runtime/phases/approval.ts)
     if (type === "approval") {
         const { approvalDecisionToPhaseState } = await import("./runtime/phases/approval.js");
+        const { resolveApprovalDecision } = await import("./runtime/phases/approval-wait.js");
         const readRefs = [];
         const ctx = buildInterpolationContext(state, previousOutput, undefined, (ref) => readRefs.push(ref));
         const message = interpolate(phase.task ?? "Approve to continue?", ctx).text;
@@ -2369,20 +2370,31 @@ async function executePhaseInner(phase, state, deps, prior, emitProgress, _retry
         if (cached)
             return cached;
         const reads = readRefsToReads(readRefs, state);
-        // Non-interactive (headless/CI/detached): auto-REJECT — safety boundary, never bypass.
-        if (!deps.requestApproval) {
-            return approvalDecisionToPhaseState(phase.id, { decision: "reject" }, {
+        const resolved = await resolveApprovalDecision({
+            phase,
+            message,
+            upstream: previousOutput,
+            requestApproval: deps.requestApproval,
+            signal: deps.signal,
+        });
+        if (resolved.kind === "fail") {
+            return {
+                id: phase.id,
+                status: "failed",
+                error: resolved.error,
+                output: resolved.error,
+                approval: { decision: "reject", auto: true, note: "approval-expired" },
+                usage: emptyUsage(),
                 inputHash,
                 reads,
-                auto: true,
-            });
+                endedAt: Date.now(),
+            };
         }
-        const decision = await deps.requestApproval({
-            phaseId: phase.id,
-            message,
-            upstream: previousOutput,
+        return approvalDecisionToPhaseState(phase.id, resolved.decision, {
+            inputHash,
+            reads,
+            auto: resolved.auto,
         });
-        return approvalDecisionToPhaseState(phase.id, decision, { inputHash, reads });
     }
     if (type === "flow" || type === "expand") {
         const readRefs = [];
@@ -3814,7 +3826,7 @@ export async function executeTaskflow(state, deps) {
             if (!deps.runTask) {
                 throw new Error("event kernel requires RuntimeDeps.runTask");
             }
-            return await runEventKernel(state, {
+            const kernelResult = await runEventKernel(state, {
                 cwd: deps.cwd,
                 agents: deps.agents,
                 runTask: deps.runTask,
@@ -3831,6 +3843,8 @@ export async function executeTaskflow(state, deps) {
                 _stack: deps._stack,
                 _dynamic: deps._dynamic,
             });
+            await maybeDispatchTerminalHooks(kernelResult.state, deps.cwd, def);
+            return kernelResult;
         }
         return await runTaskflowLayers(state, deps);
     }
@@ -4112,7 +4126,9 @@ async function runTaskflowLayers(state, deps) {
     // window where a successful detached run permanently lost its final output.
     state.finalOutput = finalOutput;
     state.outputSourcePhaseId = outputSourcePhaseId;
+    state.updatedAt = Date.now();
     safeEmit(deps, state);
+    await maybeDispatchTerminalHooks(state, deps.cwd, def);
     const totalUsage = aggregateUsage(Object.values(state.phases).map((p) => p.usage ?? emptyUsage()));
     return {
         state,
@@ -4123,4 +4139,17 @@ async function runTaskflowLayers(state, deps) {
         outputSourcePhaseId,
     };
 }
+/** Fire-and-forget terminal hooks; never throws into the runtime outcome. */
+async function maybeDispatchTerminalHooks(state, cwd, def) {
+    try {
+        const hooks = def.hooks;
+        if (!hooks)
+            return;
+        const { dispatchHooks } = await import("./hooks.js");
+        await dispatchHooks(state, { cwd, hooks });
+    }
+    catch {
+        /* hooks must never replace the runtime outcome */
+    }
+}
 //# sourceMappingURL=runtime.js.map