@quintinshaw/pi-dynamic-workflows 1.7.1 → 1.9.0

package/dist/workflow-ui.js

@@ -0,0 +1,426 @@
+/**
+ * Interactive `/workflows` navigator, modeled on Claude Code's view:
+ *
+ *   runs ──enter──▶ phases ──enter──▶ agents ──enter──▶ agent detail
+ *        ◀──esc───        ◀──esc────         ◀──esc────
+ *
+ * Keys: ↑/↓ (or j/k) select · enter/→ drill in · esc/← back (esc at top closes)
+ *       p pause/resume · x stop · r restart · s save · q quit
+ *
+ * The state machine and line rendering are pure and unit-tested; the pi-tui
+ * Component shell (openWorkflowNavigator) wires them to live manager events.
+ */
+import { parseKey } from "@earendil-works/pi-tui";
+import { registerSavedWorkflow } from "./saved-commands.js";
+const STATUS_ICON = {
+    pending: "·",
+    queued: "·",
+    running: "◆",
+    paused: "⏸",
+    completed: "✓",
+    done: "✓",
+    failed: "✗",
+    error: "✗",
+    aborted: "⊘",
+    skipped: "⊘",
+};
+const PLAIN = { fg: (_c, t) => t, bold: (t) => t };
+/** Reads run/phase/agent data from the manager, preferring live snapshots. */
+export class NavigatorModel {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    snapshot(runId) {
+        const live = this.manager.getRun(runId);
+        if (live)
+            return { snapshot: live.snapshot, status: live.status };
+        const p = this.manager.listRuns().find((r) => r.runId === runId);
+        if (!p)
+            return undefined;
+        return { snapshot: persistedToSnapshot(p), status: p.status };
+    }
+    runs() {
+        return this.manager.listRuns().map((p) => {
+            const live = this.manager.getRun(p.runId);
+            const agents = (live?.snapshot.agents ?? p.agents);
+            return {
+                runId: p.runId,
+                name: live?.snapshot.name ?? p.workflowName,
+                status: live?.status ?? p.status,
+                done: agents.filter((a) => a.status === "done").length,
+                total: agents.length,
+                tokens: (live?.snapshot.tokenUsage ?? p.tokenUsage)?.total ?? 0,
+            };
+        });
+    }
+    runName(runId) {
+        return this.snapshot(runId)?.snapshot.name ?? runId;
+    }
+    runStatus(runId) {
+        return this.snapshot(runId)?.status ?? "unknown";
+    }
+    phases(runId) {
+        const snap = this.snapshot(runId)?.snapshot;
+        if (!snap)
+            return [];
+        const order = snap.phases.length ? [...snap.phases] : [];
+        const byPhase = new Map();
+        for (const a of snap.agents) {
+            const key = a.phase ?? "(no phase)";
+            if (!byPhase.has(key))
+                byPhase.set(key, []);
+            byPhase.get(key)?.push(a);
+            if (!order.includes(key))
+                order.push(key);
+        }
+        return order.map((title) => {
+            const agents = byPhase.get(title) ?? [];
+            return {
+                title,
+                done: agents.filter((a) => a.status === "done").length,
+                total: agents.length,
+                tokens: agents.reduce((n, a) => n + (a.tokens ?? 0), 0),
+            };
+        });
+    }
+    agents(runId, phase) {
+        const snap = this.snapshot(runId)?.snapshot;
+        if (!snap)
+            return [];
+        return snap.agents
+            .filter((a) => (a.phase ?? "(no phase)") === phase)
+            .map((a) => ({ id: a.id, label: a.label, status: a.status, phase: a.phase, tokens: a.tokens }));
+    }
+    agentDetail(runId, agentId) {
+        return this.snapshot(runId)?.snapshot.agents.find((a) => a.id === agentId);
+    }
+}
+function persistedToSnapshot(p) {
+    return {
+        name: p.workflowName,
+        phases: p.phases,
+        currentPhase: p.currentPhase,
+        logs: p.logs,
+        agents: p.agents.map((a) => ({
+            id: a.id,
+            label: a.label,
+            phase: a.phase,
+            prompt: a.prompt,
+            status: a.status,
+            resultPreview: a.result == null ? undefined : String(typeof a.result === "string" ? a.result : JSON.stringify(a.result)),
+            error: a.error,
+        })),
+        agentCount: p.agents.length,
+        runningCount: p.agents.filter((a) => a.status === "running").length,
+        doneCount: p.agents.filter((a) => a.status === "done").length,
+        errorCount: p.agents.filter((a) => a.status === "error").length,
+        tokenUsage: p.tokenUsage ? { ...p.tokenUsage } : undefined,
+        runId: p.runId,
+    };
+}
+/** Navigation state machine: a stack of (view, cursor) frames plus detail scroll. */
+export class NavigatorState {
+    stack = [
+        { kind: "runs", cursor: 0 },
+    ];
+    scroll = 0;
+    top() {
+        return this.stack[this.stack.length - 1];
+    }
+    get kind() {
+        return this.top().kind;
+    }
+    get cursor() {
+        return this.top().cursor;
+    }
+    get runId() {
+        return this.top().runId;
+    }
+    get phase() {
+        return this.top().phase;
+    }
+    get agentId() {
+        return this.top().agentId;
+    }
+    get depth() {
+        return this.stack.length;
+    }
+    /** Clamp the cursor to [0, count). */
+    clamp(count) {
+        const t = this.top();
+        t.cursor = count <= 0 ? 0 : Math.max(0, Math.min(t.cursor, count - 1));
+    }
+    move(delta, count) {
+        if (this.kind === "detail") {
+            this.scroll = Math.max(0, this.scroll + delta);
+            return;
+        }
+        if (count <= 0)
+            return;
+        const t = this.top();
+        t.cursor = (t.cursor + delta + count) % count;
+    }
+    /** Drill into the selected item. Returns true if the view changed. */
+    drill(model) {
+        const t = this.top();
+        if (t.kind === "runs") {
+            const runs = model.runs();
+            const run = runs[t.cursor];
+            if (!run)
+                return false;
+            this.stack.push({ kind: "phases", cursor: 0, runId: run.runId });
+            return true;
+        }
+        if (t.kind === "phases" && t.runId) {
+            const phases = model.phases(t.runId);
+            const ph = phases[t.cursor];
+            if (!ph)
+                return false;
+            this.stack.push({ kind: "agents", cursor: 0, runId: t.runId, phase: ph.title });
+            return true;
+        }
+        if (t.kind === "agents" && t.runId && t.phase) {
+            const agents = model.agents(t.runId, t.phase);
+            const ag = agents[t.cursor];
+            if (!ag)
+                return false;
+            this.scroll = 0;
+            this.stack.push({ kind: "detail", cursor: 0, runId: t.runId, phase: t.phase, agentId: ag.id });
+            return true;
+        }
+        return false;
+    }
+    /** Pop one level. Returns false when already at the top (caller should close). */
+    back() {
+        if (this.stack.length <= 1)
+            return false;
+        this.stack.pop();
+        this.scroll = 0;
+        return true;
+    }
+    /** The runId the current view acts on (for pause/stop/save). */
+    activeRunId(model) {
+        if (this.runId)
+            return this.runId;
+        if (this.kind === "runs")
+            return model.runs()[this.cursor]?.runId;
+        return undefined;
+    }
+}
+function pad(n) {
+    return n.toLocaleString();
+}
+function fmtTokens(t) {
+    return t > 0 ? `${pad(t)} tok` : "";
+}
+/** Build the lines for the current view. Pure: depends only on state + model + theme. */
+export function renderNavigator(state, model, width, theme = PLAIN) {
+    const lines = [];
+    const sel = (i, text) => i === state.cursor ? theme.fg("accent", theme.bold(`❯ ${text}`)) : `  ${text}`;
+    const dim = (t) => theme.fg("dim", t);
+    if (state.kind === "runs") {
+        const runs = model.runs();
+        state.clamp(runs.length);
+        lines.push(theme.bold("Workflows"));
+        if (!runs.length)
+            lines.push(dim("  No runs yet. Start one with a background workflow."));
+        runs.forEach((r, i) => {
+            const icon = STATUS_ICON[r.status] ?? "?";
+            const meta = [`${r.done}/${r.total}`, fmtTokens(r.tokens)].filter(Boolean).join(" · ");
+            lines.push(sel(i, `${icon} ${r.name}  ${dim(`${r.runId} · ${r.status} · ${meta}`)}`));
+        });
+    }
+    else if (state.kind === "phases" && state.runId) {
+        const phases = model.phases(state.runId);
+        state.clamp(phases.length);
+        lines.push(theme.bold(model.runName(state.runId)) + dim(`  (${model.runStatus(state.runId)})`));
+        phases.forEach((p, i) => {
+            const meta = [`${p.done}/${p.total} agents`, fmtTokens(p.tokens)].filter(Boolean).join(" · ");
+            lines.push(sel(i, `${p.title}  ${dim(meta)}`));
+        });
+    }
+    else if (state.kind === "agents" && state.runId && state.phase) {
+        const agents = model.agents(state.runId, state.phase);
+        state.clamp(agents.length);
+        lines.push(theme.bold(`${model.runName(state.runId)} › ${state.phase}`));
+        agents.forEach((a, i) => {
+            const icon = STATUS_ICON[a.status] ?? "?";
+            const tok = a.tokens ? dim(` ${fmtTokens(a.tokens)}`) : "";
+            lines.push(sel(i, `${icon} ${a.label}${tok}`));
+        });
+    }
+    else if (state.kind === "detail" && state.runId && state.agentId != null) {
+        const a = model.agentDetail(state.runId, state.agentId);
+        lines.push(theme.bold(a ? a.label : "agent"));
+        if (a) {
+            const body = [];
+            body.push(dim("Status: ") + (a.status ?? ""));
+            if (a.error)
+                body.push(dim("Error: ") + a.error);
+            body.push("", dim("Prompt:"));
+            body.push(...wrap(a.prompt ?? "", width));
+            body.push("", dim("Result:"));
+            body.push(...wrap(a.resultPreview ?? "(none)", width));
+            // Scrollable region.
+            const maxScroll = Math.max(0, body.length - 1);
+            state.scroll = Math.min(state.scroll, maxScroll);
+            lines.push(...body.slice(state.scroll));
+        }
+    }
+    lines.push("");
+    lines.push(footerHint(state, theme));
+    return lines;
+}
+function footerHint(state, theme) {
+    const parts = state.kind === "detail"
+        ? ["j/k scroll", "esc back"]
+        : ["↑/↓ select", "enter open", "esc back", "p pause", "x stop", "r restart", "s save", "q quit"];
+    return theme.fg("dim", parts.join(" · "));
+}
+function wrap(text, width) {
+    const w = Math.max(20, width - 2);
+    const out = [];
+    for (const para of String(text).split("\n")) {
+        if (para.length <= w) {
+            out.push(para);
+            continue;
+        }
+        let rest = para;
+        while (rest.length > w) {
+            out.push(rest.slice(0, w));
+            rest = rest.slice(w);
+        }
+        if (rest)
+            out.push(rest);
+    }
+    return out;
+}
+export function keyToAction(keyId, kind) {
+    switch (keyId) {
+        case "up":
+            return { type: "move", delta: -1 };
+        case "down":
+            return { type: "move", delta: 1 };
+        case "k":
+            return { type: "move", delta: -1 };
+        case "j":
+            return { type: "move", delta: 1 };
+        case "enter":
+        case "return":
+        case "right":
+            return kind === "detail" ? { type: "none" } : { type: "drill" };
+        case "escape":
+        case "esc":
+        case "left":
+            return { type: "back" };
+        case "q":
+            return { type: "close" };
+        case "p":
+            return { type: "pause" };
+        case "x":
+            return { type: "stop" };
+        case "r":
+            return { type: "restart" };
+        case "s":
+            return { type: "save" };
+        default:
+            return { type: "none" };
+    }
+}
+function currentCount(state, model) {
+    if (state.kind === "runs")
+        return model.runs().length;
+    if (state.kind === "phases" && state.runId)
+        return model.phases(state.runId).length;
+    if (state.kind === "agents" && state.runId && state.phase)
+        return model.agents(state.runId, state.phase).length;
+    return 0;
+}
+/**
+ * Open the interactive `/workflows` navigator as a focused overlay. Resolves when
+ * the user closes it (esc at the top level, or `q`).
+ */
+export function openWorkflowNavigator(pi, manager, ui, opts = {}) {
+    const model = new NavigatorModel(manager);
+    const state = new NavigatorState();
+    return ui.custom((tui, theme, _keybindings, done) => {
+        const rerender = () => tui.requestRender();
+        const events = ["agentStart", "agentEnd", "phase", "log", "complete", "error", "stopped", "paused", "resumed"];
+        const onEvent = () => rerender();
+        for (const ev of events)
+            manager.on(ev, onEvent);
+        const cleanup = () => {
+            for (const ev of events)
+                manager.off(ev, onEvent);
+        };
+        const act = (data) => {
+            const action = keyToAction(parseKey(data), state.kind);
+            switch (action.type) {
+                case "move":
+                    state.move(action.delta, currentCount(state, model));
+                    break;
+                case "drill":
+                    state.drill(model);
+                    break;
+                case "back":
+                    if (!state.back()) {
+                        cleanup();
+                        done();
+                    }
+                    break;
+                case "close":
+                    cleanup();
+                    done();
+                    return;
+                case "pause": {
+                    const id = state.activeRunId(model);
+                    if (id)
+                        ui.notify(manager.pause(id) ? `Paused ${id}` : `Cannot pause ${id}`, "info");
+                    break;
+                }
+                case "stop": {
+                    const id = state.activeRunId(model);
+                    if (id)
+                        ui.notify(manager.stop(id) ? `Stopped ${id}` : `Cannot stop ${id}`, "info");
+                    break;
+                }
+                case "restart":
+                    ui.notify("Restarting a single agent isn't supported yet", "warning");
+                    break;
+                case "save": {
+                    const id = state.activeRunId(model);
+                    const run = id ? manager.listRuns().find((r) => r.runId === id) : undefined;
+                    if (!run?.script) {
+                        ui.notify("No saved run script to save", "warning");
+                    }
+                    else if (!opts.storage) {
+                        ui.notify("Saving is not available (no storage)", "error");
+                    }
+                    else {
+                        const name = run.workflowName || "workflow";
+                        const saved = opts.storage.save({
+                            name,
+                            description: run.workflowName,
+                            script: run.script,
+                            location: "project",
+                        });
+                        registerSavedWorkflow(pi, opts.cwd ?? process.cwd(), saved);
+                        ui.notify(`Saved /${name}`, "info");
+                    }
+                    break;
+                }
+                default:
+                    return;
+            }
+            rerender();
+        };
+        const component = {
+            render: (width) => renderNavigator(state, model, width, theme),
+            handleInput: (data) => act(data),
+            invalidate: () => { },
+            dispose: () => cleanup(),
+        };
+        return component;
+    }, { overlay: true });
+}

package/dist/workflow.d.ts

@@ -18,6 +18,23 @@ export interface JournalEntry {
     hash: string;
     result: unknown;
 }
+/**
+ * Global resources shared across a run and any workflow() nested inside it, so
+ * the 16-concurrent / 1000-total caps and the token budget hold across nesting
+ * instead of each level getting its own limiter and counters.
+ */
+export interface SharedRuntime {
+    limiter: <T>(fn: () => Promise<T>) => Promise<T>;
+    agentCount: number;
+    spent: number;
+    tokenUsage: {
+        input: number;
+        output: number;
+        total: number;
+        cost: number;
+    };
+    depth: number;
+}
 export interface WorkflowRunOptions extends WorkflowAgentOptions {
     args?: unknown;
     agent?: Pick<WorkflowAgent, "run">;
@@ -38,6 +55,10 @@ export interface WorkflowRunOptions extends WorkflowAgentOptions {
     resumeFromRunId?: string;
     /** Called after each live agent completes so the caller can persist the journal. */
     onAgentJournal?: (entry: JournalEntry) => void;
+    /** Internal: shared runtime inherited by a nested workflow() call. */
+    sharedRuntime?: SharedRuntime;
+    /** Resolve a saved-workflow name to its script, enabling `workflow('name', args)`. */
+    loadSavedWorkflow?: (name: string) => string | undefined;
     onLog?: (message: string) => void;
     onPhase?: (title: string) => void;
     onAgentStart?: (event: {

package/dist/workflow.js

@@ -27,14 +27,19 @@ export async function runWorkflow(script, options = {}) {
     const state = {
         logs: [],
         phases: [],
-        agentCount: 0,
         callSeq: 0,
-        spent: 0,
-        tokenUsage: { input: 0, output: 0, total: 0, cost: 0 },
     };
     const agentRunner = options.agent ?? new WorkflowAgent(options);
     const concurrency = Math.max(1, Math.min(options.concurrency ?? Math.max(1, (globalThis.navigator?.hardwareConcurrency ?? 8) - 2), MAX_CONCURRENCY));
-    const limiter = createLimiter(concurrency);
+    // Global caps + budget are shared with any nested workflow() so they hold across nesting.
+    const shared = options.sharedRuntime ?? {
+        limiter: createLimiter(concurrency),
+        agentCount: 0,
+        spent: 0,
+        tokenUsage: { input: 0, output: 0, total: 0, cost: 0 },
+        depth: 0,
+    };
+    const limiter = shared.limiter;
     const log = (message) => {
         const text = String(message);
         state.logs.push(text);
@@ -48,8 +53,8 @@ export async function runWorkflow(script, options = {}) {
     };
     const budget = Object.freeze({
         total: options.tokenBudget ?? null,
-        spent: () => state.spent,
-        remaining: () => (options.tokenBudget == null ? Infinity : Math.max(0, options.tokenBudget - state.spent)),
+        spent: () => shared.spent,
+        remaining: () => (options.tokenBudget == null ? Infinity : Math.max(0, options.tokenBudget - shared.spent)),
     });
     const throwIfAborted = () => {
         if (options.signal?.aborted) {
@@ -59,7 +64,7 @@ export async function runWorkflow(script, options = {}) {
     const agent = async (prompt, agentOptions = {}) => {
         throwIfAborted();
         // Check agent limit
-        if (state.agentCount >= maxAgents) {
+        if (shared.agentCount >= maxAgents) {
             throw new WorkflowError(`Agent limit exceeded (${maxAgents}). Use maxAgents option to increase the limit.`, WorkflowErrorCode.AGENT_LIMIT_EXCEEDED, { recoverable: false });
         }
         if (budget.total !== null && budget.remaining() <= 0) {
@@ -79,15 +84,15 @@ export async function runWorkflow(script, options = {}) {
         // consuming a concurrency slot, tokens, or a real subagent run.
         const cached = options.resumeJournal?.get(callIndex);
         if (cached && cached.hash === callHash) {
-            state.agentCount++;
-            const label = requestedLabel || defaultAgentLabel(assignedPhase, state.agentCount);
+            shared.agentCount++;
+            const label = requestedLabel || defaultAgentLabel(assignedPhase, shared.agentCount);
             options.onAgentStart?.({ label, phase: assignedPhase, prompt, model: modelSpec });
             options.onAgentEnd?.({ label, phase: assignedPhase, result: cached.result, tokens: 0 });
             return cached.result;
         }
         return limiter(async () => {
-            state.agentCount++;
-            const label = requestedLabel || defaultAgentLabel(assignedPhase, state.agentCount);
+            shared.agentCount++;
+            const label = requestedLabel || defaultAgentLabel(assignedPhase, shared.agentCount);
             const timeout = agentOptions.timeoutMs ?? agentTimeoutMs;
             options.onAgentStart?.({ label, phase: assignedPhase, prompt, model: modelSpec });
             // Optional per-agent worktree isolation (deterministic name -> stable resume keys).
@@ -104,12 +109,12 @@ export async function runWorkflow(script, options = {}) {
             const recordTokens = (result) => {
                 const tokens = usage && usage.total > 0 ? usage.total : estimateTokens(result) + estimateTokens(prompt);
                 if (usage) {
-                    state.tokenUsage.input += usage.input;
-                    state.tokenUsage.output += usage.output;
-                    state.tokenUsage.cost += usage.cost;
+                    shared.tokenUsage.input += usage.input;
+                    shared.tokenUsage.output += usage.output;
+                    shared.tokenUsage.cost += usage.cost;
                 }
-                state.tokenUsage.total += tokens;
-                state.spent += tokens;
+                shared.tokenUsage.total += tokens;
+                shared.spent += tokens;
                 return tokens;
             };
             try {
@@ -198,10 +203,40 @@ export async function runWorkflow(script, options = {}) {
             return value;
         }));
     };
+    // Nested workflow(): run a saved workflow (or a raw script) inline, sharing this
+    // run's limiter/counters/budget so the global caps hold. One level deep only.
+    const workflowFn = async (nameOrScript, childArgs) => {
+        throwIfAborted();
+        if (shared.depth >= 1) {
+            throw new WorkflowError("workflow() can nest only one level deep", WorkflowErrorCode.SCRIPT_VALIDATION_ERROR, {
+                recoverable: false,
+            });
+        }
+        const resolved = options.loadSavedWorkflow?.(String(nameOrScript));
+        const childScript = resolved ?? String(nameOrScript);
+        shared.depth++;
+        try {
+            const child = await runWorkflow(childScript, {
+                ...options,
+                args: childArgs,
+                sharedRuntime: shared,
+                // A nested run is its own script; never reuse the parent's resume journal.
+                resumeJournal: undefined,
+                resumeFromRunId: undefined,
+                runId: `${runId}-nested${shared.depth}`,
+                persistLogs: false,
+            });
+            return child.result;
+        }
+        finally {
+            shared.depth--;
+        }
+    };
     const context = vm.createContext({
         agent,
         parallel,
         pipeline,
+        workflow: workflowFn,
         log,
         phase,
         args: options.args,
@@ -233,16 +268,16 @@ export async function runWorkflow(script, options = {}) {
         log(`Logs persisted to ${logFile}`);
     }
     // Emit final token usage
-    options.onTokenUsage?.(state.tokenUsage);
+    options.onTokenUsage?.(shared.tokenUsage);
     return {
         meta,
         result: result,
         logs: state.logs,
         phases: state.phases,
-        agentCount: state.agentCount,
+        agentCount: shared.agentCount,
         durationMs: Date.now() - started,
         runId,
-        tokenUsage: state.tokenUsage,
+        tokenUsage: shared.tokenUsage,
     };
 }
 export function parseWorkflowScript(script) {

package/extensions/workflow.ts

@@ -1,7 +1,9 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   createWorkflowStorage,
   createWorkflowTool,
+  installResultDelivery,
+  installTaskPanel,
   registerAllSavedWorkflows,
   registerBuiltinWorkflows,
   registerWorkflowCommands,
@@ -12,19 +14,23 @@ export default function extension(pi: ExtensionAPI) {
   // Single manager/storage shared by the workflow tool and the /workflows command,
   // so background runs started by the tool are reachable from the command.
   const cwd = process.cwd();
-  const manager = new WorkflowManager({ cwd });
   const storage = createWorkflowStorage(cwd);
+  const manager = new WorkflowManager({ cwd, loadSavedWorkflow: (name) => storage.load(name)?.script });
 
   const workflowTool = createWorkflowTool({ cwd, manager, storage });
   pi.registerTool(workflowTool);
   registerWorkflowCommands(pi, manager, { storage, cwd });
   registerBuiltinWorkflows(pi, { cwd });
   registerAllSavedWorkflows(pi, cwd, storage);
+  // Deliver a background run's result into the conversation when it finishes.
+  installResultDelivery(pi, manager);
 
-  pi.on("session_start", () => {
+  pi.on("session_start", (_event: unknown, ctx: ExtensionContext) => {
     const active = pi.getActiveTools();
     if (!active.includes(workflowTool.name)) {
       pi.setActiveTools([...active, workflowTool.name]);
     }
+    // Live "workflows running" panel below the input (focus + enter to open).
+    installTaskPanel(pi, manager, ctx.ui, { storage, cwd });
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quintinshaw/pi-dynamic-workflows",
-  "version": "1.7.1",
+  "version": "1.9.0",
   "description": "Claude-Code-style dynamic workflow orchestration for Pi.",
   "type": "module",
   "main": "./dist/index.js",

package/src/index.ts

@@ -45,10 +45,12 @@ export {
 } from "./saved-commands.js";
 export type { StructuredOutputCapture, StructuredOutputToolOptions } from "./structured-output.js";
 export { createStructuredOutputTool } from "./structured-output.js";
+export { installResultDelivery, installTaskPanel, type TaskPanelOptions } from "./task-panel.js";
 export { createWebFetchTool, createWebSearchTool, createWebTools } from "./web-tools.js";
 export type {
   AgentOptions,
   JournalEntry,
+  SharedRuntime,
   WorkflowMeta,
   WorkflowMetaPhase,
   WorkflowRunOptions,
@@ -62,5 +64,14 @@ export type { SavedWorkflow, WorkflowStorage } from "./workflow-saved.js";
 export { createWorkflowStorage } from "./workflow-saved.js";
 export type { WorkflowToolInput, WorkflowToolOptions } from "./workflow-tool.js";
 export { createWorkflowTool } from "./workflow-tool.js";
+export {
+  keyToAction,
+  type NavAction,
+  NavigatorModel,
+  NavigatorState,
+  openWorkflowNavigator,
+  renderNavigator,
+  type ViewKind,
+} from "./workflow-ui.js";
 export type { Worktree } from "./worktree.js";
 export { createWorktree, removeWorktree } from "./worktree.js";