@agwab/pi-workflow 0.2.1 → 0.3.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { discoverAgents, loadAgentByName, parseAgentMarkdown, } from "./agents.js";
-export { formatLogs, formatRunDetails, formatRunStatus, formatStatus, refreshRun, resumeRun, resumeSupervisors, runDynamicTask, runWorkflow, runWorkflowSpec, waitForRun, } from "./engine.js";
-export type { ResumeRunSummary } from "./engine.js";
+export { formatLogs, formatRunDetails, formatRunStatus, formatStatus, refreshRun, resumeRun, resumeSupervisors, runDynamicTask, stopRun, runWorkflow, runWorkflowSpec, waitForRun, } from "./engine.js";
+export type { ResumeRunSummary, StopRunSummary } from "./engine.js";
 export { listWorkflows, resolveWorkflowRef } from "./workflow-specs.js";
 export type { ResolvedWorkflowSpecRef, WorkflowSpecRecord, } from "./workflow-specs.js";
 export { compileRole, extractMarkdownSections } from "./roles.js";
@@ -11,4 +11,4 @@ export { WorkflowValidationError } from "./types.js";
 export { runDynamicDecisionLoop } from "./dynamic-decision-loop.js";
 export type { DynamicDecisionLoopControllerContext, DynamicDecisionLoopResult, DynamicDecisionLoopRunResult, RunDynamicDecisionLoopOptions, } from "./dynamic-decision-loop.js";
 export declare const WORKFLOW_COMMAND = "workflow";
-export declare const WORKFLOW_HELP = "pi-workflow\n\nUsage:\n  /workflow [run-id]\n  /workflow help\n  /workflow validate <workflow-name-or-path>\n  /workflow roles <workflow-name-or-path>\n  /workflow agents\n  /workflow list\n  /workflow run [--model MODEL] [--thinking LEVEL] <workflow-name-or-path> \"<task>\" [--detach]\n  /workflow dynamic [--model MODEL] [--thinking LEVEL] \"<task>\" [--detach]\n  /workflow status [run-id]\n  /workflow show <run-id-or-workflow-name>\n  /workflow logs <run-id> [task-id] [lines]\n  /workflow wait <run-id> [timeout-ms]\n  /workflow resume <run-id>\n\n/workflow opens the read-only workflow board TUI.\n/workflow <run-id> opens the board focused on that run.\n/workflow dynamic starts a spec-less direct dynamic run: no workflow name,\nuser-selected spec, or generated workflow spec is required.\n\nWith --detach, a standalone supervisor process (pi-workflow supervise) keeps\nthe run progressing after this session exits.\n";
+export declare const WORKFLOW_HELP = "pi-workflow\n\nUsage:\n  /workflow [run-id]\n  /workflow help\n  /workflow validate <workflow-name-or-path>\n  /workflow roles <workflow-name-or-path>\n  /workflow agents\n  /workflow list\n  /workflow run [--model MODEL] [--thinking LEVEL] <workflow-name-or-path> \"<task>\" [--detach]\n  /workflow dynamic [--model MODEL] [--thinking LEVEL] \"<task>\" [--detach]\n  /workflow status [run-id]\n  /workflow show <run-id-or-workflow-name>\n  /workflow logs <run-id> [task-id] [lines]\n  /workflow wait <run-id> [timeout-ms]\n  /workflow resume <run-id>\n  /workflow stop <run-id>\n\n/workflow opens the read-only workflow board TUI.\n/workflow <run-id> opens the board focused on that run.\n/workflow dynamic starts a spec-less direct dynamic run: no workflow name,\nuser-selected spec, or generated workflow spec is required.\n\nWith --detach, a standalone supervisor process (pi-workflow supervise) keeps\nthe run progressing after this session exits.\n";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { discoverAgents, loadAgentByName, parseAgentMarkdown, } from "./agents.js";
-export { formatLogs, formatRunDetails, formatRunStatus, formatStatus, refreshRun, resumeRun, resumeSupervisors, runDynamicTask, runWorkflow, runWorkflowSpec, waitForRun, } from "./engine.js";
+export { formatLogs, formatRunDetails, formatRunStatus, formatStatus, refreshRun, resumeRun, resumeSupervisors, runDynamicTask, stopRun, runWorkflow, runWorkflowSpec, waitForRun, } from "./engine.js";
 export { listWorkflows, resolveWorkflowRef } from "./workflow-specs.js";
 export { compileRole, extractMarkdownSections } from "./roles.js";
 export { loadWorkflow, loadWorkflowSpec, parseWorkflow } from "./schema.js";
@@ -23,6 +23,7 @@ Usage:
   /workflow logs <run-id> [task-id] [lines]
   /workflow wait <run-id> [timeout-ms]
   /workflow resume <run-id>
+  /workflow stop <run-id>
 
 /workflow opens the read-only workflow board TUI.
 /workflow <run-id> opens the board focused on that run.

package/dist/store.js

@@ -1,11 +1,12 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { cp, mkdir, open, readdir, readFile, realpath, rename, stat, unlink, utimes, writeFile, } from "node:fs/promises";
+import { cp, link, mkdir, open, readdir, readFile, realpath, rename, stat, unlink, utimes, writeFile, } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep, } from "node:path";
 import { randomBytes } from "node:crypto";
 import { parseWorkflow } from "./schema.js";
 import { WORKFLOW_RUN_TYPE, } from "./types.js";
 const TERMINAL_INDEX_LIMIT = 50;
 const LEASE_STALE_MS = 30_000;
+const LEASE_ABSOLUTE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
 const INDEX_LOCK_WAIT_MS = 5_000;
 const INDEX_LOCK_RETRY_MS = 50;
 const DEFAULT_INDEX_UPDATE_DEBOUNCE_MS = 500;
@@ -142,34 +143,74 @@ async function reclaimStaleLock(lockFile) {
     const snapshot = await readLockSnapshot(lockFile);
     if (!snapshot)
         return true;
-    if (Date.now() - snapshot.mtimeMs <= LEASE_STALE_MS)
+    if (!isReclaimableLockSnapshot(snapshot))
         return false;
-    if (snapshot.pid !== undefined && isProcessAlive(snapshot.pid))
+    const reclaimFile = `${lockFile}.reclaim-${process.pid}-${randomBytes(3).toString("hex")}`;
+    try {
+        await rename(lockFile, reclaimFile);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
         return false;
-    const latest = await readLockSnapshot(lockFile);
-    if (!latest)
+    }
+    const claimed = await readLockSnapshot(reclaimFile);
+    if (!claimed)
         return true;
-    if (latest.ownerId !== snapshot.ownerId || latest.pid !== snapshot.pid)
+    if (!sameLockOwnerSnapshot(snapshot, claimed)) {
+        await restoreReclaimFile(reclaimFile, lockFile);
+        return false;
+    }
+    if (!isReclaimableLockSnapshot(claimed)) {
+        await restoreReclaimFile(reclaimFile, lockFile);
         return false;
-    if (Date.now() - latest.mtimeMs <= LEASE_STALE_MS)
+    }
+    await unlink(reclaimFile).catch(() => undefined);
+    return true;
+}
+async function restoreReclaimFile(reclaimFile, lockFile) {
+    try {
+        await link(reclaimFile, lockFile);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+    finally {
+        await unlink(reclaimFile).catch(() => undefined);
+    }
+}
+function isReclaimableLockSnapshot(snapshot) {
+    const now = Date.now();
+    const leaseStale = now - snapshot.mtimeMs > LEASE_STALE_MS;
+    const absoluteStale = now - (snapshot.createdAtMs ?? snapshot.mtimeMs) > LEASE_ABSOLUTE_STALE_MS;
+    if (!leaseStale && !absoluteStale)
         return false;
-    if (latest.pid !== undefined && isProcessAlive(latest.pid))
+    if (snapshot.pid !== undefined &&
+        isProcessAlive(snapshot.pid) &&
+        !absoluteStale)
         return false;
-    await unlink(lockFile).catch(() => undefined);
     return true;
 }
+function sameLockOwnerSnapshot(left, right) {
+    return (left.ownerId === right.ownerId &&
+        left.pid === right.pid &&
+        left.createdAtMs === right.createdAtMs);
+}
 async function readLockSnapshot(lockFile) {
     try {
         const [fileStat, text] = await Promise.all([
             stat(lockFile),
             readFile(lockFile, "utf8"),
         ]);
-        const [ownerId = "", pidText] = text.split(/\r?\n/);
+        const [ownerId = "", pidText, createdAtText] = text.split(/\r?\n/);
         const pid = Number.parseInt(pidText ?? "", 10);
+        const createdAtMs = Date.parse(createdAtText ?? "");
         return {
             ownerId,
             pid: Number.isFinite(pid) ? pid : undefined,
             mtimeMs: fileStat.mtimeMs,
+            createdAtMs: Number.isFinite(createdAtMs) ? createdAtMs : undefined,
         };
     }
     catch (error) {
@@ -996,8 +1037,10 @@ export function deriveWorkflowStatus(summary) {
         return "running";
     if (summary.total > 0 && summary.completed === summary.total)
         return "completed";
-    if (summary.failed > 0 || summary.interrupted > 0)
+    if (summary.failed > 0)
         return "failed";
+    if (summary.interrupted > 0)
+        return "interrupted";
     return "interrupted";
 }
 export function isTerminalWorkflowStatus(status) {
@@ -1176,6 +1219,7 @@ export function createTaskRunRecord(cwd, runId, task, index) {
         dependsOn: task.dependsOn,
         artifactGraph: taskArtifactGraph,
         dynamicGenerated: task.dynamicGenerated,
+        foreachGenerated: task.foreachGenerated,
         files,
         lastMessage: blocked ? task.safety.permission.reason : undefined,
     };

package/dist/subagent-backend.js

@@ -17,7 +17,12 @@ const LEGACY_FETCH_CACHE_ENV = "PI_WORKFLOW_FETCH_CACHE";
 const DEFAULT_TRANSIENT_MODEL_FAILURE_RETRIES = 5;
 const DEFAULT_ARTIFACT_OUTPUT_RETRIES = 2;
 const MAX_CONCURRENT_LAUNCHES_ENV = "PI_WORKFLOW_MAX_CONCURRENT_LAUNCHES";
+const PARENT_SUBAGENT_CWD_ENV = "PI_WORKFLOW_PARENT_SUBAGENT_CWD";
+const PARENT_SUBAGENT_RUNS_DIR_ENV = "PI_WORKFLOW_PARENT_SUBAGENT_RUNS_DIR";
+const PARENT_SUBAGENT_RUN_ID_ENV = "PI_WORKFLOW_PARENT_SUBAGENT_RUN_ID";
+const PARENT_SUBAGENT_ATTEMPT_ID_ENV = "PI_WORKFLOW_PARENT_SUBAGENT_ATTEMPT_ID";
 const DEFAULT_LAUNCH_SLOT_RELEASE_DELAY_MS = 3_000;
+const STALE_LAUNCH_CLAIM_GRACE_MS = 30_000;
 const MIN_TRANSIENT_RETRY_JITTER_MS = 1_000;
 const MAX_TRANSIENT_RETRY_JITTER_MS = 5_000;
 const MODULE_PATH = fileURLToPath(import.meta.url);
@@ -39,6 +44,12 @@ function bundledNodeModulePath(packageName, ...parts) {
     ];
     return (candidates.find((candidate) => existsSync(candidate)) ?? candidates[0]);
 }
+const GENERIC_TASK_STATUS_DETAILS = new Set([
+    "completed",
+    "failed",
+    "interrupted",
+    "running",
+]);
 const subagentApiSpecifier = "@agwab/pi-subagent/api";
 let cachedSubagentApi;
 let injectedSubagentApi;
@@ -52,6 +63,67 @@ async function loadSubagentApi() {
     cachedSubagentApi ??= import(subagentApiSpecifier).then((mod) => mod);
     return cachedSubagentApi;
 }
+function nonEmptyEnv(env, key) {
+    const value = env[key]?.trim();
+    return value ? value : undefined;
+}
+function parentSubagentRefFromEnv(env = process.env) {
+    const cwd = nonEmptyEnv(env, PARENT_SUBAGENT_CWD_ENV);
+    const runsDir = nonEmptyEnv(env, PARENT_SUBAGENT_RUNS_DIR_ENV);
+    const runId = nonEmptyEnv(env, PARENT_SUBAGENT_RUN_ID_ENV);
+    if (!cwd || !runsDir || !runId)
+        return undefined;
+    const attemptId = nonEmptyEnv(env, PARENT_SUBAGENT_ATTEMPT_ID_ENV);
+    return { cwd, runsDir, runId, ...(attemptId ? { attemptId } : {}) };
+}
+function terminalChildEventForTaskStatus(status) {
+    if (status === "completed")
+        return "completed";
+    if (status === "failed")
+        return "failed";
+    if (status === "interrupted")
+        return "cancelled";
+    return undefined;
+}
+async function recordParentSubagentChildEvent(options) {
+    const parent = parentSubagentRefFromEnv();
+    if (!parent)
+        return;
+    const api = await loadSubagentApi().catch(() => undefined);
+    if (!api?.recordSubagentChildEvent)
+        return;
+    await api
+        .recordSubagentChildEvent({
+        ...parent,
+        event: options.event,
+        childRunId: options.childRunId,
+        workflowRunId: options.run.runId,
+        childTaskId: options.task.taskId,
+        ...(options.failureKind === undefined
+            ? {}
+            : { failureKind: options.failureKind }),
+        ...(options.message === undefined ? {} : { message: options.message }),
+    })
+        .catch(() => undefined);
+}
+async function recordTerminalParentSubagentChildEvent(run, task, snapshot) {
+    const event = terminalChildEventForTaskStatus(task.status);
+    if (!event)
+        return;
+    const taskFailureKind = task.statusDetail && !GENERIC_TASK_STATUS_DETAILS.has(task.statusDetail)
+        ? task.statusDetail
+        : undefined;
+    await recordParentSubagentChildEvent({
+        event,
+        childRunId: snapshot.runId,
+        run,
+        task,
+        failureKind: event === "completed"
+            ? undefined
+            : (snapshot.failureKind ?? taskFailureKind ?? task.statusDetail),
+        message: task.lastMessage,
+    });
+}
 let launchSlotReleaseDelayMs = DEFAULT_LAUNCH_SLOT_RELEASE_DELAY_MS;
 let transientRetryJitterForTests;
 const launchWaitQueue = [];
@@ -87,8 +159,7 @@ function releaseLaunchSlotAfterDelay(delayMs, release) {
         release();
         return;
     }
-    const timer = setTimeout(release, delayMs);
-    timer.unref?.();
+    setTimeout(release, delayMs);
 }
 async function runWithLaunchSlot(action) {
     const release = await acquireLaunchSlot();
@@ -129,8 +200,6 @@ export function setSubagentLaunchControlsForTests(options) {
 }
 export async function cleanupSubagentRun(_cwd, run) {
     for (const task of run.tasks) {
-        if (isTerminalTaskStatus(task.status))
-            continue;
         const handle = getSubagentHandle(task);
         if (!handle)
             continue;
@@ -240,6 +309,13 @@ export async function launchSubagentTask(cwd, run, task, compiledTask) {
     task.statusDetail = "running";
     task.lastMessage = "launched via pi-subagent/headless";
     await writeRunRecord(cwd, run).catch(() => undefined);
+    await recordParentSubagentChildEvent({
+        event: "started",
+        childRunId: launched.runId,
+        run,
+        task,
+        message: task.lastMessage,
+    });
     return { kind: "launched" };
 }
 export async function refreshRunFromSubagentArtifacts(cwd, run) {
@@ -266,8 +342,13 @@ export async function refreshRunFromSubagentArtifacts(cwd, run) {
             }
         }
         if (!handle) {
+            if (isStaleLaunchClaim(task)) {
+                resetStaleLaunchClaim(task);
+                changed = true;
+                continue;
+            }
             if (isTaskTimedOut(task)) {
-                markTaskTimedOut(task);
+                markSubagentTaskTimedOut(task);
                 changed = true;
             }
             continue;
@@ -290,16 +371,8 @@ export async function refreshRunFromSubagentArtifacts(cwd, run) {
             .catch(() => null);
         if (snapshot === null) {
             if (isTaskTimedOut(task)) {
-                await api
-                    .interruptSubagent({
-                    cwd: handle.cwd,
-                    runsDir: handle.runsDir,
-                    runId: handle.runId,
-                    attemptId: handle.attemptId,
-                    reason: "workflow timeout",
-                })
-                    .catch(() => undefined);
-                markTaskTimedOut(task);
+                await interruptTimedOutSubagent(api, handle);
+                markSubagentTaskTimedOut(task);
                 changed = true;
             }
             continue;
@@ -312,16 +385,8 @@ export async function refreshRunFromSubagentArtifacts(cwd, run) {
                 ? `pi-subagent heartbeat ${activeAttempt.heartbeatAt}`
                 : "pi-subagent running";
             if (isTaskTimedOut(task)) {
-                await api
-                    .interruptSubagent({
-                    cwd: handle.cwd,
-                    runsDir: handle.runsDir,
-                    runId: handle.runId,
-                    attemptId: handle.attemptId,
-                    reason: "workflow timeout",
-                })
-                    .catch(() => undefined);
-                markTaskTimedOut(task);
+                await interruptTimedOutSubagent(api, handle);
+                markSubagentTaskTimedOut(task);
                 changed = true;
             }
             continue;
@@ -333,6 +398,40 @@ export async function refreshRunFromSubagentArtifacts(cwd, run) {
         await writeRunRecord(cwd, run);
     return run;
 }
+async function interruptTimedOutSubagent(api, handle) {
+    await api
+        .interruptSubagent({
+        cwd: handle.cwd,
+        runsDir: handle.runsDir,
+        runId: handle.runId,
+        attemptId: handle.attemptId,
+        reason: "workflow timeout",
+    })
+        .catch(() => undefined);
+}
+function markSubagentTaskTimedOut(task) {
+    markTaskTimedOut(task);
+    task.backendHandle = undefined;
+    task.backendTaskId = task.taskId;
+    task.pid = undefined;
+}
+function isStaleLaunchClaim(task) {
+    if (task.statusDetail !== "launching" || !task.startedAt)
+        return false;
+    const startedAtMs = Date.parse(task.startedAt);
+    return (Number.isFinite(startedAtMs) &&
+        Date.now() - startedAtMs > STALE_LAUNCH_CLAIM_GRACE_MS);
+}
+function resetStaleLaunchClaim(task) {
+    task.status = "pending";
+    task.statusDetail = "pending";
+    task.startedAt = undefined;
+    task.backendHandle = undefined;
+    task.backendFiles = undefined;
+    task.backendTaskId = task.taskId;
+    task.pid = undefined;
+    task.lastMessage = "stale pi-subagent launch claim reset";
+}
 async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
     const outputRef = findLog(snapshot, "output");
     const stderrRef = findLog(snapshot, "stderr");
@@ -386,7 +485,7 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
     const contextLengthExceeded = Boolean(subagentResult?.metadata?.contextLengthExceeded ??
         snapshot.metadata?.contextLengthExceeded);
     if (task.artifactGraph?.enabled && statusInfo.status === "completed") {
-        return await materializeTerminalArtifactGraphResult(cwd, run, task, {
+        const changed = await materializeTerminalArtifactGraphResult(cwd, run, task, {
             outputFile,
             stderrFile,
             resultFile,
@@ -395,6 +494,8 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
             exitCode,
             subagentResult,
         });
+        await recordTerminalParentSubagentChildEvent(run, task, snapshot);
+        return changed;
     }
     if (shouldAttemptArtifactGraphSalvage({
         task,
@@ -406,7 +507,7 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
         subagentResult,
         snapshot,
     })) {
-        return await materializeTerminalArtifactGraphResult(cwd, run, task, {
+        const changed = await materializeTerminalArtifactGraphResult(cwd, run, task, {
             outputFile,
             stderrFile,
             resultFile,
@@ -420,6 +521,8 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
                 subagentFailureKind: snapshot.failureKind,
             },
         });
+        await recordTerminalParentSubagentChildEvent(run, task, snapshot);
+        return changed;
     }
     const workflowResult = {
         status: statusInfo.status,
@@ -447,10 +550,12 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
     };
     if (shouldRetryTransientModelFailure(statusInfo, workflowResult, outputBytes)) {
         await writeJson(transientFailureAttemptPath(resultFile, (task.launchRetry?.attempts ?? 0) + 1), workflowResult);
-        return retryOrFailTransientSubagentFailure(task, {
+        const changed = retryOrFailTransientSubagentFailure(task, {
             reason: statusInfo.failureKind ?? "model",
             message: errorMessage ?? "pi-subagent run failed before producing output",
         });
+        await recordTerminalParentSubagentChildEvent(run, task, snapshot);
+        return changed;
     }
     await writeJson(resultFile, workflowResult);
     const completedAfterTimeout = resultCompletedAfterTimeout(task, completedAt);
@@ -464,6 +569,7 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
         delete task.backendHandle;
         delete task.backendFiles;
     }
+    await recordTerminalParentSubagentChildEvent(run, task, snapshot);
     return changed;
 }
 function artifactGraphRetrySession(run, task, subagentResult, attempt) {
@@ -1145,6 +1251,7 @@ async function recoverSubagentHandle(run, task) {
     const runsDir = subagentRunsDir(run, task);
     const absoluteRunsDir = resolve(task.cwd, runsDir);
     const expectedCorrelationId = `${run.runId}:${task.taskId}`;
+    const claimStartedAtMs = timestampMs(task.startedAt);
     const entries = await readdir(absoluteRunsDir, { withFileTypes: true }).catch(() => []);
     const candidates = [];
     for (const entry of entries) {
@@ -1153,6 +1260,8 @@ async function recoverSubagentHandle(run, task) {
         const record = await readJsonLoose(join(absoluteRunsDir, entry.name, "run.json"));
         if (!record || record.correlationId !== expectedCorrelationId)
             continue;
+        if (isPreClaimSubagentRecord(record, claimStartedAtMs))
+            continue;
         const attemptId = record.activeAttemptId ??
             record.latestAttemptId ??
             record.attempts?.at(-1)?.attemptId;
@@ -1170,6 +1279,14 @@ async function recoverSubagentHandle(run, task) {
     candidates.sort((left, right) => right.updatedAtMs - left.updatedAtMs);
     return candidates[0]?.handle;
 }
+function isPreClaimSubagentRecord(record, claimStartedAtMs) {
+    if (claimStartedAtMs === undefined)
+        return false;
+    const recordStartedAtMs = timestampMs(record.startedAt) ??
+        timestampMs(record.attempts?.[0]?.startedAt) ??
+        timestampMs(record.updatedAt);
+    return (recordStartedAtMs !== undefined && recordStartedAtMs < claimStartedAtMs);
+}
 function timestampMs(value) {
     if (value === undefined)
         return undefined;
@@ -1213,7 +1330,16 @@ function subagentRunsDir(run, task) {
 function subagentSessionId(run, task) {
     if (!task.artifactGraph?.enabled)
         return undefined;
-    return task.outputRetry?.sessionId ?? baseSubagentSessionId(run, task);
+    const baseSessionId = baseSubagentSessionId(run, task);
+    if (task.outputRetry?.sessionId)
+        return task.outputRetry.sessionId;
+    const launchAttempt = task.launchRetry?.attempts ?? 0;
+    if (launchAttempt > 0)
+        return `${baseSessionId}:launch-retry-${launchAttempt}`;
+    const resumeAttempt = task.resumeEvents?.length ?? 0;
+    if (resumeAttempt > 0)
+        return `${baseSessionId}:resume-${resumeAttempt}`;
+    return baseSessionId;
 }
 function baseSubagentSessionId(run, task) {
     return `pi-workflow.${run.runId}.${task.taskId}`.replace(/[^A-Za-z0-9._-]/g, "-");

package/dist/types.d.ts

@@ -484,6 +484,9 @@ export interface CompiledTask {
         branchId?: string;
         outputProfile?: string;
     };
+    foreachGenerated?: {
+        placeholderSpecId: string;
+    };
     loopChild?: CompiledLoopChildTaskRef;
     loopPlaceholder?: {
         loopId: string;
@@ -562,6 +565,9 @@ export interface WorkflowTaskRunRecord {
         branchId?: string;
         outputProfile?: string;
     };
+    foreachGenerated?: {
+        placeholderSpecId: string;
+    };
     launchRetry?: {
         attempts: number;
         maxAttempts?: number;

package/dist/workflow-runtime.js

@@ -193,9 +193,18 @@ export function readSimpleJsonPath(value, path) {
     const parts = path.slice(2).split(".").filter(Boolean);
     let current = value;
     for (const part of parts) {
-        if (current === null || typeof current !== "object" || !(part in current))
+        if (!canReadJsonPathPart(current, part))
             return undefined;
         current = current[part];
     }
     return current;
 }
+function canReadJsonPathPart(value, part) {
+    return (isSafeJsonPathPart(part) && isRecord(value) && Object.hasOwn(value, part));
+}
+function isSafeJsonPathPart(part) {
+    return part !== "__proto__" && part !== "prototype" && part !== "constructor";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/workflow-view.js

@@ -953,12 +953,14 @@ function statusForSummary(summary) {
         return "running";
     if (summary.blocked > 0)
         return "blocked";
-    if (summary.failed > 0 || summary.interrupted > 0)
+    if (summary.failed > 0)
         return "failed";
     if (summary.pending > 0)
         return "pending";
     if (summary.total > 0 && summary.completed === summary.total)
         return "completed";
+    if (summary.interrupted > 0)
+        return "interrupted";
     return "interrupted";
 }
 function taskElapsed(task) {