@agwab/pi-workflow 0.3.0 → 0.4.0

package/dist/engine.js

@@ -4,11 +4,12 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { Worker } from "node:worker_threads";
 import { compileWorkflow } from "./compiler.js";
 import { loadWorkflowSpec } from "./schema.js";
-import { createRunRecord, createTaskRunRecord, compiledWorkflowPath, fromProjectPath, indexSupervisorErrorPath, isTerminalWorkflowStatus, isTerminalTaskStatus, listRunRecords, readIndex, readJson, readRunRecord, resetTaskForResume, setTaskTerminal, supervisorPath, toProjectPath, updateIndex, withRunLease, workflowRunPath, writeJsonAtomic, writeRunRecord, writeCompiledRunArtifact, writeStaticRunArtifacts, } from "./store.js";
+import { createRunRecord, createTaskRunRecord, compiledWorkflowPath, fromProjectPath, indexSupervisorErrorPath, isBlockedTaskResumableForResume, isTerminalWorkflowStatus, isTerminalTaskStatus, listRunRecords, readIndex, readJson, readRunRecord, resetTaskForResume, setTaskTerminal, supervisorPath, toProjectPath, updateIndex, withRunLease, workflowRunPath, writeJsonAtomic, writeRunRecord, writeCompiledRunArtifact, writeStaticRunArtifacts, } from "./store.js";
 import { resolveWorkflowBackend } from "./backend.js";
 import { ensureManagedWorktree } from "./worktree.js";
 import { resolveWorkflowHelperRef } from "./workflow-helpers.js";
 import { buildAvailableToolView } from "./tool-metadata.js";
+import { summarizeWorkflowTelemetry } from "./workflow-artifacts.js";
 import { workflowBundleFingerprint, workflowBundleSpecPath, } from "./workflow-source-context-runtime.js";
 import { readSimpleJsonPath, } from "./workflow-runtime.js";
 import { dynamicRunDir, hashDynamicRequest, readDynamicEvents, } from "./dynamic-events.js";
@@ -18,10 +19,11 @@ import { assertDynamicRuntimeBudgetAvailable, dynamicRuntimeBudgetExceededMessag
 import { assertDynamicGeneratedMetadataMatches, assertDynamicGenerationBudgetAvailable, buildDynamicGeneratedCompiledTask, dynamicGeneratedInsertIndex, isDynamicCompiledTaskPayload, normalizeDynamicAgentRequest, readDynamicGeneratedTaskResult, } from "./dynamic-generated-task-runtime.js";
 import { optionalEventString, runDynamicHelperCall, runDynamicNestedWorkflowCall, } from "./dynamic-controller-calls.js";
 import { normalizeDynamicFanoutPlanRequest, runDynamicDecisionLoopStatusPersistCall, runDynamicDecisionPersistCall, runDynamicFanoutPlanPersistCall, runDynamicResultReadCall, runDynamicStateIndexPersistCall, } from "./dynamic-control-ops.js";
-import { assertRunTaskPositionalAlignment, buildForeachGeneratedTasks, dependenciesReady, markDagDependentsSkipped, nextTaskRecordIndex, reconcileDynamicGeneratedRunRecords, reconcileForeachGeneratedRunRecords, recoverStaleRunningDynamicControllers, replaceDependencyList, sourceStageIdsForFrom, stageSourcePolicy, updateDownstreamDependencies, } from "./engine-run-graph.js";
+import { assertRunTaskPositionalAlignment, buildForeachGeneratedTasks, dependenciesReady, foreachStreamingEnabled, foreachStreamingMinChunk, markDagDependentsSkipped, nextTaskRecordIndex, reconcileDynamicGeneratedRunRecords, reconcileForeachGeneratedRunRecords, recoverStaleRunningDynamicControllers, replaceDependencyList, sourceStageIdsForFrom, stageSourcePolicy, updateDownstreamDependencies, } from "./engine-run-graph.js";
 import { reconcileLoopTaskMaterialization, scheduleLoop, } from "./loop-runtime.js";
 import { executeSupportTask, normalizeDynamicControllerOutput, prepareArtifactGraphRetryTask, prepareDagTask, readArtifactGraphControl, readArtifactGraphSupportSources, readSupportSources, writeArtifactGraphDynamicResult, } from "./artifact-graph-runtime.js";
 import { DIRECT_DYNAMIC_RUNTIME_VERSION, ensureDirectDynamicRuntimeBundle, } from "./dynamic-runtime-bundle.js";
+import { hasFatalPartialOutputIssue, readWorkflowPartialOutputLedger, writeWorkflowPartialOutputLedgerFromFile, } from "./workflow-partial-output.js";
 import { WORKFLOW_RUN_TYPE, } from "./types.js";
 export { buildRunSourceContext } from "./workflow-source-context-runtime.js";
 export { evaluateLoopUntilCondition } from "./loop-runtime.js";
@@ -126,6 +128,18 @@ export async function waitForRun(cwd, runIdOrPrefix, timeoutMs, options = {}) {
     }
     return run;
 }
+function assertBlockedRunResumable(run) {
+    if (run.status !== "blocked")
+        return;
+    const blockers = run.tasks.filter((task) => task.status === "blocked" && !isBlockedTaskResumableForResume(task));
+    if (blockers.length === 0)
+        return;
+    const details = blockers
+        .slice(0, 3)
+        .map((task) => `${task.specId} statusDetail=${task.statusDetail}`)
+        .join(", ");
+    throw new Error(`Cannot resume blocked run ${run.runId}: non-resumable blocked task(s): ${details}. Resolve the attention/approval blocker before resuming.`);
+}
 export async function stopRun(cwd, runIdOrPrefix) {
     const current = await readRunRecord(cwd, runIdOrPrefix);
     const stopped = await withRunLease(cwd, current.runId, async () => {
@@ -160,6 +174,7 @@ export async function resumeRun(cwd, runIdOrPrefix, options = {}) {
         current.status !== "blocked") {
         throw new Error(`resume requires a failed, interrupted, or resumable blocked run; ${current.runId} is ${current.status}`);
     }
+    assertBlockedRunResumable(current);
     const compiledFlow = await readCompiledWorkflow(cwd, current.runId);
     const hasLoopTasks = compiledFlow?.tasks.some((task) => task.kind === "loop" ||
         task.loopPlaceholder !== undefined ||
@@ -170,6 +185,7 @@ export async function resumeRun(cwd, runIdOrPrefix, options = {}) {
     const resetTaskIds = [];
     const updated = await withRunLease(cwd, current.runId, async () => {
         const run = await readRunRecord(cwd, current.runId);
+        assertBlockedRunResumable(run);
         await resolveWorkflowBackend(run)
             .cleanupRun(cwd, run)
             .catch(() => undefined);
@@ -271,8 +287,19 @@ function isMissingRunError(error) {
     return (isEnoentError(error) ||
         (error instanceof Error && /^Flow run not found: /.test(error.message)));
 }
+function assertScheduleLeaseActive(signal) {
+    if (!signal?.aborted)
+        return;
+    const reason = signal.reason;
+    if (reason instanceof Error)
+        throw reason;
+    throw new Error(reason === undefined
+        ? "Lost supervisor lease"
+        : `Lost supervisor lease: ${String(reason)}`);
+}
 export async function scheduleRun(cwd, runId, compiled, options = {}) {
-    return withRunLease(cwd, runId, async () => {
+    return withRunLease(cwd, runId, async (leaseSignal) => {
+        assertScheduleLeaseActive(leaseSignal);
         let run = await readRunRecord(cwd, runId);
         run = await resolveWorkflowBackend(run).refreshRun(cwd, run);
         if (isTerminalWorkflowStatus(run.status))
@@ -287,7 +314,8 @@ export async function scheduleRun(cwd, runId, compiled, options = {}) {
         if (compiledFlow.type !== WORKFLOW_RUN_TYPE) {
             throw new Error(`unsupported compiled workflow type: ${compiledFlow.type}`);
         }
-        await scheduleDag(cwd, run, compiledFlow, options);
+        await scheduleDag(cwd, run, compiledFlow, options, leaseSignal);
+        assertScheduleLeaseActive(leaseSignal);
         run = await readRunRecord(cwd, run.runId);
         return run;
     });
@@ -299,13 +327,13 @@ export async function formatStatus(cwd) {
         const refreshed = (await readIndex(cwd).catch(() => cached)) ?? cached;
         if (refreshed.runs.length === 0)
             return "No workflow runs found.";
-        return formatIndex(refreshed);
+        return formatIndex(cwd, refreshed);
     }
     await reconcileActiveRuns(cwd);
     const rebuilt = await updateIndex(cwd).catch(() => readIndex(cwd));
     if (!rebuilt || rebuilt.runs.length === 0)
         return "No workflow runs found.";
-    return formatIndex(rebuilt);
+    return formatIndex(cwd, rebuilt);
 }
 export async function formatRunDetails(cwd, runIdOrPrefix) {
     const run = await refreshRun(cwd, runIdOrPrefix);
@@ -336,10 +364,12 @@ export async function formatLogs(cwd, runIdOrPrefix, taskId = "task-1", lineCoun
     return `${run.runId}/${task.taskId} output=${task.files.output}\n${tail || "(empty log)"}`;
 }
 export function formatRun(run, detail = "summary") {
+    const telemetry = summarizeWorkflowTelemetry(run);
     const lines = [
         `${run.runId} [${run.status}] type=${run.type} backend=${run.backend.type}/${run.backend.mode}`,
         `created=${run.createdAt} updated=${run.updatedAt}`,
         `tasks=${run.taskSummary.completed}/${run.taskSummary.total} completed, running=${run.taskSummary.running}, pending=${run.taskSummary.pending}, blocked=${run.taskSummary.blocked}, failed=${run.taskSummary.failed}, interrupted=${run.taskSummary.interrupted}`,
+        `completion=${telemetry.completion.health}, outputRetries=${telemetry.retryCounts.output}, launchRetries=${telemetry.retryCounts.launch}, resumeEvents=${telemetry.resumeCounts.events}, contextLimitFailures=${telemetry.completion.contextLimitFailures}`,
     ];
     for (const task of run.tasks) {
         lines.push(formatTask(task, detail));
@@ -372,7 +402,8 @@ async function recordSupervisorError(cwd, runId, error) {
         error: error instanceof Error ? error.message : String(error),
     }).catch(() => undefined);
 }
-async function scheduleDag(cwd, run, compiledFlow, options = {}) {
+async function scheduleDag(cwd, run, compiledFlow, options = {}, leaseSignal) {
+    assertScheduleLeaseActive(leaseSignal);
     if (compiledFlow.type === WORKFLOW_RUN_TYPE) {
         const loopReconciled = await reconcileLoopTaskMaterialization(cwd, run, compiledFlow);
         if (loopReconciled)
@@ -398,6 +429,7 @@ async function scheduleDag(cwd, run, compiledFlow, options = {}) {
     let running = run.tasks.filter((task) => task.status === "running").length;
     const bySpecId = new Map(run.tasks.map((task) => [task.specId, task]));
     for (let index = 0; index < run.tasks.length && running < maxConcurrency; index += 1) {
+        assertScheduleLeaseActive(leaseSignal);
         const task = run.tasks[index];
         const compiledTask = compiledFlow.tasks[index];
         if (!task || !compiledTask || task.status !== "pending")
@@ -417,6 +449,8 @@ async function scheduleDag(cwd, run, compiledFlow, options = {}) {
             const changed = await materializeForeachTask(cwd, run, compiledFlow, index, compiledTask);
             if (changed)
                 return;
+            if (foreachStreamingEnabled(compiledTask))
+                continue;
         }
         if (compiledTask.stageMaxConcurrency !== undefined) {
             const runningInStage = run.tasks.filter((candidate) => candidate.stageId === compiledTask.stageId &&
@@ -425,7 +459,9 @@ async function scheduleDag(cwd, run, compiledFlow, options = {}) {
                 Math.max(1, Math.min(MAX_CONCURRENCY, compiledTask.stageMaxConcurrency)))
                 continue;
         }
+        assertScheduleLeaseActive(leaseSignal);
         const launched = await launchPendingTaskAt(cwd, run, compiledFlow, index, options);
+        assertScheduleLeaseActive(leaseSignal);
         if (launched && run.tasks[index]?.status === "running")
             running += 1;
     }
@@ -505,10 +541,12 @@ async function materializeForeachTask(cwd, run, compiledFlow, index, template) {
         return false;
     const sourceStageIds = sourceStageIdsForFrom(template.foreach.from);
     const sourceTasks = run.tasks.filter((task) => sourceStageIds.includes(task.stageId ?? ""));
+    const streaming = foreachStreamingEnabled(template);
     const extracted = await extractArtifactGraphForeachItems(cwd, {
         from: template.foreach.from,
         sourcePolicy: stageSourcePolicy(compiledFlow, template.stageId),
         maxItems: template.foreach.maxItems,
+        streaming,
     }, sourceTasks);
     if (extracted.error) {
         setTaskTerminal(templateRunTask, "blocked", "foreach_expansion_blocked", {
@@ -527,6 +565,21 @@ async function materializeForeachTask(cwd, run, compiledFlow, index, template) {
         return true;
     }
     const placeholderSpecId = template.id;
+    if (streaming) {
+        return await materializeStreamingForeachTask({
+            cwd,
+            run,
+            compiledFlow,
+            index,
+            templateRunTask,
+            placeholderSpecId,
+            sourceTaskSpecIds: sourceTasks.map((task) => task.specId),
+            itemMetas: extracted.itemMetas ?? [],
+            generatedTasks: generated.tasks,
+            waitingForSources: extracted.waitingForSources ?? false,
+            minChunk: foreachStreamingMinChunk(template),
+        });
+    }
     const generatedSpecIds = generated.tasks.map((task) => task.id);
     const hasDownstreamDependents = compiledFlow.tasks.some((task, taskIndex) => taskIndex !== index && (task.dependsOn ?? []).includes(placeholderSpecId));
     if (generatedSpecIds.length === 0 && !hasDownstreamDependents) {
@@ -550,16 +603,183 @@ async function materializeForeachTask(cwd, run, compiledFlow, index, template) {
     await writeRunRecord(cwd, run);
     return true;
 }
+async function materializeStreamingForeachTask(input) {
+    const sourceTaskSpecIdSet = new Set(input.sourceTaskSpecIds);
+    const generatedTasksWithItemDeps = input.generatedTasks.map((task, index) => {
+        const itemMeta = input.itemMetas[index];
+        if (!itemMeta)
+            return task;
+        return {
+            ...task,
+            dependsOn: replaceSourceDependenciesWithItemSource(task.dependsOn ?? [], sourceTaskSpecIdSet, itemMeta, {
+                keepPartialSourceDependency: partialGeneratedTaskNeedsCompletedSourceContext(task),
+            }),
+            foreachGenerated: {
+                ...(task.foreachGenerated ?? {
+                    placeholderSpecId: input.placeholderSpecId,
+                }),
+                itemHash: itemMeta.itemHash,
+                itemSourceSpecId: itemMeta.sourceSpecId,
+                itemSourceKind: itemMeta.sourceKind,
+                itemRef: itemMeta.itemRef,
+            },
+        };
+    });
+    const existingGeneratedTasks = input.compiledFlow.tasks.filter((task) => task.foreachGenerated?.placeholderSpecId === input.placeholderSpecId);
+    const existingGeneratedSpecIds = existingGeneratedTasks.map((task) => task.id);
+    const existingGeneratedTaskBySpecId = new Map(existingGeneratedTasks.map((task) => [task.id, task]));
+    for (const task of generatedTasksWithItemDeps) {
+        const existing = existingGeneratedTaskBySpecId.get(task.id);
+        const existingHash = existing?.foreachGenerated?.itemHash;
+        const nextHash = task.foreachGenerated?.itemHash;
+        if (existing && existingHash && nextHash && existingHash !== nextHash) {
+            setTaskTerminal(input.templateRunTask, "blocked", "foreach_expansion_blocked", {
+                lastMessage: `foreach streaming item ${task.id} changed after materialization`,
+            });
+            await writeRunRecord(input.cwd, input.run);
+            return true;
+        }
+    }
+    const existingGeneratedSpecIdSet = new Set(existingGeneratedSpecIds);
+    const finalGeneratedSpecIdSet = new Set(generatedTasksWithItemDeps.map((task) => task.id));
+    if (!input.waitingForSources) {
+        const withdrawn = existingGeneratedTasks.find((task) => task.foreachGenerated?.itemSourceKind === "partial" &&
+            !finalGeneratedSpecIdSet.has(task.id));
+        if (withdrawn) {
+            setTaskTerminal(input.templateRunTask, "blocked", "foreach_expansion_blocked", {
+                lastMessage: `foreach streaming item ${withdrawn.id} was published as partial output but is missing from final control`,
+            });
+            await writeRunRecord(input.cwd, input.run);
+            return true;
+        }
+    }
+    const newGeneratedTasks = generatedTasksWithItemDeps.filter((task) => !existingGeneratedSpecIdSet.has(task.id));
+    const allGeneratedSpecIds = [
+        ...existingGeneratedSpecIds,
+        ...newGeneratedTasks.map((task) => task.id),
+    ];
+    const shouldHoldForMinChunk = input.waitingForSources &&
+        newGeneratedTasks.length > 0 &&
+        newGeneratedTasks.length < input.minChunk;
+    if (shouldHoldForMinChunk)
+        return false;
+    let changed = false;
+    if (newGeneratedTasks.length > 0) {
+        let compiledInsertIndex = input.index + 1;
+        while (input.compiledFlow.tasks[compiledInsertIndex]?.foreachGenerated
+            ?.placeholderSpecId === input.placeholderSpecId) {
+            compiledInsertIndex += 1;
+        }
+        input.compiledFlow.tasks.splice(compiledInsertIndex, 0, ...newGeneratedTasks);
+        let runInsertIndex = input.index + 1;
+        while (input.run.tasks[runInsertIndex]?.foreachGenerated?.placeholderSpecId ===
+            input.placeholderSpecId) {
+            runInsertIndex += 1;
+        }
+        const nextIndex = nextTaskRecordIndex(input.run);
+        const generatedRunTasks = newGeneratedTasks.map((task, offset) => createTaskRunRecord(input.cwd, input.run.runId, task, nextIndex + offset));
+        input.run.tasks.splice(runInsertIndex, 0, ...generatedRunTasks);
+        changed = true;
+    }
+    const dependencyTargets = [input.placeholderSpecId, ...allGeneratedSpecIds];
+    for (const task of input.compiledFlow.tasks) {
+        if (!task.dependsOn)
+            continue;
+        const replaced = replaceDependencyList(task.dependsOn, input.placeholderSpecId, dependencyTargets);
+        if (JSON.stringify(task.dependsOn) !== JSON.stringify(replaced)) {
+            task.dependsOn = replaced;
+            changed = true;
+        }
+    }
+    for (const task of input.run.tasks) {
+        if (!task.dependsOn)
+            continue;
+        const replaced = replaceDependencyList(task.dependsOn, input.placeholderSpecId, dependencyTargets);
+        if (JSON.stringify(task.dependsOn) !== JSON.stringify(replaced)) {
+            task.dependsOn = replaced;
+            changed = true;
+        }
+    }
+    if (!input.waitingForSources) {
+        const statusDetail = allGeneratedSpecIds.length === 0
+            ? "foreach_empty"
+            : "foreach_streaming_complete";
+        const lastMessage = allGeneratedSpecIds.length === 0
+            ? "foreach produced 0 item(s)"
+            : `foreach streaming materialized ${allGeneratedSpecIds.length} item(s)`;
+        setTaskTerminal(input.templateRunTask, "completed", statusDetail, {
+            lastMessage,
+        });
+        changed = true;
+    }
+    else if (newGeneratedTasks.length > 0) {
+        input.templateRunTask.statusDetail = "foreach_streaming_waiting";
+        input.templateRunTask.lastMessage = `foreach streaming materialized ${allGeneratedSpecIds.length} item(s); waiting for more source tasks`;
+        changed = true;
+    }
+    if (!changed)
+        return false;
+    await writeJsonAtomic(compiledWorkflowPath(input.cwd, input.run.runId), input.compiledFlow);
+    await writeRunRecord(input.cwd, input.run);
+    return true;
+}
+function replaceSourceDependenciesWithItemSource(dependsOn, sourceTaskSpecIds, itemMeta, options = {}) {
+    const replaced = [];
+    let inserted = false;
+    const shouldReplaceWithSource = itemMeta.sourceKind !== "partial" ||
+        options.keepPartialSourceDependency === true;
+    for (const dep of dependsOn) {
+        if (!sourceTaskSpecIds.has(dep)) {
+            replaced.push(dep);
+            continue;
+        }
+        if (!shouldReplaceWithSource)
+            continue;
+        if (!inserted) {
+            replaced.push(itemMeta.sourceSpecId);
+            inserted = true;
+        }
+    }
+    if (!inserted && shouldReplaceWithSource) {
+        replaced.push(itemMeta.sourceSpecId);
+    }
+    return [...new Set(replaced)];
+}
+function partialGeneratedTaskNeedsCompletedSourceContext(task) {
+    const artifactGraph = task.artifactGraph;
+    if (artifactGraph?.artifactAccess === "none")
+        return false;
+    return Boolean(artifactGraph?.sourceProjection !== undefined ||
+        (artifactGraph?.requiredReads?.length ?? 0) > 0);
+}
 async function extractArtifactGraphForeachItems(cwd, stage, sourceTasks) {
     const items = [];
+    const itemMetas = [];
     const path = stage.from?.path;
     if (typeof path !== "string" || !path.startsWith("$.")) {
         return {
             error: "foreach.from.path must be a control JSONPath like $.items",
         };
     }
+    let waitingForSources = false;
     for (const task of sourceTasks) {
         if (task.status !== "completed") {
+            if (stage.streaming && !isTerminalTaskStatus(task.status)) {
+                const partial = await extractPartialForeachItems(cwd, task, path);
+                if (partial.error)
+                    return { error: partial.error };
+                for (const item of partial.items) {
+                    items.push(item.item);
+                    itemMetas.push({
+                        sourceSpecId: task.specId,
+                        sourceKind: "partial",
+                        itemHash: item.itemHash,
+                        itemRef: `${task.specId}:${item.itemRef}`,
+                    });
+                }
+                waitingForSources = true;
+                continue;
+            }
             if (stage.sourcePolicy !== "partial")
                 return { error: `${task.taskId} did not complete` };
             continue;
@@ -575,7 +795,15 @@ async function extractArtifactGraphForeachItems(cwd, stage, sourceTasks) {
                 }
                 continue;
             }
-            items.push(...value);
+            for (const [index, item] of value.entries()) {
+                items.push(item);
+                itemMetas.push({
+                    sourceSpecId: task.specId,
+                    sourceKind: "control",
+                    itemHash: hashDynamicRequest(item),
+                    itemRef: `${task.specId}:control:${path}[${index}]`,
+                });
+            }
         }
         catch (error) {
             if (stage.sourcePolicy !== "partial") {
@@ -590,7 +818,27 @@ async function extractArtifactGraphForeachItems(cwd, stage, sourceTasks) {
             error: `foreach extracted ${items.length} items, exceeding maxItems=${stage.maxItems}`,
         };
     }
-    return { items };
+    return { items, itemMetas, waitingForSources };
+}
+async function extractPartialForeachItems(cwd, task, path) {
+    const partialPaths = task.artifactGraph?.output.partial?.paths ?? [];
+    if (!partialPaths.includes(path))
+        return { items: [] };
+    const taskDir = dirname(fromProjectPath(cwd, task.files.result));
+    let ledger = await readWorkflowPartialOutputLedger(taskDir).catch(() => undefined);
+    if (!ledger) {
+        ledger = await writeWorkflowPartialOutputLedgerFromFile({
+            taskDir,
+            outputFile: fromProjectPath(cwd, task.files.output),
+            allowedPaths: partialPaths,
+        }).catch(() => undefined);
+    }
+    if (!ledger)
+        return { items: [] };
+    const fatal = hasFatalPartialOutputIssue(ledger);
+    if (fatal)
+        return { items: [], error: fatal.message };
+    return { items: ledger.items.filter((item) => item.path === path) };
 }
 async function launchPendingTaskAt(cwd, run, compiledFlow, index, options = {}) {
     const task = run.tasks[index];
@@ -1900,21 +2148,36 @@ function uniqueStrings(values) {
 async function readCompiledWorkflow(cwd, runId) {
     return readJson(compiledWorkflowPath(cwd, runId));
 }
-function formatIndex(index) {
-    return index.runs
-        .map((run) => {
+async function formatIndex(cwd, index) {
+    const blocks = await Promise.all(index.runs.map(async (run) => {
         const lines = [
             `${run.runId} [${run.status}] type=${run.type} updated=${run.updatedAt}`,
             `tasks=${run.taskSummary.completed}/${run.taskSummary.total} completed, running=${run.taskSummary.running}, pending=${run.taskSummary.pending}, blocked=${run.taskSummary.blocked}, failed=${run.taskSummary.failed}, skipped=${run.taskSummary.skipped}, interrupted=${run.taskSummary.interrupted}`,
         ];
-        for (const task of run.tasks) {
+        for (const task of await indexTasksForStatus(cwd, run)) {
             const message = task.lastMessage ? ` — ${task.lastMessage}` : "";
             const kind = task.kind && task.kind !== "main" ? ` ${task.kind}` : "";
             lines.push(`- ${task.taskId}${kind} ${task.agent} [${task.status}/${task.statusDetail}]${message}`);
         }
         return lines.join("\n");
-    })
-        .join("\n\n");
+    }));
+    return blocks.join("\n\n");
+}
+async function indexTasksForStatus(cwd, run) {
+    if (Array.isArray(run.tasks))
+        return run.tasks;
+    const fullRun = await readRunRecord(cwd, run.runId).catch(() => undefined);
+    return (fullRun?.tasks.map((task) => ({
+        taskId: task.taskId,
+        displayName: task.displayName,
+        agent: task.agent,
+        kind: task.kind,
+        stageId: task.stageId,
+        backendHandle: task.backendHandle,
+        status: task.status,
+        statusDetail: task.statusDetail,
+        lastMessage: task.lastMessage,
+    })) ?? []);
 }
 function formatTask(task, detail) {
     const elapsed = task.elapsedMs !== undefined

package/dist/extension.js

@@ -73,7 +73,7 @@ const WORKFLOW_DYNAMIC_TOOL_PARAMETERS = {
 };
 export default function workflowExtension(pi) {
     let workflowCompletionCache = [];
-    pi.on("session_start", async (_event, ctx) => {
+    pi.on("session_start", async (event, ctx) => {
         if (!isWorkflowSupervisorEnabled())
             return;
         workflowCompletionCache = await listWorkflows(ctx.cwd).catch(() => workflowCompletionCache);
@@ -81,7 +81,8 @@ export default function workflowExtension(pi) {
             dynamicUi: dynamicUiFromContext(ctx),
         }).catch(() => undefined);
         await notifyUnfinishedRuns(ctx.cwd, (message, type) => ctx.ui.notify(message, type)).catch(() => undefined);
-        await deliverMissedWorkflowFeedback(ctx, pi).catch(() => undefined);
+        if (event.reason !== "reload")
+            await deliverMissedWorkflowFeedback(ctx, pi).catch(() => undefined);
     });
     registerWorkflowNaturalLanguageTools(pi);
     pi.registerCommand(WORKFLOW_COMMAND, {

package/dist/index.d.ts

@@ -10,5 +10,13 @@ export type { AgentDefinition, ApprovalMode, BackendOptions, CompiledWorkflow, C
 export { WorkflowValidationError } from "./types.js";
 export { runDynamicDecisionLoop } from "./dynamic-decision-loop.js";
 export type { DynamicDecisionLoopControllerContext, DynamicDecisionLoopResult, DynamicDecisionLoopRunResult, RunDynamicDecisionLoopOptions, } from "./dynamic-decision-loop.js";
+export { assertValidDynamicDecision, validateDynamicDecision, } from "./dynamic-decision.js";
+export type { DynamicDecisionAction, DynamicDecisionPhase, DynamicDecisionStatus, DynamicDecisionValidationContext, DynamicDecisionValidationResult, NormalizedDynamicDecision, } from "./dynamic-decision.js";
+export { dynamicOutputProfileValues } from "./dynamic-profiles.js";
+export type { DynamicOutputProfile } from "./dynamic-profiles.js";
+export { buildWorkflowRunMetrics, WORKFLOW_METRICS_PRICING_MODEL_VERSION, WORKFLOW_METRICS_SCHEMA_VERSION, } from "./workflow-metrics.js";
+export { VERIFICATION_STATUS, VERIFICATION_STATUS_BUCKETS, VERIFICATION_STATUS_LABELS, VERIFICATION_STATUS_VALUES, canonicalVerificationStatus, isNonVerifiedTerminalStatus, isVerificationBlockedStatus, isVerifiedStatus, verificationStatusBucket, } from "./verification-ontology.js";
+export type { TerminalVerificationStatus, VerificationStatus, } from "./verification-ontology.js";
+export type { WorkflowLaunchTimingMetrics, WorkflowMetricValue, WorkflowMetricsPricingModelVersion, WorkflowMetricsPricingSource, WorkflowMetricsSchemaVersion, WorkflowRetryMetrics, WorkflowRunMetrics, WorkflowRunMetricsMetadata, WorkflowRunMetricsRollup, WorkflowStageMetrics, WorkflowTaskMetrics, WorkflowTaskStatusCounts, WorkflowUsageMetrics, } from "./workflow-metrics.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  /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

@@ -6,6 +6,10 @@ export { loadWorkflow, loadWorkflowSpec, parseWorkflow } from "./schema.js";
 export { parseArtifactGraphWorkflowSpec } from "./artifact-graph-schema.js";
 export { WorkflowValidationError } from "./types.js";
 export { runDynamicDecisionLoop } from "./dynamic-decision-loop.js";
+export { assertValidDynamicDecision, validateDynamicDecision, } from "./dynamic-decision.js";
+export { dynamicOutputProfileValues } from "./dynamic-profiles.js";
+export { buildWorkflowRunMetrics, WORKFLOW_METRICS_PRICING_MODEL_VERSION, WORKFLOW_METRICS_SCHEMA_VERSION, } from "./workflow-metrics.js";
+export { VERIFICATION_STATUS, VERIFICATION_STATUS_BUCKETS, VERIFICATION_STATUS_LABELS, VERIFICATION_STATUS_VALUES, canonicalVerificationStatus, isNonVerifiedTerminalStatus, isVerificationBlockedStatus, isVerifiedStatus, verificationStatusBucket, } from "./verification-ontology.js";
 export const WORKFLOW_COMMAND = "workflow";
 export const WORKFLOW_HELP = `pi-workflow
 

package/dist/prompt-json.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Serialize JSON embedded directly in prompts/model context.
+ *
+ * Persisted artifacts can stay pretty-printed for humans, but prompt context
+ * should avoid indentation bytes when the JSON data is otherwise identical.
+ */
+export declare function stringifyPromptJson(value: unknown): string;

package/dist/prompt-json.js

@@ -0,0 +1,13 @@
+/**
+ * Serialize JSON embedded directly in prompts/model context.
+ *
+ * Persisted artifacts can stay pretty-printed for humans, but prompt context
+ * should avoid indentation bytes when the JSON data is otherwise identical.
+ */
+export function stringifyPromptJson(value) {
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined) {
+        throw new TypeError("prompt JSON value must be JSON-serializable");
+    }
+    return serialized;
+}

package/dist/roles.d.ts

@@ -1,4 +1,4 @@
-import { AgentDefinition, CompiledRole, RoleSpec } from "./types.js";
+import type { AgentDefinition, CompiledRole, RoleSpec } from "./types.js";
 export declare const DEFAULT_SAFE_SECTIONS: readonly ["Core Principles", "Domain Expertise", "Safety Review", "Rules", "Research Manifest"];
 export declare function compileRole(name: string, spec: RoleSpec, sourceAgent?: AgentDefinition): CompiledRole;
 export declare function extractMarkdownSections(markdown: string, includeSections: readonly string[], excludeSections: readonly string[]): string;

package/dist/roles.js

@@ -1,3 +1,4 @@
+import { compactStrings } from "./strings.js";
 export const DEFAULT_SAFE_SECTIONS = [
     "Core Principles",
     "Domain Expertise",
@@ -19,14 +20,10 @@ export function compileRole(name, spec, sourceAgent) {
     const maxChars = spec.maxChars ?? DEFAULT_MAX_ROLE_CHARS;
     const includeSections = spec.includeSections ?? [...DEFAULT_SAFE_SECTIONS];
     const excludedSections = [...ALWAYS_EXCLUDED_SECTIONS, ...(spec.excludeSections ?? [])];
-    const parts = [];
-    if (sourceAgent) {
-        const extracted = extractMarkdownSections(sourceAgent.body, includeSections, excludedSections);
-        if (extracted.trim() !== "")
-            parts.push(extracted.trim());
-    }
-    if (spec.prompt?.trim())
-        parts.push(spec.prompt.trim());
+    const parts = compactStrings([
+        sourceAgent ? extractMarkdownSections(sourceAgent.body, includeSections, excludedSections) : undefined,
+        spec.prompt,
+    ], { unique: false });
     const fullContent = parts.join("\n\n");
     const truncated = fullContent.length > maxChars;
     return {

package/dist/store.d.ts

@@ -1,4 +1,20 @@
 import { type CompiledWorkflow, type CompiledTask, type WorkflowIndexRecord, type WorkflowRunRecord, type WorkflowRunStatus, type WorkflowTaskRunRecord, type TaskRunStatus, type TaskSummary } from "./types.js";
+type RunLeaseTestHooks = {
+    heartbeatIntervalMs?: number;
+    onAfterReclaimRename?: (context: {
+        lockFile: string;
+        reclaimFile: string;
+    }) => void | Promise<void>;
+    onBeforeRestoreReclaimFile?: (context: {
+        lockFile: string;
+        reclaimFile: string;
+    }) => void | Promise<void>;
+    onBeforeReleaseLockRename?: (context: {
+        lockFile: string;
+        releaseFile: string;
+        ownerId: string;
+    }) => void | Promise<void>;
+};
 export declare function nowIso(): string;
 export declare function makeRunId(): string;
 export declare function workflowsRoot(cwd: string): string;
@@ -15,7 +31,8 @@ export declare function fromProjectPath(cwd: string, filePath: string): string;
 export declare function ensureDir(dir: string): Promise<void>;
 export declare function readJson<T>(file: string): Promise<T | undefined>;
 export declare function writeJsonAtomic(file: string, value: unknown): Promise<void>;
-export declare function withRunLease<T>(cwd: string, runId: string, action: () => Promise<T>): Promise<T | undefined>;
+export declare function setRunLeaseTestHooksForTests(hooks?: RunLeaseTestHooks): void;
+export declare function withRunLease<T>(cwd: string, runId: string, action: (abortSignal: AbortSignal) => Promise<T>): Promise<T | undefined>;
 export declare function createRunRecord(cwd: string, compiled: CompiledWorkflow, specPath: string, options?: {
     runId?: string;
     parentRunId?: string;
@@ -44,6 +61,7 @@ export declare function setTaskTerminal(task: WorkflowTaskRunRecord, status: Tas
     exitCode?: number;
     lastMessage?: string;
 }): boolean;
+export declare function isBlockedTaskResumableForResume(task: Pick<WorkflowTaskRunRecord, "status" | "statusDetail">): boolean;
 export declare function resetTaskForResume(task: WorkflowTaskRunRecord): boolean;
 export declare function createTaskRunRecord(cwd: string, runId: string, task: CompiledTask, index: number): WorkflowTaskRunRecord;
 export declare function resolveFlowsCwd(cwd: string): Promise<string>;
@@ -56,3 +74,4 @@ export declare function workflowSupervisorOwnerIdForTests(): string;
 export declare function workflowProcessRoleForTests(): string;
 export declare function acquireSupervisorLease(cwd: string, runId: string): Promise<boolean>;
 export declare function heartbeatSupervisorLease(cwd: string, runId: string): Promise<boolean>;
+export {};