pi-extensible-workflows 3.3.0 → 3.4.1

package/dist/src/host.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 import { Type } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
 import { copyToClipboard, getAgentDir, SettingsManager, truncateToVisualLines } from "@earendil-works/pi-coding-agent";
-import { createNativeAgentSession, FairAgentScheduler, WorkflowAgentExecutor } from "./agent-execution.js";
+import { FairAgentScheduler, WorkflowAgentExecutor, localAgentTransport } from "./agent-execution.js";
 import { herdrPaneId, openHerdrPane } from "./herdr.js";
 import { acquireSessionLease, listRunIds, RunStore, structuralPath as operationPath } from "./persistence.js";
 import { budgetRelaxed, budgetUsage, mergeBudget, resumeBudgetAllowed, validateBudget, validateBudgetPatch, WorkflowBudgetRuntime } from "./budget.js";
@@ -15,7 +15,7 @@ import { asWorkflowError, aliasDrift, createLaunchSnapshot, deepFreeze, errorCod
 import { launchScriptForSnapshot, loadAgentDefinitions, preflight, resolveAgentResourcePolicy, resolveWorkflowSettings, saveModelAliases, validateAgentOptions, validateCheckpoint, validateModelAliasAvailability, validateShellOptions, validateWorkflowLaunchWithRegistry, workflowProjectSettingsPath, workflowPrompt, workflowSettingsPath } from "./validation.js";
 import { beginWorkflowExtensionLoading, loadingRegistry, resetWorkflowRegistry } from "./registry.js";
 import { agentIdentityPath, agentWorktree, encoded, executeShellCommand, persistActiveAgentAttempt, persistAgentAttempts, readShellResult, runWorkflow, shellIdentityPath } from "./execution.js";
-import { openWorkflowArtifact, workflowResultArtifact, workflowScriptArtifact } from "./workflow-artifacts.js";
+import { openWorkflowArtifact, workflowPromptArtifact, workflowResultArtifact, workflowScriptArtifact } from "./workflow-artifacts.js";
 import { ERROR_CODES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, WORKFLOW_AGENT_STALL_THRESHOLD_MS, WORKFLOW_AGENT_STATE_CHANGED_EVENT, WORKFLOW_BUDGET_EVENT, WORKFLOW_CHECKPOINT_STATE_CHANGED_EVENT, WORKFLOW_PHASE_CHANGED_EVENT, WORKFLOW_RUN_COMPLETED_EVENT, WORKFLOW_RUN_FAILED_EVENT, WORKFLOW_RUN_RESUMED_EVENT, WORKFLOW_RUN_STARTED_EVENT, WORKFLOW_RUN_STATE_CHANGED_EVENT, WORKFLOW_WORKTREE_CREATED_EVENT, WorkflowError } from "./types.js";
 const SETTLED_AGENT_STATES = new Set(["completed", "failed", "cancelled"]);
 const INTERNAL_WORKFLOW_TOOLS = ["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"];
@@ -165,14 +165,14 @@ export class RunLifecycle {
 export function formatWorkflowPreview(args) {
     const explicitName = typeof args.name === "string" && args.name.trim() ? args.name.trim() : undefined;
     const registeredName = typeof args.workflow === "string" && args.workflow.trim() ? args.workflow.trim() : undefined;
-    const name = registeredName ?? explicitName ?? "workflow";
+    const name = explicitName ?? registeredName ?? "workflow";
     if (typeof args.script !== "string" || !args.script.trim())
-        return `workflow ${name}${registeredName ? "\nRegistered function" : ""}`;
+        return `workflow ${name}${registeredName ? `\nRegistered function${explicitName ? `: ${registeredName}` : ""}` : ""}`;
     return [`workflow ${name}`, typeof args.description === "string" && args.description.trim() ? args.description.trim() : ""].filter(Boolean).join("\n");
 }
 export const WORKFLOW_TOOL_LABEL = "Workflow";
-export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline parallel-to-summary path by default";
-export const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow. Prefer a named inline script that fans out independent work with parallel(...), awaits the keyed results before interpolating them into one summarizing agent(...), and returns. Inline launches require an explicit non-empty name; registered function launches reject name and use workflow as the run name. Advanced controls include registered functions, outputSchema, budgets, checkpoints, worktrees, retry/resume, CLI export, and pipelines. Use workflow_retry with an explicit failed run ID; parentRunId only reuses named worktrees. Runs are in the background by default; completion arrives as a follow-up message. Set foreground: true when the caller must wait for the final value. If a foreground call detaches before its result is accepted, its terminal success or failure is promoted to one follow-up message. Foreground results include the completed run ID. Recovery inherits the source launch mode; legacy snapshots without launchMode recover in the background. Set foreground: true or false on workflow_resume/workflow_retry to override it; foreground recovery waits for terminal value and run details, while background recovery returns immediately with a follow-up. Recovery map: agent(..., { retries }) reruns one agent call in the same run for transient failures; workflow_retry({ runId, foreground? }) replays a failed run into a child; workflow_resume({ runId, budget?, foreground? }) continues a budget_exhausted run; parentRunId on a new launch only borrows named worktrees and never replays or resumes.";
+export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline or file-backed parallel-to-summary path by default";
+export const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow. Prefer a named inline script that fans out independent work with parallel(...), awaits the keyed results before interpolating them into one summarizing agent(...), and returns. Inline and file-backed launches require a non-empty name; registered function launches may use name as an optional run label and otherwise use workflow as the run name. Advanced controls include registered functions, outputSchema, budgets, checkpoints, worktrees, retry/resume, CLI export, and pipelines. Use workflow_retry with an explicit failed run ID; parentRunId only reuses named worktrees. Runs are in the background by default; completion arrives as a follow-up message. Set foreground: true when the caller must wait for the final value. If a foreground call detaches before its result is accepted, its terminal success or failure is promoted to one follow-up message. Foreground results include the completed run ID. Recovery inherits the source launch mode; legacy snapshots without launchMode recover in the background. Set foreground: true or false on workflow_resume/workflow_retry to override it; foreground recovery waits for terminal value and run details, while background recovery returns immediately with a follow-up. Recovery map: agent(..., { retries }) reruns one agent call in the same run for transient failures; workflow_retry({ runId, foreground? }) replays a failed run into a child; workflow_resume({ runId, budget?, foreground? }) continues a budget_exhausted run; parentRunId on a new launch only borrows named worktrees and never replays or resumes.";
 function workflowRecoveryGuidance(action, state) {
     if (action === "resume") {
         if (state === "failed")
@@ -196,10 +196,11 @@ function workflowRecoveryGuidance(action, state) {
     return `Only failed workflow runs can be retried; source is ${state}`;
 }
 export const WORKFLOW_TOOL_PARAMETERS = Type.Object({
-    name: Type.Optional(Type.String({ description: "Required non-empty name for the default inline workflow path; invalid for registered function launches" })),
+    name: Type.Optional(Type.String({ description: "Optional run label; required and non-empty for inline or file-backed launches, defaults to the registered function name when omitted" })),
     description: Type.Optional(Type.String({ description: "Optional human-readable workflow description" })),
     script: Type.Optional(Type.String({ description: "Immutable inline workflow source; default to a named script that fans out with parallel(...) and awaits results before passing them to a summarizing agent(...)" })),
-    workflow: Type.Optional(Type.String({ description: "Advanced: registered reusable function as an unqualified name" })),
+    scriptPath: Type.Optional(Type.String({ description: "Path to a JavaScript workflow file, read once at launch and persisted as the inline source" })),
+    workflow: Type.Optional(Type.String({ description: "Advanced: registered reusable function as an unqualified name; name may optionally label the run" })),
     args: Type.Optional(Type.Unknown({ description: "JSON-compatible workflow arguments" })),
     foreground: Type.Optional(Type.Boolean({ description: "Wait for completion instead of the default background launch" })),
     concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 16, description: "Advanced: optional per-run active-agent limit" })),
@@ -549,12 +550,26 @@ function styleForState(map, state, styles) {
 function progressStyleForState(state, styles) { return styleForState(PROGRESS_STATE_STYLE, state, styles); }
 function workflowIconStyle(state, styles) { return styleForState(WORKFLOW_ICON_STYLE, state, styles); }
 function phaseStyleForState(state, styles) { return styleForState(PHASE_STATE_STYLE, state, styles); }
+function formatWorkflowRuntime(durationMs) {
+    const seconds = Math.max(0, Math.floor(durationMs / 1000));
+    if (seconds < 60)
+        return `${String(seconds)}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60)
+        return `${String(minutes)}m${remainingSeconds ? ` ${String(remainingSeconds)}s` : ""}`;
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${String(hours)}h${remainingMinutes ? ` ${String(remainingMinutes)}m` : ""}`;
+}
 export function formatWorkflowProgress(run, spinner = "◇", styles = PLAIN_WORKFLOW_PROGRESS_STYLES, now = Date.now()) {
     const done = run.agents.filter((agent) => SETTLED_AGENT_STATES.has(agent.state)).length;
     const workflowIcon = runStateGlyph(run.state, spinner);
     const iconStyle = workflowIconStyle(run.state, styles);
     const header = styles.bold(styles.accent(`Workflow: ${run.workflowName} (${String(done)}/${String(run.agents.length)} done)`));
-    const lines = [`${iconStyle(workflowIcon)} ${header}`];
+    const state = progressStyleForState(run.state, styles)(`[${run.state}]`);
+    const runtime = run.usage ? ` runtime=${formatWorkflowRuntime(run.usage.durationMs)}` : "";
+    const lines = [`${iconStyle(workflowIcon)} ${header} ${state}${runtime}`];
     const budgetWarning = run.state === "budget_exhausted" || (run.budgetEvents ?? []).some((event) => event.type === "hard_exhausted");
     lines.push(...formatCompactBudgetStatus(run).map((line) => `  ${budgetWarning ? styles.warning(line) : line}`));
     const activeShells = run.activeShells ?? 0;
@@ -586,6 +601,7 @@ function workflowToolUpdate(run) {
     return { content: [{ type: "text", text: formatWorkflowProgress(run) }], details: { runId: run.id, run } };
 }
 const workflowSpinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const WORKFLOW_PROGRESS_REFRESH_MS = 1_000;
 function textBlock(text) {
     return {
         render(width) {
@@ -815,14 +831,41 @@ function themeWorkflowProgressStyles(theme) {
         bold: (text) => typeof theme.bold === "function" ? theme.bold(text) : text,
     };
 }
-function workflowProgressBlock(run, theme) {
+function workflowProgressBlock(run, theme, progress, refresh, invalidate) {
     const styles = themeWorkflowProgressStyles(theme);
+    const currentRun = () => {
+        const displayed = progress?.run ?? run;
+        if (!progress || displayed.state !== "running")
+            return displayed;
+        const durationMs = Math.max(displayed.usage?.durationMs ?? 0, progress.runtimeBaseMs + Date.now() - progress.runtimeStartedAt);
+        return { ...displayed, usage: { ...budgetUsage(displayed.usage), durationMs } };
+    };
     return {
         render(width) {
             const frame = workflowSpinner[Math.floor(Date.now() / 80) % workflowSpinner.length] ?? "◇";
-            return truncateWorkflowProgress(formatWorkflowProgress(run, frame, styles), width);
+            return truncateWorkflowProgress(formatWorkflowProgress(currentRun(), frame, styles), width);
+        },
+        invalidate() {
+            const displayed = currentRun();
+            if (!progress || !refresh || displayed.state !== "running" || !displayed.agents.some((agent) => agent.state === "running"))
+                return;
+            const now = Date.now();
+            if (progress.refresh || now - progress.lastRefreshAt < WORKFLOW_PROGRESS_REFRESH_MS)
+                return;
+            progress.lastRefreshAt = now;
+            const inputRun = progress.inputRun;
+            const pending = refresh().then((next) => {
+                if (next && progress.inputRun === inputRun) {
+                    progress.run = next;
+                    invalidate?.();
+                }
+            }).catch(() => undefined);
+            progress.refresh = pending;
+            void pending.finally(() => {
+                if (progress.refresh === pending)
+                    delete progress.refresh;
+            });
         },
-        invalidate() { },
     };
 }
 export function formatBudgetStatus(run) {
@@ -1014,7 +1057,7 @@ export function formatNavigatorRun(loaded, checkpoints, worktrees, now = Date.no
     for (const checkpoint of checkpoints)
         lines.push(`  ${checkpoint.name}: ${checkpoint.prompt} context=${JSON.stringify(checkpoint.context)}`);
     lines.push(`Worktrees: ${String(worktrees.length)}`);
-    lines.push(`Native Pi transcripts: ${String(run.nativeSessions.length)}`);
+    lines.push(`Agent sessions: ${String(run.agentSessions.length)}`);
     return lines.join("\n");
 }
 export function formatWorkflowPhaseDashboard(run, snapshot, width, selection = {}, styles = PLAIN_WORKFLOW_PROGRESS_STYLES, now = Date.now()) {
@@ -1077,7 +1120,7 @@ export function formatWorkflowPhaseDashboard(run, snapshot, width, selection = {
         if (!agent)
             return [styles.muted("Agent details are unavailable")];
         const byId = new Map(run.agents.map((candidate) => [candidate.id, candidate]));
-        const result = [styles.bold(`Selected agent: ${agentBreadcrumb(agent, byId, true)}`), `State: ${phaseStyle(agent.state)(agent.state)}`, `Structural path: ${agent.structuralPath?.join(" > ") || "(root)"}`, `Model: ${agent.model.provider}/${agent.model.model}${agent.model.thinking ? `:${agent.model.thinking}` : ""}`, `Role: ${agent.role ?? "(none)"}`, `Tools: ${agent.tools.join(", ") || "(none)"}`, `Attempts: ${String(agent.attempts)}`, ...(agent.accounting ? formatAgentAccounting(agent.accounting) : []), ...(selection.actions ? [] : [styles.muted("enter for agent actions")])];
+        const result = [styles.bold(`Selected agent: ${agentBreadcrumb(agent, byId, true)}`), `State: ${phaseStyle(agent.state)(agent.state)}`, `Structural path: ${agent.structuralPath?.join(" > ") || "(root)"}`, `Model: ${agent.model.provider}/${agent.model.model}${agent.model.thinking ? `:${agent.model.thinking}` : ""}`, `Role: ${agent.role ?? "(none)"}`, `Tools: ${agent.tools.join(", ") || "(none)"}`, ...(agent.systemPrompt === undefined ? [] : [`System prompt: ${agent.systemPrompt}`]), `Attempts: ${String(agent.attempts)}`, ...(agent.accounting ? formatAgentAccounting(agent.accounting) : []), ...(selection.actions ? [] : [styles.muted("enter for agent actions")])];
         const error = agent.attemptDetails?.at(-1)?.error;
         if (error)
             result.push(styles.error(`Error: ${error.code}: ${error.message}`));
@@ -1169,8 +1212,8 @@ function boundedWorkflowFailureDiagnostics(value) {
                 ...(value.failedAgent.role ? { role: utf8Prefix(value.failedAgent.role, 128) } : {}),
                 structuralPath: value.failedAgent.structuralPath.slice(0, 8).map((part) => utf8Prefix(part, 128)),
                 attempt: value.failedAgent.attempt,
-                ...(value.failedAgent.sessionId ? { sessionId: utf8Prefix(value.failedAgent.sessionId, 256) } : {}),
-                ...(value.failedAgent.sessionFile ? { sessionFile: utf8Prefix(value.failedAgent.sessionFile, 1024) } : {}),
+                ...(value.failedAgent.transport ? { transport: utf8Prefix(value.failedAgent.transport, 128) } : {}),
+                ...(value.failedAgent.session ? { session: structuredClone(value.failedAgent.session) } : {}),
             } } : {}),
         completedSiblingAgents: (value.completedSiblingAgents ?? []).slice(0, 16).map((agent) => ({
             id: utf8Prefix(agent.id, 128),
@@ -1199,18 +1242,6 @@ function boundedWorkflowFailureDiagnostics(value) {
             bounded = { ...bounded, retry };
             continue;
         }
-        if (bounded.failedAgent?.sessionFile) {
-            const failedAgent = { ...bounded.failedAgent };
-            delete failedAgent.sessionFile;
-            bounded = { ...bounded, failedAgent };
-            continue;
-        }
-        if (bounded.failedAgent?.sessionId) {
-            const failedAgent = { ...bounded.failedAgent };
-            delete failedAgent.sessionId;
-            bounded = { ...bounded, failedAgent };
-            continue;
-        }
         if (Buffer.byteLength(bounded.artifacts.runDirectory) > 256) {
             bounded = { ...bounded, artifacts: { ...bounded.artifacts, runDirectory: utf8Prefix(bounded.artifacts.runDirectory, 256) } };
             continue;
@@ -1283,8 +1314,8 @@ async function createWorkflowFailureDiagnostics(store, metadata, error, run) {
         ...(failedAgentRecord.role ? { role: failedAgentRecord.role } : {}),
         structuralPath: [...(failedAgentRecord.structuralPath ?? [])],
         attempt: Math.max(1, failedAttempt?.attempt ?? failedAgentRecord.attempts),
-        ...(failedAttempt?.sessionId ? { sessionId: failedAttempt.sessionId } : {}),
-        ...(failedAttempt?.sessionFile ? { sessionFile: failedAttempt.sessionFile } : {}),
+        ...(failedAttempt?.transport ? { transport: failedAttempt.transport } : {}),
+        ...(failedAttempt?.session ? { session: failedAttempt.session } : {}),
     } : undefined;
     const completedSiblingAgents = run.agents.filter((agent) => {
         if (agent.state !== "completed" || agent.id === failedAgentRecord?.id)
@@ -1321,7 +1352,7 @@ async function createWorkflowFailureDiagnostics(store, metadata, error, run) {
     });
 }
 export function formatWorkflowFailureDiagnostics(diagnostic) {
-    const failedAgent = diagnostic.failedAgent ? `${diagnostic.failedAgent.label ?? diagnostic.failedAgent.id}${diagnostic.failedAgent.role ? ` role=${diagnostic.failedAgent.role}` : ""} attempt=${String(diagnostic.failedAgent.attempt)} path=${diagnostic.failedAgent.structuralPath.join(" > ") || "(root)"}${diagnostic.failedAgent.sessionFile ? ` session=${diagnostic.failedAgent.sessionFile}` : ""}` : "(not persisted)";
+    const failedAgent = diagnostic.failedAgent ? `${diagnostic.failedAgent.label ?? diagnostic.failedAgent.id}${diagnostic.failedAgent.role ? ` role=${diagnostic.failedAgent.role}` : ""} attempt=${String(diagnostic.failedAgent.attempt)} path=${diagnostic.failedAgent.structuralPath.join(" > ") || "(root)"}${diagnostic.failedAgent.session ? ` session=${diagnostic.failedAgent.session.transport}/${diagnostic.failedAgent.session.sessionId}` : ""}` : "(not persisted)";
     const siblingAgents = diagnostic.completedSiblingAgents;
     const siblings = siblingAgents ? siblingAgents.map((agent) => `${agent.label ?? agent.id}${agent.role ? ` role=${agent.role}` : ""} path=${agent.structuralPath.join(" > ") || "(root)"}`).join(", ") || "(none)" : diagnostic.completedSiblingPaths.map((path) => path.join(" > ") || "(root)").join(", ") || "(none)";
     const retry = diagnostic.retry ? [`  Retry: ${diagnostic.retry.action}`, `  Replayable completed paths: ${diagnostic.retry.completedPaths.join(", ") || "(none)"}`, `  Incomplete paths: ${diagnostic.retry.incompletePaths.join(", ") || "(unknown)"}`, `  Named worktrees: ${diagnostic.retry.namedWorktrees.join(", ") || "(none)"}`, `  Warning: ${diagnostic.retry.warning}`] : [];
@@ -1717,7 +1748,7 @@ function workflowKeyLabel(keybindings, binding, fallback, labels) {
     const vim = WORKFLOW_VIM_KEYS[binding];
     return [...new Set(vim ? [...configured, vim] : configured)].join("/");
 }
-export default function workflowExtension(pi, home, clipboard = copyToClipboard, createSession = createNativeAgentSession, agentDir, additionalSkillPaths = []) {
+export default function workflowExtension(pi, home, clipboard = copyToClipboard, transport = localAgentTransport, agentDir, additionalSkillPaths = []) {
     beginWorkflowExtensionLoading();
     const registry = loadingRegistry();
     const extensionAgentDir = agentDir ?? getAgentDir();
@@ -1773,6 +1804,11 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     const foregroundDeliveries = new Map();
     const liveActivities = new Map();
     const liveEventTimes = new Map();
+    const liveAgentSessions = new Map();
+    const setLiveAgentSession = (runId, agentId, session) => { const key = `${runId}:${agentId}`; if (session)
+        liveAgentSessions.set(key, session);
+    else
+        liveAgentSessions.delete(key); };
     const setLiveActivity = (runId, agentId, activity) => {
         const activities = liveActivities.get(runId);
         if (activity) {
@@ -1980,13 +2016,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const onProgress = async (progress) => {
                 let runState;
                 if (progress.persist) {
-                    runState = await persistRunState(run.store, run.metadata, (current) => current.agents.some((agent) => agent.id === id) ? { ...current, ...run.budget.snapshot(), agents: current.agents.map((agent) => agent.id === id ? { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls, activity: progress.activity, ...(progress.lastEventAt === undefined ? {} : { lastEventAt: progress.lastEventAt }) } : agent) } : current);
+                    runState = await persistRunState(run.store, run.metadata, (current) => current.agents.some((agent) => agent.id === id) ? { ...current, ...run.budget.snapshot(), agents: current.agents.map((agent) => agent.id === id ? { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls, ...(progress.state ? { model: progress.state.model, tools: progress.state.tools, ...(progress.state.systemPrompt === undefined ? {} : { systemPrompt: progress.state.systemPrompt }) } : {}), activity: progress.activity, ...(progress.lastEventAt === undefined ? {} : { lastEventAt: progress.lastEventAt }) } : agent) } : current);
                 }
                 else {
                     const loaded = await run.store.load();
                     if (!loaded.run.agents.some((agent) => agent.id === id))
                         return;
-                    runState = { ...loaded.run, ...run.budget.snapshot(), agents: loaded.run.agents.map((agent) => agent.id === id ? { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls, activity: progress.activity, ...(progress.lastEventAt === undefined ? {} : { lastEventAt: progress.lastEventAt }) } : agent) };
+                    runState = { ...loaded.run, ...run.budget.snapshot(), agents: loaded.run.agents.map((agent) => agent.id === id ? { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls, ...(progress.state ? { model: progress.state.model, tools: progress.state.tools, ...(progress.state.systemPrompt === undefined ? {} : { systemPrompt: progress.state.systemPrompt }) } : {}), activity: progress.activity, ...(progress.lastEventAt === undefined ? {} : { lastEventAt: progress.lastEventAt }) } : agent) };
                 }
                 if (!runState.agents.some((agent) => agent.id === id))
                     return;
@@ -1995,6 +2031,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 run.update?.(workflowToolUpdate(withLiveActivities(runState)));
             };
             const onAttempt = async (attempt) => {
+                setLiveAgentSession(runId, id, attempt.liveSession);
                 await scheduler.flush();
                 scheduler.attemptStarted(id);
                 const lastEventAt = Date.now();
@@ -2014,10 +2051,12 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             await eventPublisher.agentStates(run.store, run.metadata, before.agents, completed.agents);
             const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot() }));
             setLiveActivity(runId, id);
+            setLiveAgentSession(runId, id);
             run.update?.(workflowToolUpdate(withLiveActivities(persisted)));
             return result.value;
         }
         catch (error) {
+            setLiveAgentSession(runId, id);
             const attempts = error.attempts;
             if (attempts?.length) {
                 const before = (await run.store.load()).run;
@@ -2051,7 +2090,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 }
                 const resultPath = !node.parentId && node.options.agentIdentity ? agentIdentityPath(node.options.agentIdentity) : undefined;
                 const lastEventAt = node.state === "running" ? previous?.state === "running" && previous.lastEventAt !== undefined ? previous.lastEventAt : Date.now() : previous?.lastEventAt;
-                return { id: node.id, name: node.label, ...(node.options.requestedLabel ? { label: node.options.requestedLabel } : {}), path: node.id, state: node.state, ...(node.parentId ? { parentId: node.parentId } : {}), structuralPath: [...(node.options.agentIdentity?.structuralPath ?? [])], ...(resultPath ? { resultPath } : {}), ...(node.options.parentBreadcrumb ? { parentBreadcrumb: node.options.parentBreadcrumb } : {}), ...(node.options.worktreeOwner ? { worktreeOwner: node.options.worktreeOwner } : {}), ...(node.options.role ? { role: node.options.role } : {}), ...(effective.requestedModel ? { requestedModel: effective.requestedModel } : {}), model: effective.model, tools: effective.tools, attempts: previous?.attempts ?? 0, ...(previous?.attemptDetails ? { attemptDetails: previous.attemptDetails } : {}), ...(previous?.accounting ? { accounting: previous.accounting } : {}), ...(previous?.toolCalls ? { toolCalls: previous.toolCalls } : {}), ...(previous?.activity ? { activity: previous.activity } : {}), ...(lastEventAt === undefined ? {} : { lastEventAt }) };
+                return { ...(previous?.systemPrompt === undefined ? {} : { systemPrompt: previous.systemPrompt }), ...(node.prompt !== undefined ? { prompt: node.prompt } : previous?.prompt !== undefined ? { prompt: previous.prompt } : {}), id: node.id, name: node.label, ...(node.options.requestedLabel ? { label: node.options.requestedLabel } : {}), path: node.id, state: node.state, ...(node.parentId ? { parentId: node.parentId } : {}), structuralPath: [...(node.options.agentIdentity?.structuralPath ?? [])], ...(resultPath ? { resultPath } : {}), ...(node.options.parentBreadcrumb ? { parentBreadcrumb: node.options.parentBreadcrumb } : {}), ...(node.options.worktreeOwner ? { worktreeOwner: node.options.worktreeOwner } : {}), ...(node.options.role ? { role: node.options.role } : {}), ...(effective.requestedModel ? { requestedModel: effective.requestedModel } : {}), model: effective.model, tools: effective.tools, attempts: previous?.attempts ?? 0, ...(previous?.attemptDetails ? { attemptDetails: previous.attemptDetails } : {}), ...(previous?.accounting ? { accounting: previous.accounting } : {}), ...(previous?.toolCalls ? { toolCalls: previous.toolCalls } : {}), ...(previous?.activity ? { activity: previous.activity } : {}), ...(lastEventAt === undefined ? {} : { lastEventAt }) };
             });
             return { ...current, agents };
         });
@@ -2071,6 +2110,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         run.checkpointResolvers.clear();
         liveActivities.delete(runId);
         liveEventTimes.delete(runId);
+        for (const key of liveAgentSessions.keys())
+            if (key.startsWith(`${runId}:`))
+                liveAgentSessions.delete(key);
         eventPublisher.removeRun(runId);
         runs.delete(runId);
     };
@@ -2232,7 +2274,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         pi.registerTool({
             name: "workflow_catalog",
             label: "Workflow Catalog",
-            description: "List reusable workflow functions, variables, and model aliases, or load one entry in full",
+            description: "List reusable workflow functions, variables, and model aliases; pass `name` to load one entry in full",
             parameters: Type.Object({ name: Type.Optional(Type.String({ description: "Registered function, variable, or model alias name for full detail" })) }, { additionalProperties: false }),
             async execute(_id, params = {}) {
                 const context = { cwd, projectTrusted: trustedProject, globalSettingsPath: workflowSettingsPath(extensionAgentDir) };
@@ -2249,7 +2291,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         });
         catalogRegistered = true;
     };
-    const createAgentExecutor = (root) => new WorkflowAgentExecutor({ ...root, agentDir: extensionAgentDir, ...(additionalSkillPaths.length ? { additionalSkillPaths } : {}), agentSetupHooks: registry.agentSetupHooks() }, createSession);
+    const createAgentExecutor = (root) => new WorkflowAgentExecutor({ ...root, agentDir: extensionAgentDir, ...(additionalSkillPaths.length ? { additionalSkillPaths } : {}), agentSetupHooks: registry.agentSetupHooks() }, transport);
     const activeSnapshotTools = (tools, active) => active === "session"
         ? new Set(tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog"))
         : new Set(tools.filter((tool) => active.has(tool) || tool === "workflow_catalog"));
@@ -2580,7 +2622,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const childBudget = new WorkflowBudgetRuntime(budget, loaded.run.budgetVersion ?? 1, loaded.run.usage, loaded.run.budgetEvents);
             const childInitialBudget = childBudget.snapshot();
             const retry = { sourceRunId: loaded.run.id, lineageRootRunId, completedPaths, incompletePaths, namedWorktrees };
-            await childStore.create({ id: childRunId, workflowName: loaded.snapshot.metadata.name, cwd, sessionId, state: "interrupted", parentRunId: loaded.run.id, retry, agents: [], nativeSessions: [], ...(budget ? { budget } : {}), budgetVersion: loaded.run.budgetVersion ?? 1, ...childInitialBudget }, childSnapshot);
+            await childStore.create({ id: childRunId, workflowName: loaded.snapshot.metadata.name, cwd, sessionId, state: "interrupted", parentRunId: loaded.run.id, retry, agents: [], agentSessions: [], ...(budget ? { budget } : {}), budgetVersion: loaded.run.budgetVersion ?? 1, ...childInitialBudget }, childSnapshot);
             const fallbackModel = { provider: hostModel.provider, model: hostModel.id, thinking: pi.getThinkingLevel() };
             const model = modelSpec(loaded.snapshot.models[0] ?? "", fallbackModel);
             const lifecycle = lifecycleFor(childStore, "interrupted", childBudget, loaded.snapshot.metadata);
@@ -2810,7 +2852,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 } : undefined;
                 const budgetRuntime = new WorkflowBudgetRuntime(budget);
                 const initialBudget = budgetRuntime.snapshot();
-                await store.create({ id: runId, workflowName: checked.metadata.name, cwd: ctx.cwd, sessionId: ctx.sessionManager.getSessionId(), state: "running", ...(parentRunId !== undefined ? { parentRunId } : {}), agents: [], nativeSessions: [], delivery: params.foreground ? { mode: "foreground", state: "attached", toolCallId } : { mode: "background", state: "pending" }, ...(budget ? { budget } : {}), budgetVersion: 1, ...initialBudget }, snapshot);
+                await store.create({ id: runId, workflowName: checked.metadata.name, cwd: ctx.cwd, sessionId: ctx.sessionManager.getSessionId(), state: "running", ...(parentRunId !== undefined ? { parentRunId } : {}), agents: [], agentSessions: [], delivery: params.foreground ? { mode: "foreground", state: "attached", toolCallId } : { mode: "background", state: "pending" }, ...(budget ? { budget } : {}), budgetVersion: 1, ...initialBudget }, snapshot);
                 if (params.foreground)
                     foregroundDeliveries.set(toolCallId, { store, inline: false });
                 const lifecycle = lifecycleFor(store, "running", budgetRuntime, checked.metadata);
@@ -2910,8 +2952,33 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 clearInterval(state.workflowSpinner);
                 delete state.workflowSpinner;
             }
-            if (runDetails?.run)
-                return workflowProgressBlock(runDetails.run, theme);
+            if (runDetails?.run) {
+                const incoming = runDetails.run;
+                let progress = state.workflowProgress;
+                if (!isPartial || !progress || progress.runId !== incoming.id) {
+                    progress = undefined;
+                    delete state.workflowProgress;
+                    if (isPartial) {
+                        progress = { runId: incoming.id, inputRun: incoming, run: incoming, lastRefreshAt: 0, runtimeStartedAt: Date.now(), runtimeBaseMs: incoming.usage?.durationMs ?? 0 };
+                        state.workflowProgress = progress;
+                    }
+                }
+                else if (progress.inputRun !== incoming) {
+                    if (progress.run.state !== "running" && incoming.state === "running") {
+                        progress.runtimeBaseMs = incoming.usage?.durationMs ?? 0;
+                        progress.runtimeStartedAt = Date.now();
+                    }
+                    progress.inputRun = incoming;
+                    progress.run = incoming;
+                }
+                return workflowProgressBlock(progress?.run ?? incoming, theme, progress, async () => {
+                    const active = runs.get(incoming.id);
+                    const store = active?.store ?? new RunStore(incoming.cwd, incoming.sessionId, incoming.id, home);
+                    const loaded = await store.load();
+                    return withLiveActivities(loaded.run);
+                }, () => { if (state.workflowProgress === progress)
+                    context.invalidate(); });
+            }
             const content = result.content[0];
             return textBlock(isPartial ? "Workflow starting..." : runDetails?.preview ?? (content?.type === "text" ? content.text : "Workflow finished"));
         },
@@ -3284,36 +3351,39 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         return { dashboard: formatWorkflowPhaseDashboard(liveRun, loaded.snapshot, process.stdout.columns || 80).join("\n"), phaseModel: buildWorkflowPhaseModel(liveRun, loaded.snapshot), run: liveRun, snapshot: loaded.snapshot, actions, copies, reviews, agentResults, agents: liveRun.agents, worktrees, cwd: liveRun.cwd };
                     };
                     const agentWorktreeFor = (dashboard, agent) => agent.worktreeOwner ? dashboard.worktrees.find((candidate) => candidate.owner === agent.worktreeOwner) : undefined;
+                    const agentAttemptActionContext = (dashboard, agent) => {
+                        const attempt = (agent.attemptDetails ?? []).reduce((latest, candidate) => !latest || candidate.attempt > latest.attempt ? candidate : latest, undefined);
+                        if (!attempt)
+                            return undefined;
+                        const liveCandidate = liveAgentSessions.get(`${dashboard.run.id}:${agent.id}`);
+                        const live = liveCandidate && attempt.session && liveCandidate.reference.transport === attempt.session.transport && liveCandidate.reference.sessionId === attempt.session.sessionId ? liveCandidate : undefined;
+                        const run = runs.get(dashboard.run.id);
+                        const ui = { notify: (message, level = "info") => { ctx.ui.notify(message, level); }, confirm: (title, message) => ctx.ui.confirm(title, message), select: (title, options) => { return ctx.ui.select(title, [...options]); }, input: (title, placeholder) => ctx.ui.input(title, placeholder) };
+                        const attemptSnapshot = deepFreeze(structuredClone(attempt));
+                        return { run: deepFreeze(structuredClone(dashboard.run)), agent: deepFreeze(structuredClone(agent)), attempt: attemptSnapshot, ...(attemptSnapshot.session ? { session: attemptSnapshot.session } : {}), ...(live ? { liveSession: live } : {}), signal: run?.abortController.signal ?? new AbortController().signal, ui: Object.freeze(ui) };
+                    };
+                    const visibleAgentAttemptActions = (dashboard, agent) => {
+                        const context = agentAttemptActionContext(dashboard, agent);
+                        if (!context)
+                            return [];
+                        return Object.entries(registry.agentAttemptActions()).filter(([, action]) => { try {
+                            return action.visible(context);
+                        }
+                        catch {
+                            return false;
+                        } });
+                    };
                     const agentActionLabels = (dashboard, agent) => {
                         const worktree = agentWorktreeFor(dashboard, agent);
                         return [
-                            ...(agent.attemptDetails?.length && herdrPaneId() ? ["Fork as Pi session in pane"] : []),
+                            ...visibleAgentAttemptActions(dashboard, agent).map(([, action]) => action.label),
                             ...(worktree ? ["Copy branch", "Copy worktree path"] : []),
+                            ...(ctx.mode === "tui" && agent.prompt !== undefined ? ["Open prompt in editor"] : []),
                             ...(ctx.mode === "tui" && dashboard.agentResults.has(agent.id) ? ["Open result in editor"] : []),
                             "Copy agent ID",
                             "Back",
                         ];
                     };
-                    const forkAgentSession = async (dashboard, agent) => {
-                        const attempts = [...(agent.attemptDetails ?? [])].sort((left, right) => left.attempt - right.attempt);
-                        const worktree = agentWorktreeFor(dashboard, agent);
-                        const choices = attempts.map((attempt) => `Attempt ${String(attempt.attempt)}`);
-                        const choice = choices.length === 1 ? choices[0] : await ctx.ui.select("Fork attempts", [...choices, "Back"]);
-                        const index = choice ? choices.indexOf(choice) : -1;
-                        const attempt = index >= 0 ? attempts[index] : undefined;
-                        if (!attempt)
-                            return;
-                        const running = !SETTLED_AGENT_STATES.has(agent.state) && attempt.attempt === attempts.at(-1)?.attempt && !attempt.error;
-                        if (running && !await ctx.ui.confirm("Fork running attempt?", "This attempt is still running. The snapshot may end mid-turn and will not receive later updates. It opens read-only to avoid concurrent changes to the workflow agent's working directory. Continue?"))
-                            return;
-                        try {
-                            await openHerdrPane({ action: "fork", cwd: worktree?.cwd ?? attempt.setup?.cwd ?? dashboard.cwd, original: attempt.sessionFile, ...(running ? { readOnly: true } : {}) });
-                            ctx.ui.notify("Forked Pi session in pane.", "info");
-                        }
-                        catch (error) {
-                            ctx.ui.notify(`Cannot fork Pi session in pane: ${error instanceof Error ? error.message : String(error)}`, "warning");
-                        }
-                    };
                     const selectAgent = async (dashboard, requestedAgentId) => {
                         const byId = new Map(dashboard.agents.map((agent) => [agent.id, agent]));
                         const title = (agent) => agentBreadcrumb(agent, byId, true);
@@ -3334,6 +3404,19 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             const action = await ctx.ui.select(title(selected), actions);
                             if (!action || action === "Back")
                                 return;
+                            const extensionAction = visibleAgentAttemptActions(dashboard, selected).find(([, candidate]) => candidate.label === action);
+                            if (extensionAction) {
+                                const context = agentAttemptActionContext(dashboard, selected);
+                                if (context) {
+                                    try {
+                                        await extensionAction[1].run(context);
+                                    }
+                                    catch (error) {
+                                        ctx.ui.notify(`Agent attempt action failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+                                    }
+                                }
+                                return;
+                            }
                             if (action === "Copy agent ID") {
                                 await copyArtifact(selected.id, "agent ID");
                                 continue;
@@ -3346,8 +3429,6 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 await copyArtifact(worktree.path, "worktree path");
                                 continue;
                             }
-                            if (action === "Fork as Pi session in pane")
-                                await forkAgentSession(dashboard, selected);
                         }
                     };
                     for (;;) {
@@ -3491,7 +3572,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                             selectionNeedsScroll = false;
                                         }
                                         dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
-                                        const hint = truncateToVisualLines(theme.fg("dim", actionMode ? `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} actions · ${keyLabel("tui.select.confirm", "enter")} run · ${keyLabel("tui.select.cancel", "esc")} tree` : `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} tree · ${keyLabel("tui.editor.cursorLeft", "←")}/${keyLabel("tui.editor.cursorRight", "→")} collapse/expand · ${keyLabel("tui.select.confirm", "enter")} inspect · a actions · ${keyLabel("tui.select.cancel", "esc")} ${narrow && detailsMode ? "tree" : "back"}${content.length > viewport ? ` · ${keyLabel("tui.select.pageUp", "pgup")}/${keyLabel("tui.select.pageDown", "pgdn")} scroll` : ""} · auto-refresh 1s`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
+                                        const hint = truncateToVisualLines(theme.fg("dim", actionMode ? `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} actions · ${keyLabel("tui.select.confirm", "enter")} run · ${keyLabel("tui.editor.cursorLeft", "←")} tree · ${keyLabel("tui.select.cancel", "esc")} tree` : `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} tree · ${keyLabel("tui.editor.cursorLeft", "←")}/${keyLabel("tui.editor.cursorRight", "→")} collapse/expand · ${keyLabel("tui.select.confirm", "enter")} inspect · a actions · ${keyLabel("tui.select.cancel", "esc")} ${narrow && detailsMode ? "tree" : "back"}${content.length > viewport ? ` · ${keyLabel("tui.select.pageUp", "pgup")}/${keyLabel("tui.select.pageDown", "pgdn")} scroll` : ""} · auto-refresh 1s`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
                                         return [...content.slice(dashboardOffset, dashboardOffset + viewport), ...(hintRows ? [hint] : [])];
                                     },
                                     invalidate() { },
@@ -3508,7 +3589,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                         }
                                         if (actionMode) {
                                             const options = actionOptions();
-                                            if (workflowKeyMatches(keybindings, data, "tui.select.cancel")) {
+                                            if (workflowKeyMatches(keybindings, data, "tui.select.cancel") || workflowKeyMatches(keybindings, data, "tui.editor.cursorLeft")) {
                                                 actionMode = false;
                                                 dashboardOffset = 0;
                                                 tui.requestRender();
@@ -3531,7 +3612,11 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                                 }
                                                 else if (agent) {
                                                     const worktree = agentWorktreeFor(view, agent);
-                                                    if (action === "Open result in editor") {
+                                                    if (action === "Open prompt in editor") {
+                                                        if (agent.prompt !== undefined)
+                                                            void openArtifact(Promise.resolve(workflowPromptArtifact(agent.prompt)), "agent prompt");
+                                                    }
+                                                    else if (action === "Open result in editor") {
                                                         const result = view.agentResults.get(agent.id);
                                                         if (result !== undefined)
                                                             void openArtifact(Promise.resolve(workflowResultArtifact(result)), "agent result");
@@ -3542,8 +3627,14 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                                         void copyArtifact(worktree.branch, "branch");
                                                     else if (action === "Copy worktree path" && worktree)
                                                         void copyArtifact(worktree.path, "worktree path");
-                                                    else
-                                                        done(`__workflow_fork__:${agent.id}`);
+                                                    else {
+                                                        const extensionAction = visibleAgentAttemptActions(view, agent).find(([, candidate]) => candidate.label === action);
+                                                        const actionContext = extensionAction ? agentAttemptActionContext(view, agent) : undefined;
+                                                        if (extensionAction && actionContext) {
+                                                            actionMode = false;
+                                                            void Promise.resolve(extensionAction[1].run(actionContext)).catch((error) => { ctx.ui.notify(`Agent attempt action failed: ${error instanceof Error ? error.message : String(error)}`, "error"); }).finally(() => { void updateDashboard(); });
+                                                        }
+                                                    }
                                                 }
                                                 else if (action === "Open script in editor")
                                                     void openArtifact(readFile(join(store.directory, "workflow.js"), "utf8").then(workflowScriptArtifact), "workflow script");
@@ -3640,13 +3731,6 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             await selectAgent(view, actionChoice.slice("__workflow_agent__:".length));
                             continue;
                         }
-                        if (actionChoice.startsWith("__workflow_fork__:")) {
-                            const agentId = actionChoice.slice("__workflow_fork__:".length);
-                            const agent = view.agents.find((candidate) => candidate.id === agentId);
-                            if (agent)
-                                await forkAgentSession(view, agent);
-                            continue;
-                        }
                         if (actionChoice === "Refresh")
                             continue;
                         const copy = view.copies.get(actionChoice);

package/dist/src/index.d.ts

@@ -9,9 +9,9 @@ export * from "./workflow-artifacts.js";
 export * from "./bundles.js";
 export { default } from "./host.js";
 export { acquireSessionLease, hasLiveSessionLease, listPersistedSessionIds, projectSessionsDirectory, projectStorageKey, RunStore, runsDirectory, SessionLease, structuralPath } from "./persistence.js";
-export type { AwaitingCheckpoint, CompletedOperation, NativeSessionReference, PendingWorkflowDecision, PersistedOwnershipNode, PersistedRun, RunSummary, RunSummaryAgent, RunSummaryArtifacts, WorktreeReference } from "./persistence.js";
-export { FairAgentScheduler, WorkflowAgentExecutor } from "./agent-execution.js";
-export type { AgentAttempt, AgentBudgetHooks, AgentExecutionOptions, AgentExecutionResult, AgentExecutionRoot, AgentProgress, AgentProviderFailure, AgentProviderRecovery, AgentToolCallProgress, AgentSetup, AgentSetupContext, AgentSetupHook, NativeSession, RegisteredAgentSetupHook, SessionFactory, SessionInput } from "./agent-execution.js";
+export type { AwaitingCheckpoint, CompletedOperation, PendingWorkflowDecision, PersistedOwnershipNode, PersistedRun, RunSummary, RunSummaryAgent, RunSummaryArtifacts, WorktreeReference } from "./persistence.js";
+export { FairAgentScheduler, WorkflowAgentExecutor, createLocalWorkflowAgentSession, localAgentTransport } from "./agent-execution.js";
+export type { AgentAttempt, AgentBudgetHooks, AgentExecutionOptions, AgentExecutionResult, AgentExecutionRoot, AgentProgress, AgentProviderFailure, AgentProviderRecovery, AgentToolCallProgress, AgentSetup, AgentSetupContext, AgentSetupHook, AgentTransport, AgentTransportContext, PreparedAgentSession, RegisteredAgentSetupHook, SessionInput, WorkflowAgentMessage, WorkflowAgentSession, WorkflowAgentSessionEvent, WorkflowAgentSessionReference, WorkflowAgentSessionState, WorkflowAgentSessionStats, WorkflowAgentTurnResult } from "./agent-execution.js";
 export { doctor, doctorExitCode, formatDoctorReport } from "./doctor.js";
 export type { DoctorDiagnostic, DoctorFunction, DoctorOptions, DoctorPiState, DoctorReport, DoctorRole, DoctorSeverity, DoctorTrust } from "./doctor.js";
 export { doctorCleanup, doctorCleanupExitCode, formatDoctorCleanupReport } from "./doctor-cleanup.js";

package/dist/src/index.js

@@ -9,6 +9,6 @@ export * from "./workflow-artifacts.js";
 export * from "./bundles.js";
 export { default } from "./host.js";
 export { acquireSessionLease, hasLiveSessionLease, listPersistedSessionIds, projectSessionsDirectory, projectStorageKey, RunStore, runsDirectory, SessionLease, structuralPath } from "./persistence.js";
-export { FairAgentScheduler, WorkflowAgentExecutor } from "./agent-execution.js";
+export { FairAgentScheduler, WorkflowAgentExecutor, createLocalWorkflowAgentSession, localAgentTransport } from "./agent-execution.js";
 export { doctor, doctorExitCode, formatDoctorReport } from "./doctor.js";
 export { doctorCleanup, doctorCleanupExitCode, formatDoctorCleanupReport } from "./doctor-cleanup.js";

package/dist/src/persistence.d.ts

@@ -1,9 +1,5 @@
 import type { BudgetApprovalRequest, JsonValue, LaunchSnapshot, RunRecord, WorkflowBudgetUsage, WorkflowRunEvent } from "./types.js";
 import type { OwnershipRecord } from "./agent-execution.js";
-export interface NativeSessionReference {
-    sessionId: string;
-    sessionFile: string;
-}
 export interface EffectiveSystemPrompt {
     sessionId: string;
     attempt: number;
@@ -11,9 +7,8 @@ export interface EffectiveSystemPrompt {
     sha256: string;
     prompt: string;
 }
-export interface PersistedRun extends RunRecord {
-    nativeSessions: readonly NativeSessionReference[];
-}
+export type PersistedRun = RunRecord;
+type LoadedPersistedRun = PersistedRun;
 export interface RunSummaryAgent {
     id: string;
     name: string;
@@ -110,7 +105,7 @@ export declare class RunStore {
     private refreshSummaryBestEffort;
     isComplete(): Promise<boolean>;
     load(): Promise<{
-        run: PersistedRun;
+        run: LoadedPersistedRun;
         snapshot: Readonly<LaunchSnapshot>;
     }>;
     loadSummary(): Promise<RunSummary>;
@@ -170,3 +165,4 @@ export declare class RunStore {
     saveResult(value: JsonValue): Promise<string>;
     delete(confirmed: boolean): Promise<void>;
 }
+export {};

package/dist/src/persistence.js

@@ -321,6 +321,9 @@ export class RunStore {
         const run = await json(join(this.directory, "state.json"));
         if (resolve(run.cwd) !== this.cwd || run.sessionId !== this.sessionId || run.id !== this.runId)
             throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted run belongs to another cwd or Pi session");
+        const persisted = run;
+        if (!Array.isArray(persisted.agentSessions) || Object.hasOwn(persisted, "nativeSessions"))
+            throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted run uses an unsupported agent session format");
         return { run, snapshot: loadLaunchSnapshot(await json(join(this.directory, "snapshot.json"))) };
     }
     async loadSummary() {

package/dist/src/registry.d.ts

@@ -1,4 +1,4 @@
-import type { JsonValue, RegisteredAgentSetupHook, WorkflowCatalog, WorkflowCatalogContext, WorkflowCatalogError, WorkflowCatalogFunction, WorkflowCatalogIndex, WorkflowCatalogModelAlias, WorkflowCatalogVariable, WorkflowExtension, WorkflowFunction, WorkflowFunctionContext, WorkflowJournal, WorkflowModelAlias, WorkflowModelAliasResolverContext, WorkflowRoleDirectoryRegistration, WorkflowVariable } from "./types.js";
+import type { AgentAttemptAction, JsonValue, RegisteredAgentSetupHook, WorkflowCatalog, WorkflowCatalogContext, WorkflowCatalogError, WorkflowCatalogFunction, WorkflowCatalogIndex, WorkflowCatalogModelAlias, WorkflowCatalogVariable, WorkflowExtension, WorkflowFunction, WorkflowFunctionContext, WorkflowJournal, WorkflowModelAlias, WorkflowModelAliasResolverContext, WorkflowRoleDirectoryRegistration, WorkflowVariable } from "./types.js";
 export declare class WorkflowRegistry {
     #private;
     get frozen(): boolean;
@@ -18,6 +18,7 @@ export declare class WorkflowRegistry {
         variable: WorkflowVariable;
     }[];
     agentSetupHooks(): readonly RegisteredAgentSetupHook[];
+    agentAttemptActions(): Readonly<Record<string, AgentAttemptAction>>;
     roleDirectories(): readonly string[];
     roleDirectoryRegistrations(): readonly WorkflowRoleDirectoryRegistration[];
     modelAliases(): readonly {
@@ -29,7 +30,7 @@ export declare class WorkflowRegistry {
     }[];
     resolveModelAliases(context: Readonly<WorkflowModelAliasResolverContext>, shadowed?: ReadonlySet<string>): Promise<Readonly<Record<string, string>>>;
 }
-export type WorkflowRegistryApi = Pick<WorkflowRegistry, "frozen" | "freeze" | "register" | "function" | "functions" | "catalog" | "catalogIndex" | "catalogDetail" | "globals" | "invokeFunction" | "variables" | "modelAliases" | "resolveModelAliases" | "agentSetupHooks" | "roleDirectories" | "roleDirectoryRegistrations">;
+export type WorkflowRegistryApi = Pick<WorkflowRegistry, "frozen" | "freeze" | "register" | "function" | "functions" | "catalog" | "catalogIndex" | "catalogDetail" | "globals" | "invokeFunction" | "variables" | "modelAliases" | "resolveModelAliases" | "agentSetupHooks" | "agentAttemptActions" | "roleDirectories" | "roleDirectoryRegistrations">;
 export declare function resetWorkflowRegistry(): void;
 export declare function beginWorkflowExtensionLoading(): void;
 export declare function loadingRegistry(): WorkflowRegistryApi;