taskflow-core 0.2.9 → 0.2.10

package/dist/runtime.js

@@ -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,
             });