@marcoscale98/pi-extensible-workflows 5.14.1-fork.1 → 5.19.1-fork.1

package/dist/src/background-widget.js

@@ -25,7 +25,7 @@ const ENTRY_TYPE = "piewf-run-receipt";
  * Repaint interval. Fast enough that the spinner reads as motion rather than a
  * stutter; the underlying data is only re-read when an event says it changed.
  */
-const REPAINT_MS = 125;
+export const REPAINT_MS = 125;
 /**
  * Filesystem rescan interval. Shell-only activity has no event, but it does not
  * need to be polled at the animation cadence.
@@ -51,7 +51,7 @@ const MAX_ROWS = 10;
  * of thinking and far shorter than the ten minutes it takes to be declared
  * stalled.
  */
-const QUIET_MS = 3 * 60 * 1000;
+export const QUIET_MS = 3 * 60 * 1000;
 /** The core's own threshold for calling an agent stalled outright. */
 const STALL_MS = WORKFLOW_AGENT_STALL_THRESHOLD_MS;
 /**
@@ -130,7 +130,7 @@ function spinner(now) {
     return SPINNER[Math.floor(now / REPAINT_MS) % SPINNER.length] ?? SPINNER[0];
 }
 /** Status mark for a finished-or-running unit of work. */
-function mark(state, now, paint, runState) {
+export function mark(state, now, paint, runState) {
     if (state === "running" && (runState === undefined || runState === "running"))
         return paint(ROLE.live, spinner(now));
     if (state === "completed")
@@ -139,7 +139,7 @@ function mark(state, now, paint, runState) {
         return paint(ROLE.failed, "✗");
     return paint(ROLE.quiet, "·");
 }
-function formatElapsed(ms) {
+export function formatElapsed(ms) {
     const total = Math.max(0, Math.floor(ms / 1000));
     const minutes = Math.floor(total / 60);
     const seconds = total % 60;
@@ -576,13 +576,6 @@ function renderFrame(runs, now, width, offset = 0, theme, scrolling = false, siz
     const title = live.length === 1 ? "Workflow" : `Workflows · ${String(live.length)} runs`;
     sizeOut.rows = rows.length;
     const body = collapse(rows, MAX_ROWS - 2, paint, offset, scrolling);
-    // Width budget: the rule takes a column and a space on each side, so the
-    // text has four fewer than the widget is given. Every piece is measured
-    // against `inner` so the right-hand rule lands in one column on every row.
-    const inner = Math.max(20, width - 4);
-    // Side rules below the lid, and no floor: the box opens downward into the
-    // editor rather than closing on itself, which is one more line kept for the
-    // run.
     // A scrollbar on the right rule, drawn only when there is more tree than
     // frame. Without it the window's position is a guess: three rows of a
     // twenty-row tree look the same near the top as near the bottom.
@@ -610,6 +603,25 @@ function renderFrame(runs, now, width, offset = 0, theme, scrolling = false, siz
         const top = limit === 0 ? 0 : start >= limit ? shown - size : Math.floor((start / limit) * (shown - size));
         return index >= top && index < top + size ? "█" : "░";
     };
+    // Only advertise navigation when it can reveal hidden rows: a hint for keys
+    // that do nothing is worse than no hint.
+    const hint = !__navigationForTests.enabled || maxOffset(total, MAX_ROWS - 2) === 0
+        ? ""
+        : scrolling ? "↑/↓ to scroll · Esc to exit" : "Alt+O to scroll";
+    return drawFrame(title, hint, body, width, paint, accent, scrollbar);
+}
+/**
+ * The box around the live rows, shared with the subagent widget so both sit
+ * under the editor in one style.
+ */
+export function drawFrame(title, hint, body, width, paint, accent, scrollbar = () => undefined) {
+    // Width budget: the rule takes a column and a space on each side, so the
+    // text has four fewer than the widget is given. Every piece is measured
+    // against `inner` so the right-hand rule lands in one column on every row.
+    const inner = Math.max(20, width - 4);
+    // Side rules below the lid, and no floor: the box opens downward into the
+    // editor rather than closing on itself, which is one more line kept for the
+    // run.
     const lines = body.map((row, index) => {
         // The numbers hold the right edge; the name gives way when the two would
         // meet. A truncated workflow name is still recognisable, where a truncated
@@ -630,11 +642,6 @@ function renderFrame(runs, now, width, offset = 0, theme, scrolling = false, siz
     // rather than sitting under a separate run of dashes. In ten rows a line
     // spent on decoration is a line not spent on the run, and the box still
     // reads as closed at the top.
-    // Only advertise navigation when it can reveal hidden rows: a hint for keys
-    // that do nothing is worse than no hint.
-    const hint = !__navigationForTests.enabled || maxOffset(total, MAX_ROWS - 2) === 0
-        ? ""
-        : scrolling ? "↑/↓ to scroll · Esc to exit" : "Alt+O to scroll";
     const label = ` ${title} `;
     const tail = hint === "" ? "" : ` ${hint} `;
     const spare = inner + 2 - visibleLength(label) - visibleLength(tail);

package/dist/src/decoders.js

@@ -109,9 +109,10 @@ export function decodeWorkflowExtensions(value) {
             continue;
         }
         if (namespace === "trajectory") {
+            // Snapshots persisted before the themes setting was removed still carry a boolean `themes`; it is accepted and dropped.
             if (!object(raw) || Object.keys(raw).some((key) => key !== "port" && key !== "themes") || raw.port !== undefined && (typeof raw.port !== "number" || !Number.isSafeInteger(raw.port) || raw.port < 1 || raw.port > 65535) || raw.themes !== undefined && typeof raw.themes !== "boolean")
                 return undefined;
-            normalized.trajectory = { ...(raw.port === undefined ? {} : { port: raw.port }), ...(raw.themes === undefined ? {} : { themes: raw.themes }) };
+            normalized.trajectory = { ...(raw.port === undefined ? {} : { port: raw.port }) };
             continue;
         }
         if (!jsonValue(raw))
@@ -433,6 +434,28 @@ function decodeRunEvent(value) {
         return undefined;
     return { type: value.type, message: value.message, ...(timestamp === undefined ? {} : { timestamp }) };
 }
+function decodeScriptCall(value) {
+    if (!object(value) || value.kind !== "shell" && value.kind !== "tool" || typeof value.name !== "string" || typeof value.path !== "string" || !finiteNumber(value.startedAt))
+        return undefined;
+    const shell = value.kind === "shell";
+    if (shell && !jsonValue(value.input))
+        return undefined;
+    const inputBytes = shell ? optionalNumber(value.inputBytes) : undefined;
+    const phase = optionalString(value.phase);
+    const finishedAt = optionalNumber(value.finishedAt);
+    let error;
+    if (value.error !== undefined) {
+        if (shell)
+            error = decodeWorkflowError(value.error);
+        else if (object(value.error) && typeof value.error.code === "string")
+            error = { code: isWorkflowErrorCode(value.error.code) ? value.error.code : "INTERNAL_ERROR" };
+        if (!error)
+            return undefined;
+    }
+    if (inputBytes === INVALID_PERSISTED_VALUE || phase === INVALID_PERSISTED_VALUE || finishedAt === INVALID_PERSISTED_VALUE)
+        return undefined;
+    return { kind: value.kind, name: value.name, path: value.path, ...(shell && jsonValue(value.input) ? { input: value.input } : {}), ...(inputBytes === undefined ? {} : { inputBytes }), ...(phase === undefined ? {} : { phase }), startedAt: value.startedAt, ...(finishedAt === undefined ? {} : { finishedAt }), ...(error === undefined ? {} : { error }) };
+}
 function decodeDelivery(value) {
     if (!object(value))
         return undefined;
@@ -466,6 +489,9 @@ export function decodePersistedRun(value, allowLegacyAgentSessions = false) {
     const budgetEvents = value.budgetEvents === undefined ? undefined : decodeArray(value.budgetEvents, decodeBudgetEvent);
     const events = value.events === undefined ? undefined : decodeArray(value.events, decodeRunEvent);
     const delivery = value.delivery === undefined ? undefined : decodeDelivery(value.delivery);
+    const scriptCalls = value.scriptCalls === undefined ? undefined : decodeArray(value.scriptCalls, decodeScriptCall);
+    if (value.scriptCalls !== undefined && !scriptCalls)
+        return undefined;
     if (!agentSessions || !agents || parentRunId === INVALID_PERSISTED_VALUE || value.retry !== undefined && !retry || phase === INVALID_PERSISTED_VALUE || value.phaseHistory !== undefined && !phaseHistory || phaseHistoryIndex === INVALID_PERSISTED_VALUE || activeShells === INVALID_PERSISTED_VALUE || activeShellStartedAt === INVALID_PERSISTED_VALUE || value.activeShellsByPhase !== undefined && !activeShellsByPhase || value.error !== undefined && !error || failedAt === INVALID_PERSISTED_VALUE || value.budget !== undefined && !budget || budgetVersion === INVALID_PERSISTED_VALUE || value.budgetVersion !== undefined && !integer(budgetVersion) || value.usage !== undefined && !usage || value.budgetEvents !== undefined && !budgetEvents || value.events !== undefined && !events || value.delivery !== undefined && !delivery)
         return undefined;
     if (value.agentSessions === undefined && !allowLegacyAgentSessions)
@@ -486,6 +512,7 @@ export function decodePersistedRun(value, allowLegacyAgentSessions = false) {
         ...(activeShells === undefined ? {} : { activeShells }),
         ...(activeShellStartedAt === undefined ? {} : { activeShellStartedAt }),
         ...(activeShellsByPhase === undefined ? {} : { activeShellsByPhase }),
+        ...(scriptCalls === undefined ? {} : { scriptCalls }),
         ...(error === undefined ? {} : { error }),
         ...(failedAt === undefined ? {} : { failedAt }),
         ...(budget === undefined ? {} : { budget }),

package/dist/src/execution.d.ts

@@ -1,10 +1,12 @@
 import { RunStore } from "./persistence.js";
 import type { AgentAttempt } from "./agent-execution.js";
-import type { AgentIdentity, JsonValue, ShellIdentity, ShellOptions, ShellResult, WorkflowBridge, WorkflowExecution } from "./types.js";
+import type { AgentIdentity, JsonValue, ShellIdentity, ShellOptions, ShellResult, ToolIdentity, WorkflowBridge, WorkflowExecution } from "./types.js";
 export declare const RPC_LIMIT_BYTES: number;
 export declare const HEARTBEAT_TIMEOUT_MS = 5000;
 export declare function encoded(value: JsonValue): string;
 export declare function encoded(value: unknown): asserts value is JsonValue;
+/** The journal path of a script tool call; the arguments' digest keeps calls with different arguments apart whatever order they start in. */
+export declare function toolIdentityPath(identifier: string, args: JsonValue, identity: ToolIdentity): string;
 export declare function agentHandleTurnPath(handle: string, turn: number): string;
 export declare function agentIdentityPath(identity: AgentIdentity): string;
 export declare function shellIdentityPath(identity: ShellIdentity): string;
@@ -16,4 +18,4 @@ export declare function executeShellCommand(command: string, options: ShellOptio
 export declare function runWorkflow(script: string, args?: JsonValue, bridge?: WorkflowBridge, signal?: AbortSignal): WorkflowExecution;
 export declare function persistActiveAgentAttempt(store: RunStore, id: string, active: AgentAttempt): Promise<void>;
 export declare function persistAgentAttempts(store: RunStore, id: string, attempts: readonly AgentAttempt[]): Promise<void>;
-export type { AgentIdentity, FunctionIdentity, ShellIdentity, WorkflowBridge, WorkflowExecution } from "./types.js";
+export type { AgentIdentity, FunctionIdentity, ShellIdentity, ToolIdentity, WorkflowBridge, WorkflowExecution } from "./types.js";

package/dist/src/execution.js

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { structuralPath as operationPath } from "./persistence.js";
 import { WorkflowError, roleNameOf, sumAccounting, zeroAccounting } from "./types.js";
-import { asWorkflowError, errorText, fail, isWorkflowAuthored, isWorkflowErrorCode, jsonValue, markWorkflowAuthored, object, positiveInteger } from "./utils.js";
+import { asWorkflowError, errorText, fail, isWorkflowAuthored, isWorkflowErrorCode, jsonDigest, jsonValue, markWorkflowAuthored, object, positiveInteger } from "./utils.js";
 import { instrumentWorkflow, validateAgentOptions, validateShellCommand, validateShellOptions } from "./validation.js";
 export const RPC_LIMIT_BYTES = 10 * 1024 * 1024;
 export const HEARTBEAT_TIMEOUT_MS = 5000;
@@ -268,6 +268,30 @@ const functions = Object.freeze(Object.fromEntries(Object.entries(config.functio
   Object.defineProperty(result, "toJSON", { value() { throw workError("INVALID_METADATA", "Workflow function result is a Promise; await it before serialization"); } });
   return result;
 }])));
+// tools.<id>(args) runs a Pi session tool through the host. Any identifier resolves, so a resumed run
+// replays journaled calls even when the tool is gone; the host rejects identifiers it cannot call.
+// A call is the n-th call with the same arguments in its scope, so replay does not depend on the
+// order in which concurrent calls start.
+const NOT_TOOLS = new Set(["then", "toJSON", "toString", "valueOf", "constructor"]);
+const sortedJson = value => Array.isArray(value) ? value.map(sortedJson) : value && typeof value === "object" ? Object.fromEntries(Object.keys(value).sort().map(key => [key, sortedJson(value[key])])) : value;
+const toolOccurrences = new Map();
+const toolCall = id => (...values) => {
+  if (worktreeOwners.getStore()) throw workError("INVALID_METADATA", "tools." + id + " is unavailable inside withWorktree: session tools resolve paths against the session working directory");
+  if (values.length > 1 || values[0] !== undefined && (!values[0] || typeof values[0] !== "object" || Array.isArray(values[0]))) throw workError("INVALID_METADATA", "tools." + id + " takes one arguments object");
+  const args = values[0] === undefined ? {} : values[0];
+  const structuralPath = inheritedAgentPath.getStore() || [];
+  const key = JSON.stringify([structuralPath, id, sortedJson(args)]);
+  const occurrence = (toolOccurrences.get(key) || 0) + 1;
+  toolOccurrences.set(key, occurrence);
+  return guardedResult(rpc("tool", [id, args, { structuralPath: [...structuralPath], occurrence }]), "tool");
+};
+const tools = new Proxy(Object.create(null), {
+  get: (_target, key) => typeof key === "string" && !NOT_TOOLS.has(key) ? toolCall(key) : undefined,
+  // Probing would branch on the session that resumed the run; the launch already checks named tools.
+  has: () => { throw workError("INVALID_METADATA", "Workflow scripts cannot probe tools with 'in'; call tools.<name>(...) directly, and the launch checks that the tool exists"); },
+  set: () => false,
+  defineProperty: () => false,
+});
 const recordEntries = (value, kind) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw workError("INVALID_METADATA", kind + " must be a record");
   return Object.entries(value);
@@ -328,7 +352,7 @@ const pipeline = async (operationName, items, stages) => {
   return Object.fromEntries(results.map(result => [result.name, result.value]));
 };
 const safeMath = Object.fromEntries(Object.getOwnPropertyNames(Math).filter(name => name !== "random").map(name => [name, Math[name]]));
-const sandbox = { agent, shell, withWorktree: rejectWorktree, prompt, checkpoint, parallel, pipeline, phase, log, args: config.args, Promise, JSON, Math: Object.freeze(safeMath) };
+const sandbox = { agent, shell, withWorktree: rejectWorktree, prompt, checkpoint, parallel, pipeline, phase, log, tools, args: config.args, Promise, JSON, Math: Object.freeze(safeMath) };
 for (const [name, fn] of Object.entries(functions)) Object.defineProperty(sandbox, name, { value: fn, writable: false, configurable: false });
 for (const name of ["Date","eval","Function","WebAssembly","process","require","module","exports","console","fetch","XMLHttpRequest","WebSocket","performance","crypto","setTimeout","setInterval","setImmediate","queueMicrotask","Intl","SharedArrayBuffer","Atomics"]) sandbox[name] = undefined;
 const context = vm.createContext(sandbox, { codeGeneration: { strings: false, wasm: false } });
@@ -378,6 +402,15 @@ function readShellIdentity(value) {
     const identity = readAgentIdentity(value);
     return { structuralPath: identity.structuralPath, callSite: identity.callSite, occurrence: identity.occurrence, ...(identity.worktreeOwner ? { worktreeOwner: identity.worktreeOwner } : {}) };
 }
+function readToolIdentity(value) {
+    if (!object(value) || !Array.isArray(value.structuralPath) || !value.structuralPath.every((part) => typeof part === "string" && Boolean(part.trim())) || !positiveInteger(value.occurrence))
+        fail("INTERNAL_ERROR", "Invalid workflow tool identity");
+    return { structuralPath: [...value.structuralPath], occurrence: value.occurrence };
+}
+/** The journal path of a script tool call; the arguments' digest keeps calls with different arguments apart whatever order they start in. */
+export function toolIdentityPath(identifier, args, identity) {
+    return operationPath("tool", ...identity.structuralPath, identifier, `args:${jsonDigest(args)}`, String(identity.occurrence));
+}
 export function agentHandleTurnPath(handle, turn) {
     return operationPath("agent", "handle", handle, `turn:${String(turn)}`);
 }
@@ -681,6 +714,14 @@ export function runWorkflow(script, args = null, bridge = {}, signal) {
                     value = branded({ name, ok: false, failedAt: name, error: workerErrorShape(typed) });
                 }
             }
+            else if (method === "tool") {
+                if (typeof values[0] !== "string" || !object(values[1]))
+                    fail("INTERNAL_ERROR", "tool requires an identifier and object arguments");
+                const identity = readToolIdentity(values[2]);
+                if (!bridge.tool)
+                    fail("UNKNOWN_TOOL", `tools.${values[0]} is unavailable: this run has no session tools`);
+                value = await bridge.tool(values[0], values[1], controller.signal, identity);
+            }
             else if (method === "worktree") {
                 if (!bridge.worktree || typeof values[0] !== "string" || !values[0])
                     fail("INTERNAL_ERROR", "worktree requires an active host bridge and scope");

package/dist/src/host-delivery.js

@@ -108,6 +108,7 @@ const WORKFLOW_ERROR_PROSE = {
     RUN_NOT_FOUND: (detail) => /^Unknown workflow run\b/.test(detail) ? "The workflow run was not found." : `The workflow run was not found: ${detail}.`,
     RPC_LIMIT_EXCEEDED: (detail) => `The workflow communication data exceeded its size limit: ${detail}.`,
     SHELL_FAILED: (detail) => `The workflow shell command failed: ${detail}.`,
+    TOOL_FAILED: (detail) => `The workflow tool call failed: ${detail}.`,
     AGENT_TIMEOUT: (detail) => `The workflow agent timed out: ${detail}.`,
     AGENT_FAILED: (detail) => `The workflow agent failed: ${detail}.`,
     AGENT_RESULT_COLLECTED: (detail) => `The nested agent result was already collected: ${detail}.`,

package/dist/src/host-navigator.d.ts

@@ -1,6 +1,7 @@
 import { type ExtensionUIContext, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { RunStore, type PersistedRun } from "./persistence.js";
 import { type WorkflowRegistryApi } from "./registry.js";
+import { type WorkflowProgressStyles } from "./host-view.js";
 import { type WorkflowRecoveryContext, type createWorkflowRecovery } from "./host-recovery.js";
 import { type WorkflowRunRecord } from "./host-runtime.js";
 import { type TrajectoryPublisherProvider } from "./trajectory-host-handle.js";
@@ -34,6 +35,23 @@ export type UiHostCapabilities = {
 };
 type ReportBlocked = (active: boolean, label?: string) => void;
 export declare function uiHostCapabilities(ui: unknown): UiHostCapabilities | undefined;
+type WorkflowKeybindings = {
+    matches(data: string, binding: string): boolean;
+};
+export declare function workflowKeyMatches(keybindings: WorkflowKeybindings, data: string, binding: string): boolean;
+export declare function workflowKeyLabel(keybindings: unknown, binding: string, fallback: string, labels?: Readonly<Record<string, string>>): string;
+/**
+ * A yes/no question drawn inside a navigator dashboard. Pi's confirm dialog replaces a custom component and afterwards
+ * restores the editor rather than the component, which leaves the dashboard's promise pending and the session waiting on it.
+ */
+export declare function createInlineConfirm(requestRender: () => void): {
+    ask(title: string, message: string): Promise<boolean>;
+    active(): boolean;
+    rows(width: number, styles: WorkflowProgressStyles): string[];
+    hint(keybindings: unknown): string;
+    handleInput(keybindings: WorkflowKeybindings, data: string): void;
+    cancel(): void;
+};
 export type WorkflowNavigatorDependencies = {
     pi: Pick<ExtensionAPI, "registerCommand">;
     home: string | undefined;

package/dist/src/host-navigator.js

@@ -110,13 +110,57 @@ function keybindingKeys(keybindings, name) {
     return isKeybindingGetKeys(getKeys) ? getKeys.call(keybindings, name) : undefined;
 }
 const WORKFLOW_VIM_KEYS = { "tui.select.up": "k", "tui.select.down": "j", "tui.editor.cursorLeft": "h", "tui.editor.cursorRight": "l" };
-function workflowKeyMatches(keybindings, data, binding) { return keybindings.matches(data, binding) || WORKFLOW_VIM_KEYS[binding] === data; }
-function workflowKeyLabel(keybindings, binding, fallback, labels) {
+export function workflowKeyMatches(keybindings, data, binding) { return keybindings.matches(data, binding) || WORKFLOW_VIM_KEYS[binding] === data; }
+const WORKFLOW_KEY_LABELS = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
+export function workflowKeyLabel(keybindings, binding, fallback, labels = WORKFLOW_KEY_LABELS) {
     const keys = keybindingKeys(keybindings, binding);
     const configured = keys?.length ? keys.map((key) => labels[key] ?? key) : [fallback];
     const vim = WORKFLOW_VIM_KEYS[binding];
     return [...new Set(vim ? [...configured, vim] : configured)].join("/");
 }
+/**
+ * A yes/no question drawn inside a navigator dashboard. Pi's confirm dialog replaces a custom component and afterwards
+ * restores the editor rather than the component, which leaves the dashboard's promise pending and the session waiting on it.
+ */
+export function createInlineConfirm(requestRender) {
+    let pending;
+    const answer = (value) => {
+        const current = pending;
+        pending = undefined;
+        current?.resolve(value);
+        requestRender();
+    };
+    return {
+        ask(title, message) {
+            answer(false);
+            return new Promise((resolve) => { pending = { title, message, yes: true, resolve }; requestRender(); });
+        },
+        active() { return pending !== undefined; },
+        rows(width, styles) {
+            if (!pending)
+                return [];
+            const yes = pending.yes;
+            const message = truncateToVisualLines(pending.message, Number.MAX_SAFE_INTEGER, Math.max(1, width), 0).visualLines.map((line) => line.trimEnd());
+            return [styles.bold(pending.title), ...message, ...["Yes", "No"].map((option) => (option === "Yes") === yes ? `→ ${styles.accent(option)}` : `  ${option}`)];
+        },
+        hint(keybindings) {
+            return `${workflowKeyLabel(keybindings, "tui.select.up", "↑")}/${workflowKeyLabel(keybindings, "tui.select.down", "↓")} select · ${workflowKeyLabel(keybindings, "tui.select.confirm", "enter")} confirm · ${workflowKeyLabel(keybindings, "tui.select.cancel", "esc")} cancel`;
+        },
+        handleInput(keybindings, data) {
+            if (!pending)
+                return;
+            if (workflowKeyMatches(keybindings, data, "tui.select.up") || workflowKeyMatches(keybindings, data, "tui.select.down")) {
+                pending.yes = !pending.yes;
+                requestRender();
+            }
+            else if (workflowKeyMatches(keybindings, data, "tui.select.confirm"))
+                answer(pending.yes);
+            else if (workflowKeyMatches(keybindings, data, "tui.select.cancel"))
+                answer(false);
+        },
+        cancel() { answer(false); },
+    };
+}
 export function registerWorkflowNavigator(deps) {
     const { pi, home, clipboard, extensionAgentDir, runs, terminalRunStates, hardTerminalRunStates, ensureSessionLease, answerCheckpoint, recovery, stopWorkflowRun, moveForegroundToBackground, isForegroundAttached, liveAgents, registry, projectTrusted, resumeHostContext, resumeSelectedWorkflow, reportBlocked, setNavigatorOpen, trajectoryProvider, coordinateRunMutation: coordinateRunMutationDependency } = deps;
     const coordinateRunMutation = coordinateRunMutationDependency ?? ((task) => task());
@@ -160,7 +204,7 @@ export function registerWorkflowNavigator(deps) {
                 const setStatus = uiHostCapabilities(ctx.ui)?.setStatus;
                 setStatus?.call(ctx.ui, "workflow-stop", text);
             };
-            const runAction = async (actionCommand, status = setWorkflowStatus) => {
+            const runAction = async (actionCommand, status = setWorkflowStatus, confirm = (title, message) => confirmWithBlocked(ctx.ui, reportBlocked, title, message)) => {
                 const [action, runId, ...rest] = actionCommand.split(/\s+/);
                 try {
                     const run = runId ? runs.get(runId) : undefined;
@@ -252,7 +296,7 @@ export function registerWorkflowNavigator(deps) {
                     }
                     if (action === "stop" && run) {
                         const workflowName = stored?.loaded.run.workflowName ?? run.metadata.name;
-                        if (!await confirmWithBlocked(ctx.ui, reportBlocked, "Stop workflow?", `Stop workflow ${workflowName} (${run.store.runId})? This cannot be undone.`))
+                        if (!await confirm("Stop workflow?", `Stop workflow ${workflowName} (${run.store.runId})? This cannot be undone.`))
                             return "dashboard";
                         status(`Stopping workflow ${workflowName}...`);
                         await stopWorkflowRun(run.store.runId);
@@ -651,8 +695,18 @@ export function registerWorkflowNavigator(deps) {
                                 let selectedNodeId = tree.nodes[0]?.id;
                                 let expandedNodeIds = new Set(workflowPhaseTreeInitialExpanded(tree));
                                 const terminalRows = () => Math.max(1, tuiRows(tui) - WORKFLOW_PANEL_FOOTER_ROWS);
-                                const keyLabels = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
-                                const keyLabel = (binding, fallback) => workflowKeyLabel(keybindings, binding, fallback, keyLabels);
+                                const keyLabel = (binding, fallback) => workflowKeyLabel(keybindings, binding, fallback);
+                                const inlineConfirm = createInlineConfirm(() => { if (!disposed)
+                                    tui.requestRender(); });
+                                const confirmInDashboard = async (title, message) => {
+                                    reportBlocked?.(true, title);
+                                    try {
+                                        return await inlineConfirm.ask(title, message);
+                                    }
+                                    finally {
+                                        reportBlocked?.(false);
+                                    }
+                                };
                                 const progressNow = () => {
                                     const now = Date.now();
                                     if (hardTerminalRunStates.has(view.run.state)) {
@@ -738,7 +792,7 @@ export function registerWorkflowNavigator(deps) {
                                         setWorkflowStatus(status);
                                         if (!disposed)
                                             tui.requestRender();
-                                    }).then(async (outcome) => {
+                                    }, confirmInDashboard).then(async (outcome) => {
                                         if (outcome === "stopped") {
                                             done("__stopped__");
                                             return;
@@ -778,7 +832,8 @@ export function registerWorkflowNavigator(deps) {
                                         const content = [...statusLines, ...phaseLines];
                                         const rows = terminalRows();
                                         const hintRows = rows >= 3 ? 1 : 0;
-                                        const viewport = Math.max(1, rows - hintRows);
+                                        const confirmRows = inlineConfirm.rows(width, styles);
+                                        const viewport = Math.max(1, rows - hintRows - confirmRows.length);
                                         const maxOffset = Math.max(0, content.length - viewport);
                                         dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
                                         if (actionMode) {
@@ -804,11 +859,15 @@ export function registerWorkflowNavigator(deps) {
                                         dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
                                         const selectedNode = selectedNodeId ? tree.byId.get(selectedNodeId) : undefined;
                                         const enterAction = selectedNode?.kind === "workflow" ? "run actions" : selectedNode?.kind === "agent" ? "agent actions" : selectedNode?.children.length ? "expand/collapse" : narrow ? "inspect" : "focus details";
-                                        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")} ${enterAction} · 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] : [])];
+                                        const hint = truncateToVisualLines(theme.fg("dim", inlineConfirm.active() ? inlineConfirm.hint(keybindings) : 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")} ${enterAction} · 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), ...confirmRows, ...(hintRows ? [hint] : [])];
                                     },
                                     invalidate() { },
                                     handleInput(data) {
+                                        if (inlineConfirm.active()) {
+                                            inlineConfirm.handleInput(keybindings, data);
+                                            return;
+                                        }
                                         if (stopRequested || editorRunning)
                                             return;
                                         const narrow = renderedWidth < 80;
@@ -958,7 +1017,7 @@ export function registerWorkflowNavigator(deps) {
                                         }
                                         tui.requestRender();
                                     },
-                                    dispose() { disposed = true; stopTimer(); setWorkflowStatus(undefined); },
+                                    dispose() { disposed = true; stopTimer(); setWorkflowStatus(undefined); inlineConfirm.cancel(); },
                                 };
                             })
                             : await ctx.ui.select(view.dashboard, [...view.actions.keys(), "Back"]);
@@ -1016,8 +1075,7 @@ export function registerWorkflowNavigator(deps) {
                                         const currentLayout = layout();
                                         const maxOffset = Math.max(0, renderedLines.length - currentLayout.contentViewport);
                                         offset = Math.min(offset, maxOffset);
-                                        const keyLabels = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
-                                        const keyLabel = (binding, fallback) => workflowKeyLabel(keybindings, binding, fallback, keyLabels);
+                                        const keyLabel = (binding, fallback) => workflowKeyLabel(keybindings, binding, fallback);
                                         const hint = truncateToVisualLines(theme.fg("dim", `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")}/pgup/pgdn scroll · enter select · esc cancel`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
                                         const controls = currentLayout.compactControls
                                             ? [options.map((option, index) => `${index === selectedIndex ? "[" : " "}${option}${index === selectedIndex ? "]" : " "}`).join(" ")]

package/dist/src/host-recovery.d.ts

@@ -1,8 +1,8 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
-import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI, type ExtensionToolContext } from "@earendil-works/pi-coding-agent";
 import { FairAgentScheduler, WorkflowAgentExecutor, type AgentDefinition, type AgentExecutionRoot, type AgentProviderFailure, type AgentProviderRecovery } from "./agent-execution.js";
 import { RunStore, type PersistedRun } from "./persistence.js";
-import { WorkflowError, type AgentIdentity, type AgentResourcePolicy, type BudgetApprovalRequest, type JsonValue, type LaunchSnapshot, type ModelSpec, type RunState, type ShellIdentity, type ShellOptions, type ShellResult, type WorkflowMetadata, type WorkflowWorktreeReference } from "./types.js";
+import { WorkflowError, type AgentIdentity, type AgentResourcePolicy, type BudgetApprovalRequest, type JsonValue, type LaunchSnapshot, type ModelSpec, type RunState, type ShellIdentity, type ShellOptions, type ShellResult, type ToolIdentity, type WorkflowMetadata, type WorkflowWorktreeReference } from "./types.js";
 import { type WorkflowRegistryApi } from "./registry.js";
 import { RunLifecycle, WorkflowEventPublisher, type WorkflowRunRecord, type WorkflowToolUpdate } from "./host-runtime.js";
 import { type CompletionDeliveryContext, type CompletionDeliveryResult } from "./host-delivery.js";
@@ -21,6 +21,7 @@ export type WorkflowRecoveryContext = {
     } | undefined;
     modelRegistry: ModelRegistryCapability | undefined;
     deliveryContext: CompletionDeliveryContext;
+    toolContext?: ExtensionToolContext | undefined;
     signal?: AbortSignal;
     resolvedAliases?: Readonly<Record<string, string>>;
     blockedAliases?: ReadonlySet<string>;
@@ -70,6 +71,7 @@ export type WorkflowRecoveryDependencies = {
     };
     workflowAgentHandler: (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle, executor: WorkflowAgentExecutor, cwd: string, runId: string, captureRole?: (role: string, model: ModelSpec) => Promise<void>) => (prompt: string, options: Readonly<Record<string, JsonValue>>, signal: AbortSignal, identity: AgentIdentity) => Promise<JsonValue>;
     shellForRun: (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle, command: string, options: ShellOptions, signal: AbortSignal, identity: ShellIdentity) => Promise<ShellResult>;
+    toolForRun: (store: RunStore, lifecycle: RunLifecycle, context: ExtensionToolContext | undefined, identifier: string, args: Readonly<Record<string, JsonValue>>, signal: AbortSignal, identity: ToolIdentity) => Promise<JsonValue>;
     resolveWorktree: (store: RunStore, metadata: WorkflowMetadata, owner: string) => Promise<Readonly<WorkflowWorktreeReference>>;
     checkpointBridge: (runId: string, store: RunStore, metadata: WorkflowMetadata, foreground: boolean, ui?: {
         select?: (prompt: string, options: string[]) => Promise<string | undefined>;
@@ -104,6 +106,7 @@ export declare function createWorkflowRecovery(deps: WorkflowRecoveryDependencie
         } | undefined;
         modelRegistry: WorkflowRecoveryContext["modelRegistry"];
         deliveryContext: CompletionDeliveryContext;
+        toolContext?: ExtensionToolContext | undefined;
         signal?: AbortSignal | undefined;
         resolvedAliases?: Readonly<Record<string, string>>;
         blockedAliases?: ReadonlySet<string>;

package/dist/src/host-recovery.js

@@ -46,7 +46,7 @@ function assertExpectedWorkflowState(expectedState, actualState) {
 }
 export function persistedFailure(run, error) { const failedAt = workflowFailedAt(error); return { ...run, error: { code: error.code, message: error.message, ...(failedAt ? { failedAt } : {}) }, ...(failedAt ? { failedAt } : {}) }; }
 export function createWorkflowRecovery(deps) {
-    const { pi, home, runs, scheduler, eventPublisher, persistRunState, projectTrusted, resumeHostContext, ensureSessionLease, createAgentExecutor, activeSnapshotTools, frozenResourcePolicy, resolveLaunchPrologue, resumeRoles, workflowAgentHandler, shellForRun, resolveWorktree, checkpointBridge, phaseBridge, logBridge, lifecycleFor, createProviderErrorRecovery, cleanupTerminalRun, deliver, deliverTerminal, workflowToolUpdate, registry, modelSpec } = deps;
+    const { pi, home, runs, scheduler, eventPublisher, persistRunState, projectTrusted, resumeHostContext, ensureSessionLease, createAgentExecutor, activeSnapshotTools, frozenResourcePolicy, resolveLaunchPrologue, resumeRoles, workflowAgentHandler, shellForRun, toolForRun, resolveWorktree, checkpointBridge, phaseBridge, logBridge, lifecycleFor, createProviderErrorRecovery, cleanupTerminalRun, deliver, deliverTerminal, workflowToolUpdate, registry, modelSpec } = deps;
     const coordinateRunMutation = deps.coordinateRunMutation ?? ((task) => task());
     const budgetDecisionDelivery = (metadata, request) => `Workflow ${metadata.name} budget adjustment ${request.proposalId} for run ${request.runId} requires approval. Consumed usage: ${JSON.stringify(request.consumed)}. Previous limits: ${JSON.stringify(request.previous)}. Proposed limits: ${JSON.stringify(request.proposed)}. Respond with workflow_respond using proposalId ${request.proposalId}.`;
     const appendBudgetDecisionEvent = async (run, request, type) => {
@@ -119,7 +119,7 @@ export function createWorkflowRecovery(deps) {
         run.executor.setRunContext(runContext);
         await scheduler.cancelRun(run.store.runId);
         await run.lifecycle.resume();
-        const execution = runWorkflow(script, loaded.snapshot.args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(run.store, run.metadata, run.lifecycle, command, options, signal, identity), agent: workflowAgentHandler(run.store, run.metadata, run.lifecycle, run.executor, run.store.cwd, run.store.runId, roles.capture), worktree: async (owner) => resolveWorktree(run.store, run.metadata, owner), checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, foreground, hasUI ? ui : undefined), phase: phaseBridge(run.store, run.metadata, run.lifecycle), log: logBridge(run.store, run.lifecycle, run.metadata.name) }, run.store, runContext, registry, snapshot.settings.extensionSettings), controller.signal);
+        const execution = runWorkflow(script, loaded.snapshot.args, withWorkflowFunctions({ tool: (identifier, args, signal, identity) => toolForRun(run.store, run.lifecycle, context?.toolContext, identifier, args, signal, identity), shell: (command, options, signal, identity) => shellForRun(run.store, run.metadata, run.lifecycle, command, options, signal, identity), agent: workflowAgentHandler(run.store, run.metadata, run.lifecycle, run.executor, run.store.cwd, run.store.runId, roles.capture), worktree: async (owner) => resolveWorktree(run.store, run.metadata, owner), checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, foreground, hasUI ? ui : undefined), phase: phaseBridge(run.store, run.metadata, run.lifecycle), log: logBridge(run.store, run.lifecycle, run.metadata.name) }, run.store, runContext, registry, snapshot.settings.extensionSettings), controller.signal);
         run.execution = execution;
         const completion = execution.result.then(async (value) => {
             await scheduler.flush(run.store.runId);
@@ -333,7 +333,7 @@ export function createWorkflowRecovery(deps) {
             await eventPublisher.runStarted(prepared.childRun.store, prepared.childRun.metadata);
             const { hasUI, ui } = recoveryUi(context);
             const recoveryContext = resumeHostContext(context);
-            const completed = await coldResumeRun(prepared.childRun, hasUI, ui, projectTrusted(context), { model: prepared.hostModel, modelRegistry: prepared.modelRegistry, deliveryContext: recoveryContext.deliveryContext, resolvedAliases: prepared.currentAliases, blockedAliases: prepared.blockedAliases, blockedAliasTargets: prepared.blockedAliasTargets, ...(signal ? { signal } : {}) }, modeOverride);
+            const completed = await coldResumeRun(prepared.childRun, hasUI, ui, projectTrusted(context), { model: prepared.hostModel, modelRegistry: prepared.modelRegistry, deliveryContext: recoveryContext.deliveryContext, toolContext: recoveryContext.toolContext, resolvedAliases: prepared.currentAliases, blockedAliases: prepared.blockedAliases, blockedAliasTargets: prepared.blockedAliasTargets, ...(signal ? { signal } : {}) }, modeOverride);
             const completion = runs.get(prepared.childRun.store.runId)?.completion;
             if (completion) {
                 childStarted = true;

package/dist/src/host-view.d.ts

@@ -12,7 +12,16 @@ export interface WorkflowProgressStyles {
     dim(text: string): string;
     bold(text: string): string;
 }
-export declare function formatWorkflowProgress(run: PersistedRun, spinner?: string, styles?: WorkflowProgressStyles, now?: number, expanded?: boolean, width?: number, showHint?: boolean): string;
+export declare const PLAIN_WORKFLOW_PROGRESS_STYLES: WorkflowProgressStyles;
+export declare function runStateGlyph(state: string, running: string): string;
+export declare function progressStyleForState(state: string, styles: WorkflowProgressStyles): (text: string) => string;
+export declare function formatWorkflowRuntime(durationMs: number): string;
+/**
+ * Renders the run; with `maxLines`, a view taller than that limit switches to a compact one so the live block stays on screen.
+ * A block taller than the terminal pushes its changing header above the viewport, and pi-tui then clears and redraws the whole
+ * scrollback on every update, which snaps the reader back to the bottom.
+ */
+export declare function formatWorkflowProgress(run: PersistedRun, spinner?: string, styles?: WorkflowProgressStyles, now?: number, expanded?: boolean, width?: number, showHint?: boolean, maxLines?: number): string;
 export declare function textBlock(text: string): {
     render(width: number): string[];
     invalidate(): void;
@@ -75,6 +84,11 @@ export declare function navigatorRunLabels(entries: readonly {
 export declare function agentBreadcrumbParts(agent: AgentRecord, byId: Map<string, AgentRecord>, includeStructuralPath?: boolean): string[];
 export declare function agentBreadcrumb(agent: AgentRecord, byId: Map<string, AgentRecord>, includeStructuralPath?: boolean): string;
 export declare function formatStalledDuration(durationMs: number): string;
+export declare function stalledDuration(agent: Pick<AgentDetailPresentation, "state" | "lastEventAt">, now: number): number | undefined;
+export declare function agentActivityLabel(agent: {
+    readonly activity?: AgentRecord["activity"];
+    readonly toolCalls?: AgentRecord["toolCalls"];
+}): string;
 export interface AgentDetailPresentation {
     readonly state: string;
     readonly activity?: AgentRecord["activity"];
@@ -93,6 +107,7 @@ export interface AgentDetailPresentation {
         readonly message: string;
     };
 }
+export declare function formatAgentError(error: NonNullable<AgentDetailPresentation["error"]>, styles?: WorkflowProgressStyles): string;
 export declare function formatAgentDetail(agent: Readonly<AgentDetailPresentation>, styles?: WorkflowProgressStyles, now?: number, options?: Readonly<{
     includeError?: boolean;
 }>): string[];
@@ -113,4 +128,9 @@ export declare function formatNavigatorRun(loaded: {
     snapshot: Readonly<LaunchSnapshot>;
 }, checkpoints: readonly AwaitingCheckpoint[], worktrees: readonly WorktreeReference[], now?: number): string;
 export declare function formatWorkflowPhaseDashboard(run: PersistedRun, snapshot: Readonly<LaunchSnapshot>, width: number, selection?: WorkflowPhaseSelection, styles?: WorkflowProgressStyles, now?: number): string[];
+/** The navigator layout: a sidebar beside details at 80 columns or wider, otherwise one of them (or both stacked). */
+export declare function formatNavigatorColumns(sidebar: readonly string[], detail: readonly string[], width: number, layout?: Readonly<{
+    treeOnly?: boolean | undefined;
+    detailsOnly?: boolean | undefined;
+}>): string[];
 export declare function formatCheckpointReview(checkpoint: AwaitingCheckpoint): string;