taskflow-core 0.2.8 → 0.2.10

package/dist/runtime.js

@@ -13,7 +13,7 @@ import * as path from "node:path";
 import * as fs from "node:fs";
 import { coerceArray, evaluateCondition, interpolate, interpolateValue, safeParse, tryEvaluateCondition } from "./interpolate.js";
 import { contractViolations } from "./contract.js";
-import { isFailed, isTransientError, mapWithConcurrencyLimit, PHASE_TIMEOUT_ABORT_GRACE_MS, sanitizeErrorMessage } from "./runner-core.js";
+import { failedResultDisplayOutput, hasMeaningfulFailedOutput, isFailed, isTransientError, mapWithConcurrencyLimit, PHASE_TIMEOUT_ABORT_GRACE_MS, sanitizeErrorMessage } from "./runner-core.js";
 /** Default runner used when no host injected one: fail loudly rather than
  *  silently spawn anything (core is host-neutral and cannot spawn pi/codex). */
 const noRunnerInjected = async (_cwd, _agents, agentName, task) => ({
@@ -105,16 +105,14 @@ function buildInterpolationContext(state, previousOutput, locals, onRead, reflex
 function resultToPhaseState(id, r, inputHash, parseJson) {
     const failed = isFailed(r);
     const attempts = attemptsOf(r);
-    // For failed phases, embed the error info in the output so downstream
-    // phases (and the user) can see what went wrong. The raw r.output is
-    // often a useless placeholder like "(upstream error: subagent failed)".
     const output = failed
-        ? r.errorMessage || r.stderr || r.output
+        ? failedResultDisplayOutput(r)
         : r.output;
     return {
         id,
         status: failed ? "failed" : "done",
         output,
+        partialOutput: failed && hasMeaningfulFailedOutput(r) ? true : undefined,
         json: parseJson && !failed ? safeParse(r.output) : undefined,
         usage: r.usage,
         model: r.model,
@@ -304,7 +302,8 @@ function mergePhaseState(id, results, inputHash, parseJson) {
     // which model produced the merged output.
     const model = ran.find((r) => r.model !== undefined)?.model;
     // Combine outputs as a labelled list; also expose a JSON array of outputs.
-    // For failed items, use the error message instead of the useless placeholder.
+    // For failed items, preserve a real partial body; replace only the shared
+    // transport placeholder with the concise diagnostic.
     // Labels are positionally aligned to the ORIGINAL `over` array: we iterate
     // over ALL results (including budget-skipped, which are filtered to null) and
     // use `results.length` as N, so item k's label reads `[k/N]` matching its
@@ -316,7 +315,7 @@ function mergePhaseState(id, results, inputHash, parseJson) {
         if (r.stopReason === "budget-skipped")
             return null;
         const label = `### [${i + 1}/${results.length}] ${r.agent}${isFailed(r) ? " (failed)" : ""}`;
-        const content = isFailed(r) ? (r.errorMessage || r.stderr || r.output) : r.output;
+        const content = isFailed(r) ? failedResultDisplayOutput(r) : r.output;
         return `${label}\n\n${content}`;
     })
         .filter((x) => x !== null)
@@ -332,6 +331,7 @@ function mergePhaseState(id, results, inputHash, parseJson) {
         id,
         status: anyFailed ? "failed" : "done",
         output: combinedText,
+        partialOutput: ran.some((r) => isFailed(r) && hasMeaningfulFailedOutput(r)) ? true : undefined,
         json: jsonArray,
         usage,
         model,
@@ -600,18 +600,21 @@ function flowTreeUsesCwdBridge(def, loadFlow, seenUses = new Set()) {
  * after the root binding and cache policy were decided.
  */
 function snapshotFlowLoader(deps) {
-    if (!deps.loadFlow || deps._flowLoaderSnapshot)
+    if ((!deps.loadSavedFlow && !deps.loadFlow) || deps._flowLoaderSnapshot)
         return deps;
-    const source = deps.loadFlow;
+    const source = deps.loadSavedFlow
+        ?? ((name) => {
+            const def = deps.loadFlow?.(name);
+            return def === undefined ? undefined : { def };
+        });
     const snapshot = new Map();
-    const loadFlow = (name) => {
+    const loadSavedFlow = (name) => {
         let entry = snapshot.get(name);
         if (!entry) {
             try {
                 const loaded = source(name);
-                // Loader-owned objects may be mutated asynchronously. Capability scan
-                // and execution operate on a detached structured snapshot, never the
-                // loader's live reference.
+                // Definition and provenance are detached and cached as one value, so
+                // mutable discovery cannot pair data from one flow with another path.
                 entry = { ok: true, value: loaded === undefined ? undefined : structuredClone(loaded) };
             }
             catch (error) {
@@ -623,7 +626,8 @@ function snapshotFlowLoader(deps) {
             throw entry.error;
         return entry.value;
     };
-    return { ...deps, loadFlow, _flowLoaderSnapshot: snapshot };
+    const loadFlow = (name) => loadSavedFlow(name)?.def;
+    return { ...deps, loadFlow, loadSavedFlow, _flowLoaderSnapshot: snapshot };
 }
 function sameDirectoryIdentity(a, b) {
     return !!a && !!b && a.canonicalPath === b.canonicalPath && a.device === b.device && a.inode === b.inode;
@@ -2154,7 +2158,7 @@ async function executePhaseInner(phase, state, deps, prior, emitProgress, _retry
     }
     // script — zero-token shell (spawn/timeout/size caps in runtime/phases/script.ts)
     if (type === "script") {
-        const { runScriptCommand, scriptResultToPhaseState, scriptSpawnErrorToPhaseState } = await import("./runtime/phases/script.js");
+        const { resolveScriptCwd, runScriptCommand, scriptResultToPhaseState, scriptSpawnErrorToPhaseState } = await import("./runtime/phases/script.js");
         const cmd = phase.run;
         if (!cmd) {
             return {
@@ -2179,18 +2183,44 @@ async function executePhaseInner(phase, state, deps, prior, emitProgress, _retry
         if (stdinInterp?.missing.length)
             warnUnresolvedRefs(phase.id, stdinInterp.missing);
         const stdinInput = stdinInterp?.text;
-        const ck = cacheKeys(cc, [phase.id, JSON.stringify(interpRunText), stdinInput ?? ""]);
+        const reads = readRefs.length ? readRefsToReads(readRefs, state) : undefined;
+        let scriptCwd;
+        const hasExplicitScriptCwd = deps._cwdOverride !== undefined || phase.cwd !== undefined;
+        try {
+            scriptCwd = resolveScriptCwd({
+                executionCwd: effCwd,
+                hasExplicitCwd: hasExplicitScriptCwd,
+                scriptCwd: state.def.scriptCwd,
+                flowSourceFile: state.flowSourceFile,
+                flowSourceDirIdentity: state.flowSourceDirIdentity,
+            });
+        }
+        catch (err) {
+            return scriptSpawnErrorToPhaseState(phase.id, err, {
+                inputHash: hashInput(phase.id, JSON.stringify(interpRunText), stdinInput ?? "", "script-cwd-unresolved"),
+                reads,
+            });
+        }
+        if (deps._cwdBoundary && !isPathWithin(deps._cwdBoundary, scriptCwd)) {
+            return scriptSpawnErrorToPhaseState(phase.id, new Error("TF_CWD_BOUNDARY_ESCAPE: script cwd must remain inside the inherited cwd boundary"), {
+                inputHash: hashInput(phase.id, JSON.stringify(interpRunText), stdinInput ?? "", "script-cwd-boundary-escape"),
+                reads,
+            });
+        }
+        const ck = cacheKeys(cc, [phase.id, JSON.stringify(interpRunText), stdinInput ?? "", `cwd:${scriptCwd}`]);
         const inputHash = ck.key;
         const cached = cachedPhase(cc, ck);
         if (cached)
             return cached;
         const SCRIPT_TIMEOUT_MS = phase.timeout ?? 60_000;
-        const reads = readRefs.length ? readRefsToReads(readRefs, state) : undefined;
         try {
             const invoke = () => runScriptCommand({
                 interpRunText,
                 arrayForm: Array.isArray(cmd),
-                cwd: effCwd,
+                cwd: scriptCwd,
+                cwdIdentity: !hasExplicitScriptCwd && state.def.scriptCwd === "flow"
+                    ? state.flowSourceDirIdentity
+                    : undefined,
                 signal: deps.signal,
                 stdinInput,
                 timeoutMs: SCRIPT_TIMEOUT_MS,
@@ -2420,6 +2450,8 @@ async function executePhaseInner(phase, state, deps, prior, emitProgress, _retry
             }
         }
         let subDef;
+        let subFlowSourceFile;
+        let subFlowSourceDirIdentity;
         let name;
         let recursionKey; // identity used for cache key + recursion guard
         if (type === "expand" && !hasDef) {
@@ -2526,11 +2558,14 @@ async function executePhaseInner(phase, state, deps, prior, emitProgress, _retry
             const useName = phase.use;
             if (!useName)
                 return failPhase(phase.id, `flow phase '${phase.id}' requires 'use' or 'def'`);
-            if (!deps.loadFlow)
+            if (!deps.loadSavedFlow)
                 return failPhase(phase.id, `flow phase '${phase.id}': no sub-flow loader available`);
-            subDef = deps.loadFlow(useName);
-            if (!subDef)
+            const loaded = deps.loadSavedFlow(useName);
+            if (!loaded)
                 return failPhase(phase.id, `flow phase '${phase.id}': saved flow not found: '${useName}'`);
+            subDef = loaded.def;
+            subFlowSourceFile = loaded.filePath;
+            subFlowSourceDirIdentity = loaded.sourceDirIdentity;
             name = useName;
             recursionKey = useName;
         }
@@ -2575,7 +2610,7 @@ async function executePhaseInner(phase, state, deps, prior, emitProgress, _retry
         // Every sub-flow cache identity includes the resolved definition. A saved
         // flow's name alone is insufficient: its contents can change without the
         // parent definition moving.
-        const flowIdentity = `${hasDef ? "def" : "flow"}:${name}:${JSON.stringify(subDef)}`;
+        const flowIdentity = `${hasDef ? "def" : "flow"}:${name}:${JSON.stringify(subDef)}:source:${subFlowSourceFile ?? ""}:source-dir:${JSON.stringify(subFlowSourceDirIdentity ?? null)}`;
         const ck = cacheKeys(flowCc, [phase.id, flowIdentity, preRead, JSON.stringify(subArgs)]);
         const inputHash = ck.key;
         const cached = cachedPhase(flowCc, ck);
@@ -2606,6 +2641,8 @@ async function executePhaseInner(phase, state, deps, prior, emitProgress, _retry
             createdAt: Date.now(),
             updatedAt: Date.now(),
             cwd: effCwd,
+            flowSourceFile: subFlowSourceFile,
+            flowSourceDirIdentity: subFlowSourceDirIdentity,
         };
         // B8: pass this flow phase's preRead content to every sub-flow phase by
         // wrapping runTask — sub-phase preRead still gets prepended on top of it.
@@ -3840,6 +3877,7 @@ export async function executeTaskflow(state, deps) {
                 verifiers: deps.verifiers,
                 requestApproval: deps.requestApproval,
                 loadFlow: deps.loadFlow,
+                loadSavedFlow: deps.loadSavedFlow,
                 _stack: deps._stack,
                 _dynamic: deps._dynamic,
             });