@agwab/pi-workflow 0.1.1 → 0.2.0

package/dist/workflow-progress-health.js

@@ -0,0 +1,296 @@
+const ACTIVE_ACTIVITY_MS = 2 * 60_000;
+const LONG_TAIL_ELAPSED_MS = 8 * 60_000;
+const STALL_BY_DURATION = {
+    short: 5 * 60_000,
+    medium: 10 * 60_000,
+    long: 20 * 60_000,
+};
+const STUCK_BY_DURATION = {
+    short: 15 * 60_000,
+    medium: 30 * 60_000,
+    long: 60 * 60_000,
+};
+export function diagnoseWorkflowRunHealth(run, options = {}) {
+    const nowMs = options.nowMs ?? Date.now();
+    const runningTask = currentRunningTask(run.tasks ?? []);
+    if (runningTask)
+        return diagnoseWorkflowTaskHealth(runningTask, run, { nowMs });
+    const problem = (run.tasks ?? []).find((task) => isProblemStatus(task.status));
+    if (problem)
+        return problemRunHealth(problem, nowMs);
+    if (isProblemStatus(run.status))
+        return problemWorkflowHealth(run.status);
+    if (run.status === "completed")
+        return completedWorkflowHealth();
+    return waitingWorkflowHealth(run, nowMs);
+}
+export function diagnoseWorkflowTaskHealth(task, run, options = {}) {
+    const nowMs = options.nowMs ?? Date.now();
+    if (task.status !== "running")
+        return terminalTaskHealth(task, nowMs);
+    return runningTaskHealth(runningContext(task, run, nowMs));
+}
+export function classifyWorkflowTaskDuration(task) {
+    const text = [
+        task.stageId,
+        task.displayName,
+        task.specId,
+        task.kind,
+        task.statusDetail,
+    ]
+        .filter(Boolean)
+        .join(" ")
+        .toLowerCase();
+    if (/\b(render|helper|support|schema|partition|gate)\b/.test(text))
+        return "short";
+    if (/\b(research|audit|synthesis|review|verify|verifier|normalize|plan|impact|spec)\b/.test(text))
+        return "long";
+    const maxRuntimeMs = task.runtime?.maxRuntimeMs;
+    if (maxRuntimeMs !== undefined && Number.isFinite(maxRuntimeMs)) {
+        if (maxRuntimeMs <= 5 * 60_000)
+            return "short";
+        if (maxRuntimeMs >= 60 * 60_000)
+            return "long";
+    }
+    return "medium";
+}
+function currentRunningTask(tasks) {
+    return tasks
+        .filter((task) => task.status === "running")
+        .sort((left, right) => (parseTime(left.startedAt) ?? Number.POSITIVE_INFINITY) -
+        (parseTime(right.startedAt) ?? Number.POSITIVE_INFINITY))[0];
+}
+function completedWorkflowHealth() {
+    return {
+        state: "completed",
+        label: "completed",
+        summary: "run completed",
+        tone: "success",
+        suggestion: "review",
+        reason: "all tasks reached a terminal successful state",
+    };
+}
+function problemWorkflowHealth(status) {
+    return {
+        state: "needs-action",
+        label: "needs action",
+        summary: `run ${status}`,
+        tone: "error",
+        suggestion: "inspect",
+        reason: `workflow status is ${status}`,
+    };
+}
+function problemRunHealth(task, nowMs) {
+    return {
+        state: "needs-action",
+        label: "needs action",
+        summary: `${task.displayName ?? task.taskId ?? "task"} needs attention`,
+        tone: "error",
+        suggestion: "inspect",
+        reason: task.lastMessage ?? task.statusDetail ?? "task did not complete",
+        currentTask: taskSummary(task, nowMs),
+    };
+}
+function waitingWorkflowHealth(run, nowMs) {
+    const hasPending = run.taskSummary.pending > 0;
+    return {
+        state: hasPending ? "pending" : "active",
+        label: hasPending ? "pending" : "active",
+        summary: hasPending
+            ? "waiting for the next schedulable task"
+            : "run is active",
+        tone: hasPending ? "dim" : "accent",
+        suggestion: "wait",
+        reason: hasPending
+            ? "no task is currently running"
+            : "workflow is still in progress",
+        lastActivityAt: run.updatedAt,
+        lastActivityAgeMs: ageMs(run.updatedAt, nowMs),
+    };
+}
+function runningTaskHealth(context) {
+    return (runtimeExceededHealth(context) ??
+        staleRunningHealth(context) ??
+        longTailHealth(context) ??
+        activeRunningHealth(context));
+}
+function runtimeExceededHealth(context) {
+    const maxRuntimeMs = context.task.runtime?.maxRuntimeMs;
+    const hasElapsed = context.elapsedMs !== undefined;
+    const hasBudget = maxRuntimeMs !== undefined && Number.isFinite(maxRuntimeMs);
+    if (!hasElapsed || !hasBudget)
+        return undefined;
+    if (maxRuntimeMs <= 0 || context.elapsedMs <= maxRuntimeMs)
+        return undefined;
+    return runningHealth(context, {
+        state: "likely-stuck",
+        label: "runtime exceeded",
+        summary: "task exceeded its runtime budget",
+        tone: "error",
+        suggestion: "resume",
+        reason: "elapsed time is past runtime.maxRuntimeMs",
+    });
+}
+function staleRunningHealth(context) {
+    if (context.staleMs >= STUCK_BY_DURATION[context.durationClass] &&
+        !context.hasBackendSignal) {
+        return runningHealth(context, {
+            state: "likely-stuck",
+            label: "likely stuck",
+            summary: "no fresh backend or activity signal",
+            tone: "error",
+            suggestion: "resume",
+            reason: "running task has no backend signal and activity is stale",
+        });
+    }
+    if (context.staleMs < STALL_BY_DURATION[context.durationClass])
+        return undefined;
+    return runningHealth(context, {
+        state: "stalled",
+        label: "possibly stalled",
+        summary: "no recent visible progress",
+        tone: "warning",
+        suggestion: "inspect",
+        reason: context.hasBackendSignal
+            ? "backend signal exists, but activity is stale"
+            : "activity is stale",
+    });
+}
+function longTailHealth(context) {
+    const isLongTail = context.durationClass === "long" &&
+        context.elapsedMs !== undefined &&
+        context.elapsedMs >= LONG_TAIL_ELAPSED_MS;
+    if (!isLongTail)
+        return undefined;
+    return runningHealth(context, {
+        state: "long-tail",
+        label: "long-tail active",
+        summary: "slow task with fresh liveness signals",
+        tone: "accent",
+        suggestion: "wait",
+        reason: context.staleMs <= ACTIVE_ACTIVITY_MS
+            ? "liveness signal is fresh"
+            : "long-running stage is still within the stale threshold",
+    });
+}
+function activeRunningHealth(context) {
+    return runningHealth(context, {
+        state: "active",
+        label: "active",
+        summary: "task is running",
+        tone: "accent",
+        suggestion: "wait",
+        reason: context.staleMs <= ACTIVE_ACTIVITY_MS
+            ? "liveness signal is fresh"
+            : "activity remains within the expected window",
+    });
+}
+function runningContext(task, run, nowMs) {
+    const durationClass = classifyWorkflowTaskDuration(task);
+    const startedAtMs = parseTime(task.startedAt);
+    const heartbeatAt = parseHeartbeatAt(task.lastMessage);
+    const activityAt = latestIso([heartbeatAt, run?.updatedAt, task.startedAt]);
+    const lastActivityAgeMs = ageMs(activityAt, nowMs);
+    return {
+        task,
+        nowMs,
+        durationClass,
+        elapsedMs: startedAtMs === undefined ? undefined : Math.max(0, nowMs - startedAtMs),
+        activityAt,
+        lastActivityAgeMs,
+        heartbeatAt,
+        heartbeatAgeMs: ageMs(heartbeatAt, nowMs),
+        hasBackendSignal: Boolean(task.backendHandle || task.pid || heartbeatAt),
+        staleMs: lastActivityAgeMs ?? Number.POSITIVE_INFINITY,
+    };
+}
+function terminalTaskHealth(task, nowMs) {
+    if (task.status === "completed" || task.status === "skipped") {
+        return {
+            state: "completed",
+            label: task.status === "skipped" ? "skipped" : "completed",
+            summary: task.status === "skipped" ? "task skipped" : "task completed",
+            tone: "success",
+            suggestion: "review",
+            reason: task.statusDetail,
+            currentTask: taskSummary(task, nowMs),
+        };
+    }
+    if (task.status === "pending") {
+        return {
+            state: "pending",
+            label: "pending",
+            summary: "waiting for dependencies or scheduler",
+            tone: "dim",
+            suggestion: "wait",
+            reason: task.statusDetail,
+            currentTask: taskSummary(task, nowMs),
+        };
+    }
+    return {
+        state: "needs-action",
+        label: "needs action",
+        summary: `${task.status} task needs attention`,
+        tone: "error",
+        suggestion: "inspect",
+        reason: task.lastMessage ?? task.statusDetail,
+        currentTask: taskSummary(task, nowMs),
+    };
+}
+function runningHealth(context, health) {
+    return {
+        ...health,
+        durationClass: context.durationClass,
+        currentTask: taskSummary(context.task, context.nowMs),
+        lastActivityAt: context.activityAt,
+        lastActivityAgeMs: context.lastActivityAgeMs,
+        heartbeatAt: context.heartbeatAt,
+        heartbeatAgeMs: context.heartbeatAgeMs,
+    };
+}
+function taskSummary(task, nowMs) {
+    const startedAtMs = parseTime(task.startedAt);
+    return {
+        taskId: task.taskId,
+        displayName: task.displayName,
+        stageId: task.stageId,
+        status: task.status,
+        ...(startedAtMs === undefined
+            ? {}
+            : { elapsedMs: Math.max(0, nowMs - startedAtMs) }),
+    };
+}
+function isProblemStatus(status) {
+    return (status === "failed" || status === "blocked" || status === "interrupted");
+}
+function parseHeartbeatAt(message) {
+    if (!message)
+        return undefined;
+    const match = /heartbeat\s+(\d{4}-\d{2}-\d{2}T\S+?Z)/i.exec(message);
+    if (!match)
+        return undefined;
+    const value = match[1];
+    return parseTime(value) === undefined ? undefined : value;
+}
+function latestIso(values) {
+    let latest;
+    let latestMs = Number.NEGATIVE_INFINITY;
+    for (const value of values) {
+        const time = parseTime(value);
+        if (time === undefined || time <= latestMs)
+            continue;
+        latest = value;
+        latestMs = time;
+    }
+    return latest;
+}
+function ageMs(value, nowMs) {
+    const time = parseTime(value);
+    return time === undefined ? undefined : Math.max(0, nowMs - time);
+}
+function parseTime(value) {
+    if (!value)
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}

package/dist/workflow-runtime.d.ts

@@ -11,9 +11,15 @@ export interface WorkflowRuntimeDefaults {
     model?: string;
     thinking?: ThinkingLevel;
 }
+export interface WorkflowRuntimeThinkingResolution {
+    requested?: ThinkingLevel;
+    resolved?: ThinkingLevel;
+    reason?: string;
+}
 export interface WorkflowRuntimeResolutionInput {
     model?: string;
     thinking?: ThinkingLevel;
+    thinkingResolution?: WorkflowRuntimeThinkingResolution;
 }
 export interface WorkflowRuntimeResolutionContext {
     taskKey: string;

package/dist/workflow-runtime.js

@@ -15,10 +15,13 @@ export async function resolveWorkflowRuntime(runtime, context, options) {
         : { baseModel: undefined, thinking: undefined };
     const model = await resolveModel(baseModel, context, options);
     const effectiveThinking = runtime.thinking ?? thinking ?? options.defaults?.thinking;
-    const resolvedThinking = await resolveThinking(model, effectiveThinking, context, options);
+    const thinkingResolution = await resolveThinking(model, effectiveThinking, context, options);
     return {
         ...(model ? { model } : {}),
-        ...(resolvedThinking ? { thinking: resolvedThinking } : {}),
+        ...(thinkingResolution?.resolved
+            ? { thinking: thinkingResolution.resolved }
+            : {}),
+        ...(thinkingResolution ? { thinkingResolution } : {}),
     };
 }
 export function splitKnownThinkingSuffix(model) {
@@ -101,21 +104,41 @@ async function resolveThinking(modelId, requested, context, options) {
         return undefined;
     const model = findModelInfo(modelId, options.availableModels ?? []);
     const supported = getSupportedThinkingLevels(model);
-    if (supported.includes(requested))
-        return requested;
-    if (!options.prompt) {
-        const modelLabel = modelId ?? "selected model";
-        throw new Error(`${modelLabel} does not support reasoning level "${requested}" for ${context.taskKey}. Supported: ${supported.join(", ") || "none"}`);
+    if (supported.includes(requested)) {
+        return { requested, resolved: requested };
     }
     if (supported.length === 0) {
         throw new Error(`${modelId ?? "selected model"} does not expose any supported reasoning levels for ${context.taskKey}`);
     }
-    const selected = await options.prompt.select(`${modelId ?? "Selected model"} does not support reasoning "${requested}" for ${context.taskKey}. Choose a supported level.`, supported);
+    const downgradeOptions = lowerOrEqualSupportedThinking(requested, supported);
+    if (downgradeOptions.length === 0) {
+        const modelLabel = modelId ?? "selected model";
+        throw new Error(`${modelLabel} does not support reasoning level "${requested}" for ${context.taskKey}, and no lower-or-equal fallback is available. Supported: ${supported.join(", ") || "none"}`);
+    }
+    if (!options.prompt) {
+        const resolved = downgradeOptions[downgradeOptions.length - 1];
+        return {
+            requested,
+            resolved,
+            reason: `requested ${requested} is unsupported by ${modelId ?? "selected model"}; using ${resolved}`,
+        };
+    }
+    const selected = await options.prompt.select(`${modelId ?? "Selected model"} does not support reasoning "${requested}" for ${context.taskKey}. Choose a supported lower-or-equal level.`, downgradeOptions);
     if (!selected)
         throw new Error(`Reasoning selection cancelled for ${context.taskKey}`);
-    if (!isThinkingLevel(selected))
+    if (!isThinkingLevel(selected) || !downgradeOptions.includes(selected))
         throw new Error(`Invalid reasoning selection "${selected}" for ${context.taskKey}`);
-    return selected;
+    return {
+        requested,
+        resolved: selected,
+        reason: `selected supported reasoning ${selected} for unsupported request ${requested}`,
+    };
+}
+function lowerOrEqualSupportedThinking(requested, supported) {
+    const requestedIndex = THINKING_LEVELS.indexOf(requested);
+    if (requestedIndex < 0)
+        return [];
+    return THINKING_LEVELS.slice(0, requestedIndex + 1).filter((level) => supported.includes(level));
 }
 function findModelInfo(modelId, available) {
     if (!modelId)

package/dist/workflow-view.d.ts

@@ -62,6 +62,7 @@ export declare class WorkflowView implements Component {
     private taskIdentityLines;
     private taskOverviewLines;
     private taskTimelineLines;
+    private taskHealthLines;
     private taskValidationStripLines;
     private taskArtifactViewerLines;
     private currentArtifactSourceLines;
@@ -83,6 +84,7 @@ export declare class WorkflowView implements Component {
     private syncSelectedTaskId;
     private breadcrumbText;
     private runSummaryLines;
+    private runHealthLines;
     private runDetailSummaryLines;
     private stageContextLines;
     private footerText;

package/dist/workflow-view.js

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import { readFile } from "node:fs/promises";
 import { workflowRunPath, fromProjectPath, listRunRecords, readIndex, readRunRecord, } from "./store.js";
+import { diagnoseWorkflowRunHealth, diagnoseWorkflowTaskHealth, } from "./workflow-progress-health.js";
 import { WORKFLOW_RUN_TYPE, } from "./types.js";
 const REFRESH_INTERVAL_MS = 1_000;
 const MAX_LIST_ROWS = 18;
@@ -277,14 +278,18 @@ export class WorkflowView {
     }
     renderRunsScreen(width) {
         const selected = this.flows[this.selectedFlow];
+        const selectedDetail = selected && this.detailRun?.runId === selected.runId
+            ? this.detailRun
+            : undefined;
         const sideLines = [
             accent(this.theme, "All runs"),
             kvRow(this.theme, "total", String(this.flows.length)),
             kvRow(this.theme, "running", String(this.flows.filter((flow) => flow.status === "running").length)),
+            kvRow(this.theme, "needs action", String(this.flows.filter((flow) => ["failed", "blocked", "interrupted"].includes(flow.status)).length)),
             "",
             accent(this.theme, "Selected"),
             ...(selected
-                ? this.runSummaryLines(selected)
+                ? this.runSummaryLines(selected, selectedDetail)
                 : [placeholder(this.theme, "none")]),
         ];
         return this.renderTwoPane(width, "Filters / Summary", sideLines, "Runs", this.runLines(Math.max(1, this.mainPaneBodyWidth(width))), 32);
@@ -331,9 +336,10 @@ export class WorkflowView {
         return width - leftWidth - 5;
     }
     renderTaskDetail(width, run, task) {
+        const taskHealth = diagnoseWorkflowTaskHealth(task, run);
         const lines = [
             ...boxed(this.theme, "Task Detail", width, [
-                `${statusGlyph(this.theme, task.status)} ${strong(this.theme, task.displayName)} ${statusBadge(this.theme, task.status)} ${muted(this.theme, this.breadcrumbText())}`,
+                `${statusGlyph(this.theme, task.status)} ${strong(this.theme, task.displayName)} ${statusBadge(this.theme, task.status)} ${healthInline(this.theme, taskHealth)} ${muted(this.theme, this.breadcrumbText())}`,
                 taskMetaLine(this.theme, [
                     ["agent", task.agent],
                     ["stage", task.stageId ?? "(none)"],
@@ -343,6 +349,10 @@ export class WorkflowView {
             ], statusColor(task.status)),
             "",
         ];
+        const healthLines = this.taskHealthLines(taskHealth, width - 4);
+        if (healthLines.length > 0) {
+            lines.push(...boxed(this.theme, "Health", width, healthLines, healthColor(taskHealth)), "");
+        }
         const validationLines = this.taskValidationStripLines(task, width - 4);
         if (validationLines.length > 0) {
             lines.push(...boxed(this.theme, "Validation", width, validationLines, task.outputValidation?.status === "invalid" ||
@@ -388,13 +398,15 @@ export class WorkflowView {
             const name = flow.name ?? flow.type;
             const left = `${prefix}${marker} ${selected ? strong(this.theme, name) : name}`;
             const runIdText = shortId(flow.runId).slice(0, 16).padEnd(16, " ");
-            const runningText = flow.taskSummary.running > 0
-                ? ` ${muted(this.theme, "·")} ${metaLabel(this.theme, "running")} ${metaValue(this.theme, String(flow.taskSummary.running))}`
-                : "";
+            const detailRun = this.detailRun?.runId === flow.runId ? this.detailRun : undefined;
+            const health = diagnoseWorkflowRunHealth(detailRun ?? flow);
+            const healthText = health.state === "completed"
+                ? ""
+                : ` ${muted(this.theme, "·")} ${healthLabel(this.theme, health)}`;
             const baseRight = `${statusColumn(this.theme, flow.status, runStatusLabel(flow), statusWidth)}  ${progressBar(this.theme, flow.taskSummary, 5)} ${metaValue(this.theme, runIdText)}`;
             const right = width >= 90
-                ? `${baseRight} ${muted(this.theme, "·")} ${metaLabel(this.theme, "start")} ${metaValue(this.theme, timestampText(flow.createdAt))}${runningText}`
-                : `${baseRight}${runningText}`;
+                ? `${baseRight} ${muted(this.theme, "·")} ${metaLabel(this.theme, "start")} ${metaValue(this.theme, timestampText(flow.createdAt))}${healthText}`
+                : `${baseRight}${healthText}`;
             const line = joinColumns(left, right, width, 17);
             lines.push(selectedLine(this.theme, line, width, selected, true));
         }
@@ -437,7 +449,7 @@ export class WorkflowView {
             const selected = index === this.selectedTask;
             const prefix = selected ? accent(this.theme, "› ") : "  ";
             const left = `${prefix}${statusGlyph(this.theme, task.status)} ${selected ? strong(this.theme, task.displayName) : task.displayName}`;
-            const right = taskListStatusLabel(this.theme, task);
+            const right = taskListStatusLabel(this.theme, task, diagnoseWorkflowTaskHealth(task, run));
             const line = joinColumns(left, metaByStatus(this.theme, task.status, right), width, Math.max(22, Math.floor(width * 0.45)));
             lines.push(selectedLine(this.theme, line, width, selected, true));
         }
@@ -487,6 +499,24 @@ export class WorkflowView {
                     : "warning"));
         return lines.map((line) => fit(line, width));
     }
+    taskHealthLines(health, width) {
+        if (health.state === "completed" || health.state === "pending")
+            return [];
+        const lines = [
+            `${healthGlyph(this.theme, health)} ${healthLabel(this.theme, health)} ${muted(this.theme, health.summary)}`,
+            kvRow(this.theme, "suggested", health.suggestion, healthColor(health)),
+            kvRow(this.theme, "why", health.reason),
+        ];
+        if (health.currentTask?.elapsedMs !== undefined)
+            lines.splice(1, 0, kvRow(this.theme, "elapsed", formatDuration(health.currentTask.elapsedMs)));
+        if (health.durationClass)
+            lines.push(kvRow(this.theme, "duration", `${health.durationClass} expected`));
+        if (health.heartbeatAgeMs !== undefined)
+            lines.push(kvRow(this.theme, "heartbeat", `${formatDuration(health.heartbeatAgeMs)} ago`));
+        if (health.lastActivityAgeMs !== undefined)
+            lines.push(kvRow(this.theme, "activity", `${formatDuration(health.lastActivityAgeMs)} ago`));
+        return lines.map((line) => fit(line, width));
+    }
     taskValidationStripLines(task, width) {
         const summary = taskValidationSummary(task);
         if (!summary)
@@ -502,9 +532,7 @@ export class WorkflowView {
         const total = sourceLines.length;
         const maxStart = Math.max(0, total - TASK_ARTIFACT_VIEW_LINES);
         const start = Math.min(this.artifactScrollLine, maxStart);
-        const end = total === 0
-            ? 0
-            : Math.min(total, start + TASK_ARTIFACT_VIEW_LINES);
+        const end = total === 0 ? 0 : Math.min(total, start + TASK_ARTIFACT_VIEW_LINES);
         const visible = total === 0
             ? [
                 this.taskArtifactView === "output"
@@ -686,7 +714,8 @@ export class WorkflowView {
         return this.tasksForSelectedStage(this.detailRun)[this.selectedTask];
     }
     syncSelectedTaskId(tasks) {
-        const stageTasks = tasks ?? (this.detailRun ? this.tasksForSelectedStage(this.detailRun) : []);
+        const stageTasks = tasks ??
+            (this.detailRun ? this.tasksForSelectedStage(this.detailRun) : []);
         this.selectedTaskId = stageTasks[this.selectedTask]?.taskId ?? "";
     }
     breadcrumbText() {
@@ -704,7 +733,8 @@ export class WorkflowView {
             parts.push(task.displayName);
         return parts.join(" › ");
     }
-    runSummaryLines(flow) {
+    runSummaryLines(flow, detailRun) {
+        const health = diagnoseWorkflowRunHealth(detailRun ?? flow);
         return [
             `${statusGlyph(this.theme, flow.status)} ${strong(this.theme, flow.name ?? flow.type)} ${statusBadge(this.theme, flow.status, runStatusLabel(flow))}`,
             progressBar(this.theme, flow.taskSummary, 8),
@@ -723,9 +753,28 @@ export class WorkflowView {
                     elapsedText(flow.createdAt, flow.updatedAt, flow.status === "running"),
                 ],
             ]),
+            ...this.runHealthLines(health),
+        ];
+    }
+    runHealthLines(health) {
+        if (health.state === "completed")
+            return [];
+        const lines = [
+            "",
+            accent(this.theme, "Health"),
+            `${healthGlyph(this.theme, health)} ${healthLabel(this.theme, health)} ${muted(this.theme, health.summary)}`,
         ];
+        if (health.currentTask?.displayName)
+            lines.push(kvRow(this.theme, "current", health.currentTask.displayName));
+        if (health.lastActivityAgeMs !== undefined)
+            lines.push(kvRow(this.theme, "activity", `${formatDuration(health.lastActivityAgeMs)} ago`));
+        if (health.heartbeatAgeMs !== undefined)
+            lines.push(kvRow(this.theme, "heartbeat", `${formatDuration(health.heartbeatAgeMs)} ago`));
+        lines.push(kvRow(this.theme, "suggested", health.suggestion, healthColor(health)));
+        return lines;
     }
     runDetailSummaryLines(run) {
+        const health = diagnoseWorkflowRunHealth(run);
         const lines = [
             `${statusGlyph(this.theme, run.status)} ${strong(this.theme, run.name ?? run.type)} ${statusBadge(this.theme, run.status)}`,
             progressBar(this.theme, run.taskSummary, 10),
@@ -745,6 +794,7 @@ export class WorkflowView {
                 ["updated", timestampText(run.updatedAt)],
             ]),
             kvRow(this.theme, "run", shortId(run.runId)),
+            ...this.runHealthLines(health),
         ];
         if (run.fanout && run.fanout.length > 0) {
             lines.push("", accent(this.theme, "Fanout"));
@@ -1034,7 +1084,29 @@ function statusColor(status) {
 function statusText(status) {
     return status;
 }
-function taskListStatusLabel(theme, task) {
+function healthColor(health) {
+    return health.tone;
+}
+function healthGlyph(theme, health) {
+    if (health.tone === "success")
+        return success(theme, "✓");
+    if (health.tone === "warning")
+        return warning(theme, "●");
+    if (health.tone === "error")
+        return errorText(theme, "●");
+    if (health.tone === "dim")
+        return muted(theme, "•");
+    return accent(theme, "●");
+}
+function healthLabel(theme, health) {
+    return fg(theme, healthColor(health), strong(theme, health.label));
+}
+function healthInline(theme, health) {
+    if (health.state === "completed" || health.state === "pending")
+        return "";
+    return `${healthGlyph(theme, health)} ${healthLabel(theme, health)}`;
+}
+function taskListStatusLabel(theme, task, health) {
     const validation = taskValidationSummary(task);
     const label = validation?.status === "invalid"
         ? "invalid output"
@@ -1042,8 +1114,13 @@ function taskListStatusLabel(theme, task) {
             ? "valid"
             : task.status === "completed"
                 ? "done"
-                : statusText(task.status);
-    return fg(theme, statusColor(task.status), strong(theme, label));
+                : task.status === "running"
+                    ? health.label
+                    : statusText(task.status);
+    const suffix = task.status === "running" && health.currentTask?.elapsedMs !== undefined
+        ? ` ${muted(theme, "·")} ${metaValue(theme, formatDuration(health.currentTask.elapsedMs))}`
+        : "";
+    return `${fg(theme, task.status === "running" ? healthColor(health) : statusColor(task.status), strong(theme, label))}${suffix}`;
 }
 function compactStatusLabel(theme, status) {
     const label = status === "completed" ? "done" : statusText(status);
@@ -1107,7 +1184,7 @@ function taskValidationSummary(task) {
         : undefined;
     const issueMessage = typeof issue === "string"
         ? issue
-        : issue?.message ?? issue?.path ?? issue?.code ?? "";
+        : (issue?.message ?? issue?.path ?? issue?.code ?? "");
     const message = validation.message ?? validation.reason ?? issueMessage;
     if (status === "valid" && !message)
         return undefined;
@@ -1263,7 +1340,9 @@ function truncateToWidth(text, width) {
         return "";
     if (visibleWidth(text) <= safeWidth)
         return text;
-    const hasAnsi = text.includes("\u001b[") || text.includes("\u001b]") || text.includes("\u001b_");
+    const hasAnsi = text.includes("\u001b[") ||
+        text.includes("\u001b]") ||
+        text.includes("\u001b_");
     const ellipsis = "…";
     const ellipsisWidth = visibleWidth(ellipsis);
     const limit = Math.max(0, safeWidth - ellipsisWidth);

package/dist/workflow-web-source-extension.d.ts

@@ -0,0 +1,43 @@
+import { type WorkflowWebSecurityPolicy, type WorkflowWebSourceCacheConfig, type WorkflowWebSourcePolicy } from "./workflow-web-source.js";
+export declare const WORKFLOW_WEB_SOURCE_LAUNCH_CONFIG_SCHEMA: "workflow-web-source-launch-config-v1";
+export interface WorkflowWebProviderLaunchConfig {
+    kind: "pi-web-access" | "extension" | "none";
+    extensionPath?: string;
+}
+export interface WorkflowWebSourceLaunchConfig extends WorkflowWebSourceCacheConfig {
+    schema: typeof WORKFLOW_WEB_SOURCE_LAUNCH_CONFIG_SCHEMA;
+    workflowName?: string;
+    stageId?: string;
+    taskKey?: string;
+    cwd: string;
+    provider: WorkflowWebProviderLaunchConfig;
+    webSourcePolicy?: Partial<WorkflowWebSourcePolicy>;
+    securityPolicy?: Partial<WorkflowWebSecurityPolicy>;
+    exposeLegacyTools?: boolean;
+}
+export interface WorkflowWebSourceExtensionWrapperOptions {
+    wrapperPath: string;
+    importPath: string;
+    providerExtensionPath?: string;
+    config: WorkflowWebSourceLaunchConfig;
+}
+type ToolResult = {
+    content?: Array<Record<string, unknown>>;
+    details?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+type ToolSpec = {
+    name?: string;
+    execute?: (toolCallId: string, params: unknown, signal?: AbortSignal, onUpdate?: unknown, ctx?: unknown) => Promise<ToolResult>;
+    [key: string]: unknown;
+};
+type PiLike = Record<string | symbol, unknown> & {
+    registerTool(tool: ToolSpec): void;
+    appendEntry?(type: string, data: unknown): void;
+};
+type ProviderExtension = (pi: PiLike) => void;
+export declare function registerWorkflowWebSourceExtension(pi: PiLike, config: WorkflowWebSourceLaunchConfig, providerExtension?: ProviderExtension): void;
+export declare function buildWorkflowWebSourceExtensionWrapper(options: Omit<WorkflowWebSourceExtensionWrapperOptions, "wrapperPath">): string;
+export declare function writeWorkflowWebSourceExtensionWrapper(options: WorkflowWebSourceExtensionWrapperOptions): Promise<string>;
+export declare function workflowWebSourceModuleImportPath(modulePath: string): string;
+export {};