pi-extensible-workflows 1.0.0 → 1.0.1

package/dist/src/index.js

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { fork } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -12,11 +12,10 @@ import { Value } from "typebox/value";
 import { copyToClipboard, getAgentDir, parseFrontmatter, highlightCode, SessionManager, truncateToVisualLines } from "@earendil-works/pi-coding-agent";
 import { createNativeAgentSession, FairAgentScheduler, WorkflowAgentExecutor } from "./agent-execution.js";
 import { transcriptLines } from "./session-inspector.js";
-import { acquireSessionLease, listRunIds, RunStore, structuralPath as operationPath } from "./persistence.js";
+import { acquireSessionLease, atomicWriteFile, listRunIds, RunStore, structuralPath as operationPath } from "./persistence.js";
 export const RUN_STATES = ["queued", "running", "pausing", "paused", "awaiting_input", "completed", "failed", "stopped", "interrupted", "budget_exhausted"];
 export const AGENT_STATES = ["queued", "running", "waiting_for_child", "paused", "retrying", "completed", "failed", "cancelled"];
-export const WORKFLOW_ASYNC_STARTED_EVENT = "workflow:async-started";
-export const WORKFLOW_ASYNC_COMPLETE_EVENT = "workflow:async-complete";
+export const WORKFLOW_CALL_KINDS = ["agent", "conversation", "parallel", "pipeline", "checkpoint", "phase", "withWorktree"];
 export const WORKFLOW_RUN_STARTED_EVENT = "workflow:run-started";
 export const WORKFLOW_RUN_RESUMED_EVENT = "workflow:run-resumed";
 export const WORKFLOW_RUN_STATE_CHANGED_EVENT = "workflow:run-state-changed";
@@ -188,6 +187,7 @@ export class RunLifecycle {
 export const DEFAULT_SETTINGS = Object.freeze({ concurrency: 8 });
 function fail(code, message) { throw new WorkflowError(code, message); }
 function object(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }
+export { object as isObject };
 function nonNegativeInteger(value) { return Number.isInteger(value) && value >= 0; }
 function nonNegativeFinite(value) { return typeof value === "number" && Number.isFinite(value) && value >= 0; }
 export function validateBudget(value) {
@@ -562,9 +562,7 @@ export function saveModelAliases(path = workflowSettingsPath(), aliases = {}) {
             throw error;
     }
     mkdirSync(dirname(path), { recursive: true });
-    const temporary = `${path}.${String(process.pid)}.${randomUUID()}.tmp`;
-    writeFileSync(temporary, `${JSON.stringify({ ...parsed, modelAliases: normalized }, null, 2)}\n`, { mode: 0o600 });
-    renameSync(temporary, path);
+    atomicWriteFile(path, `${JSON.stringify({ ...parsed, modelAliases: normalized }, null, 2)}\n`, true);
 }
 export function parseRoleMarkdown(content, strict = false, rolePath) {
     if (!strict) {
@@ -700,20 +698,32 @@ function parseWorkflow(script) {
 function astNode(value) {
     return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
 }
+function astChildren(node) {
+    const children = [];
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const child of value)
+                if (astNode(child))
+                    children.push(child);
+        }
+        else if (astNode(value))
+            children.push(value);
+    }
+    return children;
+}
+function workflowCallKind(node) {
+    if (node.type !== "CallExpression" || node.callee.type !== "Identifier")
+        return undefined;
+    const kind = node.callee.name;
+    return WORKFLOW_CALL_KINDS.includes(kind) ? kind : undefined;
+}
 function workflowCalls(program) {
     const calls = [];
     const visit = (node) => {
-        if (node.type === "CallExpression" && node.callee.type === "Identifier" && ["agent", "conversation", "parallel", "pipeline", "checkpoint", "phase", "withWorktree"].includes(node.callee.name))
+        if (workflowCallKind(node))
             calls.push(node);
-        for (const value of Object.values(node)) {
-            if (Array.isArray(value)) {
-                for (const child of value)
-                    if (astNode(child))
-                        visit(child);
-            }
-            else if (astNode(value))
-                visit(value);
-        }
+        for (const child of astChildren(node))
+            visit(child);
     };
     visit(program);
     return calls.sort((left, right) => left.start - right.start);
@@ -728,9 +738,9 @@ function workflowCallsWithStructure(program) {
             if (scope?.key === null && key)
                 current = { ...current, structure: [...current.structure.slice(0, -1), { ...scope, key }] };
         }
-        if (node.type === "CallExpression" && node.callee.type === "Identifier" && ["agent", "conversation", "parallel", "pipeline", "checkpoint", "phase", "withWorktree"].includes(node.callee.name)) {
+        const operation = workflowCallKind(node);
+        if (operation) {
             const call = node;
-            const operation = call.callee.name;
             const execution = operation === "parallel" ? "parallel" : operation === "pipeline" ? "sequential" : current.execution;
             calls.push({ call, execution, structure: current.structure });
             for (const [index, argument] of call.arguments.entries()) {
@@ -741,15 +751,8 @@ function workflowCallsWithStructure(program) {
             }
             return;
         }
-        for (const value of Object.values(node)) {
-            if (Array.isArray(value)) {
-                for (const child of value)
-                    if (astNode(child))
-                        visit(child, current);
-            }
-            else if (astNode(value))
-                visit(value, current);
-        }
+        for (const child of astChildren(node))
+            visit(child, current);
     };
     visit(program, { execution: "sequential", structure: [] });
     return calls.sort((left, right) => left.call.start - right.call.start);
@@ -762,22 +765,15 @@ function validateDirectPrimitiveReferences(program, name) {
             if (!directCall && !propertyKey)
                 fail("INVALID_METADATA", `${name} calls must use a direct ${name}(...) call; aliases and indirect calls are unsupported`);
         }
-        for (const value of Object.values(node)) {
-            if (Array.isArray(value)) {
-                for (const child of value)
-                    if (astNode(child))
-                        visit(child, node);
-            }
-            else if (astNode(value))
-                visit(value, node);
-        }
+        for (const child of astChildren(node))
+            visit(child, node);
     };
     visit(program);
 }
 function hasIdentifier(node, name) {
     if (node.type === "Identifier" && node.name === name)
         return true;
-    return Object.values(node).some((value) => Array.isArray(value) ? value.some((child) => astNode(child) && hasIdentifier(child, name)) : astNode(value) && hasIdentifier(value, name));
+    return astChildren(node).some((child) => hasIdentifier(child, name));
 }
 const INTERNAL_AGENT_NAME = "__pi_extensible_workflows_agent";
 const INTERNAL_CONVERSATION_NAME = "__pi_extensible_workflows_conversation";
@@ -1156,7 +1152,7 @@ export class WorkflowRegistry {
                 fail("RESULT_INVALID", `Invalid replay for ${name}`);
             return structuredClone(replayed);
         }
-        const result = await fn.run(deepFreeze(structuredClone(input)), Object.freeze({ run: context.run, agent: context.agent, prompt: context.prompt, parallel: context.parallel, pipeline: context.pipeline, withWorktree: context.withWorktree, checkpoint: context.checkpoint, phase: context.phase, log: context.log }));
+        const result = await fn.run(deepFreeze(structuredClone(input)), Object.freeze({ run: context.run, invoke: context.invoke, agent: context.agent, prompt: context.prompt, parallel: context.parallel, pipeline: context.pipeline, withWorktree: context.withWorktree, checkpoint: context.checkpoint, phase: context.phase, log: context.log }));
         if (!jsonValue(result) || !Value.Check(fn.output, result))
             fail("RESULT_INVALID", `Invalid output from ${name}`);
         const stored = structuredClone(result);
@@ -1333,8 +1329,6 @@ export function createLaunchSnapshot(input) {
     return deepFreeze(structuredClone({ ...input, identityVersion: input.identityVersion ?? LAUNCH_SNAPSHOT_IDENTITY_VERSION }));
 }
 export function loadLaunchSnapshot(input) {
-    if (object(input.settings) && Object.prototype.hasOwnProperty.call(input.settings, "maxAgentLaunches"))
-        fail("RESUME_INCOMPATIBLE", "Persisted workflow settings contain removed maxAgentLaunches");
     return deepFreeze(structuredClone(input));
 }
 export const RPC_LIMIT_BYTES = 10 * 1024 * 1024;
@@ -2121,30 +2115,17 @@ class WorkflowEventPublisher {
             seen.add(this.budgetKey(event));
         this.#budgetEvents.set(runId, seen);
     }
-    async runStarted(store, metadata, background) {
-        await this.#publish(store, metadata, WORKFLOW_RUN_STARTED_EVENT, {});
-        if (background)
-            await this.legacyStarted(store, metadata);
-    }
-    async legacyStarted(store, metadata) { await this.#publish(store, metadata, WORKFLOW_ASYNC_STARTED_EVENT, { id: store.runId, runId: store.runId, pid: process.pid, sessionId: store.sessionId, asyncDir: store.directory, agent: metadata.name }); }
+    async runStarted(store, metadata) { await this.#publish(store, metadata, WORKFLOW_RUN_STARTED_EVENT, {}); }
     async runResumed(store, metadata) { await this.#publish(store, metadata, WORKFLOW_RUN_RESUMED_EVENT, {}); }
     async runState(store, metadata, previousState, state, reason) {
         await this.#publish(store, metadata, WORKFLOW_RUN_STATE_CHANGED_EVENT, { previousState, state, ...(reason ? { reason } : {}), ...(ERROR_CODES.includes(reason) ? { errorCode: reason } : {}) });
         if ((previousState === "paused" || previousState === "interrupted" || previousState === "budget_exhausted") && state === "running")
             await this.runResumed(store, metadata);
     }
-    async runCompleted(store, metadata, resultPath, background) {
-        await this.#publish(store, metadata, WORKFLOW_RUN_COMPLETED_EVENT, { resultPath });
-        if (background)
-            await this.#publish(store, metadata, WORKFLOW_ASYNC_COMPLETE_EVENT, { id: store.runId, runId: store.runId, sessionId: store.sessionId, asyncDir: store.directory, success: true, state: "complete" });
-    }
-    async runFailed(store, metadata, error, background, state) {
+    async runCompleted(store, metadata, resultPath) { await this.#publish(store, metadata, WORKFLOW_RUN_COMPLETED_EVENT, { resultPath }); }
+    async runFailed(store, metadata, error, state) {
         if (state === "failed")
             await this.#publish(store, metadata, WORKFLOW_RUN_FAILED_EVENT, { error: safeEventError(error) });
-        if (background) {
-            const legacyState = state === "interrupted" ? "failed" : state;
-            await this.#publish(store, metadata, WORKFLOW_ASYNC_COMPLETE_EVENT, { id: store.runId, runId: store.runId, sessionId: store.sessionId, asyncDir: store.directory, success: false, state: legacyState, ...(state === "stopped" ? { stopped: true } : {}), ...(legacyState === "budget_exhausted" || legacyState === "failed" ? { error: safeEventError(error).message } : {}) });
-        }
     }
     async agentState(store, metadata, previous, agent) {
         await this.#publish(store, metadata, WORKFLOW_AGENT_STATE_CHANGED_EVENT, { agentId: agent.id, displayLabel: agent.label ?? agent.name, ...(agent.role ? { role: agent.role } : {}), structuralPath: [...(agent.structuralPath ?? [])], ...(agent.parentId ? { parentId: agent.parentId } : {}), ...(agent.parentBreadcrumb ? { parentBreadcrumb: agent.parentBreadcrumb } : {}), ...(agent.worktreeOwner ? { worktreeOwner: agent.worktreeOwner } : {}), ...(previous ? { previousState: previous.state } : {}), state: agent.state, attempt: agent.attempts });
@@ -2321,46 +2302,100 @@ function nextNamedOccurrence(counters, label) {
 function withWorkflowFunctions(bridge, store, runContext, variables, registry) {
     const functionAgentOccurrences = new Map();
     const functionWorktreeOccurrences = new Map();
-    return { ...bridge, functions: registry.globals(), variables, function: async (name, input, path, signal, worktreeOwner, structuralPath = []) => {
-            const replayed = await store.replay(path);
-            let stored;
-            const sideEffects = [];
-            const context = {
-                run: runContext,
-                agent: async (...args) => {
-                    if (!bridge.agent || typeof args[0] !== "string")
-                        fail("AGENT_FAILED", "No agent bridge is available");
-                    const options = validateAgentOptions(args[1] === undefined ? {} : args[1]);
-                    const scopedWorktreeOwner = inheritedHostWorktreeOwner.getStore() ?? worktreeOwner;
-                    const inherited = inheritedHostAgentPath.getStore() ?? [];
-                    const key = `${path}\0${JSON.stringify(inherited)}`;
-                    const occurrence = (functionAgentOccurrences.get(key) ?? 0) + 1;
-                    functionAgentOccurrences.set(key, occurrence);
-                    return bridge.agent(args[0], options, signal, { structuralPath: [...inherited], callSite: `function:${path}`, occurrence, parentBreadcrumb: name, ...(scopedWorktreeOwner ? { worktreeOwner: scopedWorktreeOwner } : {}) });
-                },
-                prompt: workflowPrompt,
-                parallel: (...args) => hostParallel(args[0], args[1]),
-                pipeline: (...args) => hostPipeline(args[0], args[1], args[2]),
-                withWorktree: (...args) => hostWithWorktree(args, path, functionWorktreeOccurrences),
-                checkpoint: async (...args) => {
-                    if (!bridge.checkpoint || !object(args[0]) || !jsonValue(args[0]))
-                        fail("INTERNAL_ERROR", "No checkpoint bridge is available");
-                    return bridge.checkpoint(args[0], signal);
-                },
-                phase: (name) => { sideEffects.push(Promise.resolve(bridge.phase?.(name))); },
-                log: (message) => { sideEffects.push(Promise.resolve(bridge.log?.(message))); },
-            };
-            const result = await inheritedHostAgentPath.run([...structuralPath], async () => registry.invokeFunction(name, input, context, path, { get: () => replayed?.value, put: (_path, value) => { stored = value; } }));
-            await Promise.all(sideEffects);
-            if (!replayed)
-                await store.complete(path, stored ?? result);
-            return result;
-        } };
+    const functionInvokeOccurrences = new Map();
+    const invokeFunction = async (name, input, path, signal, worktreeOwner, structuralPath = [], breadcrumb) => {
+        const replayed = await store.replay(path);
+        let stored;
+        const sideEffects = [];
+        const functionBreadcrumb = breadcrumb ?? name;
+        const context = {
+            run: runContext,
+            invoke: async (targetName, targetInput) => {
+                const inherited = inheritedHostAgentPath.getStore() ?? structuralPath;
+                const scopedWorktreeOwner = inheritedHostWorktreeOwner.getStore() ?? worktreeOwner;
+                const key = JSON.stringify([path, inherited, targetName]);
+                const occurrence = (functionInvokeOccurrences.get(key) ?? 0) + 1;
+                functionInvokeOccurrences.set(key, occurrence);
+                const nestedPath = operationPath("function", "nested", path, ...inherited, targetName, `occurrence:${String(occurrence)}`);
+                return invokeFunction(targetName, targetInput, nestedPath, signal, scopedWorktreeOwner, inherited, `${functionBreadcrumb} > ${targetName}`);
+            },
+            agent: async (...args) => {
+                if (!bridge.agent || typeof args[0] !== "string")
+                    fail("AGENT_FAILED", "No agent bridge is available");
+                const options = validateAgentOptions(args[1] === undefined ? {} : args[1]);
+                const scopedWorktreeOwner = inheritedHostWorktreeOwner.getStore() ?? worktreeOwner;
+                const inherited = inheritedHostAgentPath.getStore() ?? [];
+                const key = `${path}\0${JSON.stringify(inherited)}`;
+                const occurrence = (functionAgentOccurrences.get(key) ?? 0) + 1;
+                functionAgentOccurrences.set(key, occurrence);
+                return bridge.agent(args[0], options, signal, { structuralPath: [...inherited], callSite: `function:${path}`, occurrence, parentBreadcrumb: functionBreadcrumb, ...(scopedWorktreeOwner ? { worktreeOwner: scopedWorktreeOwner } : {}) });
+            },
+            prompt: workflowPrompt,
+            parallel: (...args) => hostParallel(args[0], args[1]),
+            pipeline: (...args) => hostPipeline(args[0], args[1], args[2]),
+            withWorktree: (...args) => hostWithWorktree(args, path, functionWorktreeOccurrences),
+            checkpoint: async (...args) => {
+                if (!bridge.checkpoint || !object(args[0]) || !jsonValue(args[0]))
+                    fail("INTERNAL_ERROR", "No checkpoint bridge is available");
+                return bridge.checkpoint(args[0], signal);
+            },
+            phase: (name) => { sideEffects.push(Promise.resolve(bridge.phase?.(name))); },
+            log: (message) => { sideEffects.push(Promise.resolve(bridge.log?.(message))); },
+        };
+        const result = await inheritedHostAgentPath.run([...structuralPath], async () => registry.invokeFunction(name, input, context, path, { get: () => replayed?.value, put: (_path, value) => { stored = value; } }));
+        await Promise.all(sideEffects);
+        if (!replayed)
+            await store.complete(path, stored ?? result);
+        return result;
+    };
+    return { ...bridge, functions: registry.globals(), variables, function: invokeFunction };
 }
 function projectTrusted(ctx) {
     const check = object(ctx) ? ctx.isProjectTrusted : undefined;
     return typeof check === "function" ? Boolean(Reflect.apply(check, ctx, [])) : true;
 }
+function isEntryRenderer(value) { return typeof value === "function"; }
+function isWorkflowEventSink(value) { return object(value) && typeof value.emit === "function"; }
+function piHostCapabilities(pi) {
+    if (!object(pi))
+        return {};
+    const registerEntryRenderer = pi.registerEntryRenderer;
+    const events = pi.events;
+    return { ...(isEntryRenderer(registerEntryRenderer) ? { registerEntryRenderer } : {}), ...(isWorkflowEventSink(events) ? { events } : {}) };
+}
+function isModelRegistryGetter(value) { return typeof value === "function"; }
+function contextHostCapabilities(ctx) {
+    if (!object(ctx) || !object(ctx.modelRegistry))
+        return {};
+    const registry = ctx.modelRegistry;
+    const getAll = registry.getAll;
+    const getAvailable = registry.getAvailable;
+    return { modelRegistry: { ...(isModelRegistryGetter(getAll) ? { getAll: () => getAll.call(registry) } : {}), ...(isModelRegistryGetter(getAvailable) ? { getAvailable: () => getAvailable.call(registry) } : {}) } };
+}
+function isUiSelect(value) { return typeof value === "function"; }
+function isUiInput(value) { return typeof value === "function"; }
+function isUiSetStatus(value) { return typeof value === "function"; }
+function uiHostCapabilities(ui) {
+    if (!object(ui))
+        return undefined;
+    const select = ui.select;
+    const input = ui.input;
+    const setStatus = ui.setStatus;
+    return { ...(isUiSelect(select) ? { select } : {}), ...(isUiInput(input) ? { input } : {}), ...(isUiSetStatus(setStatus) ? { setStatus } : {}) };
+}
+function tuiHostCapabilities(tui) {
+    if (!object(tui) || !object(tui.terminal))
+        return {};
+    return { terminal: { ...(tui.terminal.rows === undefined ? {} : { rows: tui.terminal.rows }) } };
+}
+function tuiRows(tui) { const rows = tuiHostCapabilities(tui).terminal?.rows; return typeof rows === "number" && Number.isFinite(rows) ? rows : 24; }
+function isKeybindingGetter(value) { return typeof value === "function"; }
+function keybindingsHostCapabilities(keybindings) {
+    if (!object(keybindings) || !isKeybindingGetter(keybindings.getKeys))
+        return {};
+    return { getKeys: keybindings.getKeys };
+}
+function keybindingKeys(keybindings, name) { const getKeys = keybindingsHostCapabilities(keybindings).getKeys; return typeof getKeys === "function" ? getKeys.call(keybindings, name) : undefined; }
 function parseThinking(value) {
     switch (value) {
         case "off":
@@ -2376,7 +2411,7 @@ function parseThinking(value) {
 export default function workflowExtension(pi, home, clipboard = copyToClipboard, createSession = createNativeAgentSession) {
     beginWorkflowExtensionLoading();
     const registry = loadingRegistry();
-    const registerEntryRenderer = pi.registerEntryRenderer;
+    const registerEntryRenderer = piHostCapabilities(pi).registerEntryRenderer;
     registerEntryRenderer?.(WORKFLOW_LOG_ENTRY, (entry) => {
         const data = entry.data;
         return textBlock(data ? `Workflow ${data.workflowName}: ${data.message}` : "");
@@ -2390,7 +2425,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             await lifecycle.leave();
         }
     };
-    const eventPublisher = new WorkflowEventPublisher(pi.events);
+    const eventPublisher = new WorkflowEventPublisher(piHostCapabilities(pi).events);
     pi.on("resources_discover", () => {
         if (!pi.getActiveTools().includes("workflow"))
             return;
@@ -2399,6 +2434,28 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         return skillPath ? { skillPaths: [skillPath] } : undefined;
     });
     const runs = new Map();
+    const liveActivities = new Map();
+    const setLiveActivity = (runId, agentId, activity) => {
+        const activities = liveActivities.get(runId);
+        if (activity) {
+            if (activities)
+                activities.set(agentId, activity);
+            else
+                liveActivities.set(runId, new Map([[agentId, activity]]));
+        }
+        else {
+            activities?.delete(agentId);
+            if (activities?.size === 0)
+                liveActivities.delete(runId);
+        }
+    };
+    const withLiveActivities = (run) => {
+        const activities = liveActivities.get(run.id);
+        return activities?.size ? { ...run, agents: run.agents.map((agent) => {
+                const activity = activities.get(agent.id);
+                return activity ? { ...agent, activity } : agent;
+            }) } : run;
+    };
     const conversationLocks = new Set();
     const terminalRunStates = new Map();
     let sessionLease;
@@ -2443,7 +2500,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             return nextRun;
         });
         await eventPublisher.runState(store, metadata, previous, next, reason);
-        runs.get(store.runId)?.update?.(workflowToolUpdate(persisted));
+        runs.get(store.runId)?.update?.(workflowToolUpdate(withLiveActivities(persisted)));
     });
     const scheduler = new FairAgentScheduler(async ({ id, runId, parentId, prompt, options, signal, setSteer }) => {
         const run = runs.get(runId);
@@ -2464,7 +2521,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 }
                 if (!runState.agents.some((agent) => agent.id === id))
                     return;
-                run.update?.(workflowToolUpdate(runState));
+                setLiveActivity(runId, id, progress.activity);
+                run.update?.(workflowToolUpdate(withLiveActivities(runState)));
             };
             const onAttempt = async (attempt) => {
                 await scheduler.flush();
@@ -2475,7 +2533,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 const active = (await run.store.load()).run;
                 await eventPublisher.agentStates(run.store, run.metadata, before.agents, active.agents);
                 const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot() }));
-                run.update?.(workflowToolUpdate(persisted));
+                run.update?.(workflowToolUpdate(withLiveActivities(persisted)));
             };
             const result = await run.executor.execute(prompt, { label: options.label, workflowName: run.metadata.name, onProgress, onAttempt, budget, ...(parentId ? { parent: parentId, cwd: options.cwd, ...(options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}) } : options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}), ...(options.model ? { model: options.model } : {}), ...(options.thinking ? { thinking: options.thinking } : {}), ...(options.role ? { role: options.role } : {}), ...(options.role ? {} : { tools: options.tools }), effectiveTools: options.tools, ...(options.schema ? { schema: options.schema } : {}), ...(options.retries === undefined ? {} : { retries: options.retries }), ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }), ...(options.agentOptions ? { agentOptions: options.agentOptions } : {}), ...(options.agentIdentity ? { agentIdentity: options.agentIdentity } : {}), ...(options.conversation ? { conversation: options.conversation } : {}) }, signal, scheduler.toolsFor(id, (role, tools, model, inheritedTools, thinking) => run.executor.resolve({ label: "child", workflowName: run.metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(tools !== undefined ? { tools } : {}) }, inheritedTools).tools), setSteer, () => { scheduler.cancelChildren(id); scheduler.retry(id); });
             const before = (await run.store.load()).run;
@@ -2483,7 +2541,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const completed = (await run.store.load()).run;
             await eventPublisher.agentStates(run.store, run.metadata, before.agents, completed.agents);
             const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot() }));
-            run.update?.(workflowToolUpdate(persisted));
+            setLiveActivity(runId, id);
+            run.update?.(workflowToolUpdate(withLiveActivities(persisted)));
             return result.value;
         }
         catch (error) {
@@ -2495,7 +2554,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 await eventPublisher.agentStates(run.store, run.metadata, before.agents, failed.agents);
             }
             const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot() }));
-            run.update?.(workflowToolUpdate(persisted));
+            setLiveActivity(runId, id);
+            run.update?.(workflowToolUpdate(withLiveActivities(persisted)));
             throw error;
         }
     }, 16, async (runId, ownership) => {
@@ -2522,7 +2582,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             return { ...current, agents };
         });
         await eventPublisher.agentStates(run.store, run.metadata, previousAgents, runState.agents);
-        run.update?.(workflowToolUpdate(runState));
+        run.update?.(workflowToolUpdate(withLiveActivities(runState)));
     });
     const stopWorkflowRun = async (runId) => {
         const run = runs.get(runId);
@@ -2756,7 +2816,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             if (!["completed", "failed", "stopped"].includes(run.lifecycle.state)) {
                 await run.lifecycle.terminal("failed", typed.code).catch(() => undefined);
                 const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, error: { code: typed.code, message: typed.message } }));
-                await eventPublisher.runFailed(run.store, run.metadata, typed, true, run.lifecycle.state === "interrupted" ? "interrupted" : "failed");
+                await eventPublisher.runFailed(run.store, run.metadata, typed, run.lifecycle.state === "interrupted" ? "interrupted" : "failed");
                 run.update?.(workflowToolUpdate(persisted));
             }
             throw typed;
@@ -2826,7 +2886,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 throw new WorkflowError("BUDGET_EXHAUSTED", "Budgeted work was attempted after hard exhaustion");
             const resultPath = await run.store.saveResult(value);
             await run.lifecycle.terminal("completed", "completed");
-            await eventPublisher.runCompleted(run.store, run.metadata, resultPath, true);
+            await eventPublisher.runCompleted(run.store, run.metadata, resultPath);
             return { value, resultPath };
         }).catch(async (error) => {
             await scheduler.flush();
@@ -2835,7 +2895,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 await run.lifecycle.terminal(typed.code === "BUDGET_EXHAUSTED" ? "budget_exhausted" : "failed", typed.code);
             const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot(), error: { code: typed.code, message: typed.message } }));
             const state = run.lifecycle.state === "stopped" || run.lifecycle.state === "interrupted" || run.lifecycle.state === "budget_exhausted" ? run.lifecycle.state : "failed";
-            await eventPublisher.runFailed(run.store, run.metadata, typed, true, state);
+            await eventPublisher.runFailed(run.store, run.metadata, typed, state);
             run.update?.(workflowToolUpdate(persisted));
             if (!["stopped", "interrupted", "budget_exhausted"].includes(run.lifecycle.state))
                 deliverFailure(pi, run.metadata.name, error);
@@ -2962,7 +3022,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     deliver(pi, budgetDecisionDelivery(loaded.snapshot.metadata, decision));
                 scheduler.restoreRun(runId, loaded.snapshot.settings.concurrency, loaded.snapshot.identityVersion === LAUNCH_SNAPSHOT_IDENTITY_VERSION ? await store.loadOwnership() : [], () => runs.get(runId)?.budget.checkAgentLaunch());
             }
-            const resumeSelect = ctx.ui?.select;
+            const resumeSelect = uiHostCapabilities(ctx.ui)?.select;
             if (ctx.hasUI && resumeSelect) {
                 const interrupted = [...runs.values()].filter((r) => r.lifecycle.state === "interrupted");
                 if (interrupted.length > 0) {
@@ -3014,7 +3074,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 const budget = validateBudget(params.budget);
                 const rootModel = { provider: ctx.model.provider, model: ctx.model.id, thinking: pi.getThinkingLevel() };
                 const rootModelName = `${rootModel.provider}/${rootModel.model}`;
-                const modelRegistry = ctx.modelRegistry;
+                const modelRegistry = contextHostCapabilities(ctx).modelRegistry;
                 const knownModels = new Set((modelRegistry?.getAll?.() ?? modelRegistry?.getAvailable?.() ?? [ctx.model]).map((model) => `${model.provider}/${model.id}`));
                 knownModels.add(rootModelName);
                 const availableModels = knownModels;
@@ -3116,14 +3176,14 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         }
                     }, log: logBridge(lifecycle, checked.metadata.name) }, store, runContext, variables, registry), runController.signal);
                 runs.get(runId).execution = execution;
-                await eventPublisher.runStarted(store, checked.metadata, background);
+                await eventPublisher.runStarted(store, checked.metadata);
                 const finish = execution.result.then(async (value) => {
                     await scheduler.flush();
                     if (budgetRuntime.hardExhausted)
                         throw new WorkflowError("BUDGET_EXHAUSTED", "Budgeted work was attempted after hard exhaustion");
                     const resultPath = await store.saveResult(value);
                     await lifecycle.terminal("completed", "completed");
-                    await eventPublisher.runCompleted(store, checked.metadata, resultPath, background);
+                    await eventPublisher.runCompleted(store, checked.metadata, resultPath);
                     return { value, resultPath };
                 }).catch(async (error) => {
                     await scheduler.flush();
@@ -3132,7 +3192,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         await lifecycle.terminal(typed.code === "CANCELLED" ? "stopped" : typed.code === "BUDGET_EXHAUSTED" ? "budget_exhausted" : "failed", typed.code);
                     await persistRunState(store, checked.metadata, (current) => ({ ...current, ...budgetRuntime.snapshot(), error: { code: typed.code, message: typed.message } }));
                     const state = lifecycle.state === "stopped" || lifecycle.state === "interrupted" || lifecycle.state === "budget_exhausted" ? lifecycle.state : "failed";
-                    await eventPublisher.runFailed(store, checked.metadata, typed, background, state);
+                    await eventPublisher.runFailed(store, checked.metadata, typed, state);
                     throw typed;
                 });
                 runs.get(runId).completion = finish;
@@ -3198,7 +3258,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             let stores = await loadStores();
             const usage = "Usage: /workflow [doctor|model-aliases], or /workflow pause|resume|stop|approve|reject|delete <run-id> [checkpoint or proposal-id]. Use workflow_resume for budget patches.";
             const setWorkflowStatus = (text) => {
-                const setStatus = ctx.ui.setStatus;
+                const setStatus = uiHostCapabilities(ctx.ui)?.setStatus;
                 setStatus?.call(ctx.ui, "workflow-stop", text);
             };
             const runAction = async (actionCommand, keepContext, status = setWorkflowStatus) => {
@@ -3254,7 +3314,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         return keepContext ? "dashboard" : "done";
                     }
                     if (action === "adjust" && run?.lifecycle.state === "budget_exhausted") {
-                        const input = await ctx.ui.input?.("Budget patch (JSON)", "{\"tokens\":{\"hard\":null}}");
+                        const input = await uiHostCapabilities(ctx.ui)?.input?.call(ctx.ui, "Budget patch (JSON)", "{\"tokens\":{\"hard\":null}}");
                         if (input === undefined)
                             return keepContext ? "dashboard" : "done";
                         const result = await resumeWorkflowRun(run.store.runId, JSON.parse(input));
@@ -3292,7 +3352,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             };
             const manageAliases = async () => {
                 const settingsPath = workflowSettingsPath();
-                const modelRegistry = ctx.modelRegistry;
+                const modelRegistry = contextHostCapabilities(ctx).modelRegistry;
                 const available = () => [...new Set((modelRegistry?.getAvailable?.() ?? []).map((model) => `${model.provider}/${model.id}`))].sort();
                 const selectTarget = async () => {
                     const models = available();
@@ -3458,7 +3518,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             await ctx.ui.custom((tui, theme, keybindings, done) => {
                                 let offset = 0;
                                 let renderedLines = [];
-                                const viewport = () => Math.max(1, ((tui.terminal?.rows) ?? 24) - 3);
+                                const viewport = () => Math.max(1, tuiRows(tui) - 3);
                                 const move = (delta) => { offset = Math.max(0, Math.min(Math.max(0, renderedLines.length - viewport()), offset + delta)); };
                                 return {
                                     render(width) {
@@ -3615,11 +3675,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 let disposed = false;
                                 let stopRequested = false;
                                 let stopStatus;
-                                const terminalRows = () => Math.max(1, (tui.terminal?.rows) ?? 24);
+                                const terminalRows = () => Math.max(1, tuiRows(tui));
                                 const keyLabels = { up: "↑", down: "↓", pageUp: "pgup", pageDown: "pgdn", escape: "esc" };
                                 const keyLabel = (binding, fallback) => {
-                                    const getKeys = keybindings.getKeys;
-                                    const keys = getKeys?.call(keybindings, binding);
+                                    const keys = keybindingKeys(keybindings, binding);
                                     return keys?.length ? keys.map((key) => keyLabels[key] ?? key).join("/") : fallback;
                                 };
                                 const dashboardLayout = () => {
@@ -3733,7 +3792,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 const highlighted = highlightCode(view.script, "javascript");
                                 let offset = 0;
                                 let renderedLines = [];
-                                const viewport = () => Math.max(1, ((tui.terminal?.rows) ?? 24) - 3);
+                                const viewport = () => Math.max(1, tuiRows(tui) - 3);
                                 const move = (delta) => {
                                     const maxOffset = Math.max(0, renderedLines.length - viewport());
                                     offset = Math.max(0, Math.min(maxOffset, offset + delta));
@@ -3799,7 +3858,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 let offset = 0;
                                 let renderedLines = [];
                                 const layout = () => {
-                                    const rows = Math.max(1, ((tui.terminal?.rows) ?? 24));
+                                    const rows = Math.max(1, tuiRows(tui));
                                     const compactControls = rows < 4;
                                     const titleRows = rows >= 5 ? 1 : 0;
                                     const hintRows = rows >= 8 ? 1 : 0;

package/dist/src/persistence.d.ts

@@ -60,6 +60,8 @@ export declare class SessionLease {
 export declare function acquireSessionLease(cwd: string, sessionId: string, home?: string): Promise<SessionLease>;
 export declare function listRunIds(cwd: string, sessionId: string, home?: string): Promise<string[]>;
 export declare function structuralPath(...names: string[]): string;
+export declare function atomicWriteFile(path: string, content: string): Promise<void>;
+export declare function atomicWriteFile(path: string, content: string, sync: true): void;
 export declare class RunStore {
     readonly cwd: string;
     readonly sessionId: string;

package/dist/src/persistence.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
+import { renameSync, rmSync, writeFileSync } from "node:fs";
 import { access, link, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { homedir } from "node:os";
@@ -182,10 +183,32 @@ export function structuralPath(...names) {
         throw new WorkflowError("INVALID_METADATA", "Structural paths require non-empty explicit names");
     return names.map((name) => encodeURIComponent(name)).join("/");
 }
-async function atomicJson(path, value) {
+export function atomicWriteFile(path, content, sync = false) {
     const temporary = `${path}.${String(process.pid)}.${randomUUID()}.tmp`;
-    await writeFile(temporary, `${JSON.stringify(value)}\n`, { encoding: "utf8", mode: 0o600 });
-    await rename(temporary, path);
+    if (sync) {
+        try {
+            writeFileSync(temporary, content, { encoding: "utf8", mode: 0o600 });
+            renameSync(temporary, path);
+        }
+        catch (error) {
+            try {
+                rmSync(temporary, { force: true });
+            }
+            catch { /* Preserve the original write error. */ }
+            throw error;
+        }
+        return;
+    }
+    return writeFile(temporary, content, { encoding: "utf8", mode: 0o600 }).then(() => rename(temporary, path)).catch(async (error) => {
+        try {
+            await rm(temporary, { force: true });
+        }
+        catch { /* Preserve the original write error. */ }
+        throw error;
+    });
+}
+async function atomicJson(path, value) {
+    await atomicWriteFile(path, `${JSON.stringify(value)}\n`);
 }
 async function json(path) { return JSON.parse(await readFile(path, "utf8")); }
 export class RunStore {
@@ -277,7 +300,7 @@ export class RunStore {
         await write;
     }
     async appendEvent(event) {
-        await this.updateState((run) => ({ ...run, events: [...(run.events ?? []), ...(run.events?.some((current) => current.message === event.message) ? [] : [event])] }));
+        await this.updateState((run) => ({ ...run, events: [...(run.events ?? []), ...(run.events?.some((current) => current.type === event.type && current.message === event.message) ? [] : [event])] }));
     }
     async saveOwnership(nodes) {
         await atomicJson(join(this.directory, "ownership.json"), nodes);