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

package/dist/src/host-runtime.js

@@ -0,0 +1,378 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { deepFreeze, errorCode, errorText, fail, isWorkflowErrorCode, jsonValue, object } from "./utils.js";
+import { validateAgentOptions, validateShellOptions, workflowPrompt } from "./validation.js";
+import { HARD_TERMINAL_RUN_STATES, WORKFLOW_AGENT_STATE_CHANGED_EVENT, WORKFLOW_BUDGET_EVENT, WORKFLOW_CHECKPOINT_STATE_CHANGED_EVENT, WORKFLOW_PHASE_CHANGED_EVENT, WORKFLOW_RUN_COMPLETED_EVENT, WORKFLOW_RUN_FAILED_EVENT, WORKFLOW_RUN_RESUMED_EVENT, WORKFLOW_RUN_STARTED_EVENT, WORKFLOW_RUN_STATE_CHANGED_EVENT, WORKFLOW_WORKTREE_CREATED_EVENT, WorkflowError } from "./types.js";
+import { structuralPath as operationPath } from "./persistence.js";
+const inheritedHostAgentPath = new AsyncLocalStorage();
+const inheritedHostWorktreeOwner = new AsyncLocalStorage();
+/** Drops the transient shell-activity counters a run only holds while its host process is alive. */
+export function withoutActiveShells(run) {
+    const next = { ...run };
+    delete next.activeShells;
+    delete next.activeShellStartedAt;
+    delete next.activeShellsByPhase;
+    return next;
+}
+/** Reads the project cwd and Pi session ID that an extension context exposes, when present. */
+export function hostSessionContext(context) {
+    const host = object(context) ? context : {};
+    const cwd = typeof host.cwd === "string" ? host.cwd : undefined;
+    const sessionManager = object(host.sessionManager) ? host.sessionManager : undefined;
+    const sessionId = typeof sessionManager?.getSessionId === "function" ? String(Reflect.apply(sessionManager.getSessionId, sessionManager, [])) : undefined;
+    return { ...(cwd === undefined ? {} : { cwd }), ...(sessionId === undefined ? {} : { sessionId }) };
+}
+export class RunLifecycle {
+    changed;
+    #state;
+    #active = 0;
+    #waiters = [];
+    constructor(state = "running", changed) {
+        this.changed = changed;
+        this.#state = state;
+    }
+    get state() { return this.#state; }
+    async enter() {
+        while (this.#state === "pausing" || this.#state === "paused" || this.#state === "awaiting_input")
+            await new Promise((resolve) => { this.#waiters.push(resolve); });
+        if (this.#state !== "running")
+            throw new WorkflowError("CANCELLED", `Run is ${this.#state}`);
+        this.#active += 1;
+    }
+    async leave() {
+        if (this.#active > 0)
+            this.#active -= 1;
+        if (this.#state === "pausing" && this.#active === 0)
+            await this.#set("paused", "pause");
+    }
+    async enterAwaitingInput() {
+        while (this.#state === "pausing" || this.#state === "paused")
+            await new Promise((resolve) => { this.#waiters.push(resolve); });
+        if (this.#state === "awaiting_input")
+            return;
+        if (this.#state !== "running")
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot await input for ${this.#state} run`);
+        await this.#set("awaiting_input", "awaiting_input");
+    }
+    async resolveAwaitingInput() {
+        if (this.#state !== "awaiting_input")
+            return;
+        await this.#set("running", "checkpoint_resolved");
+        for (const resolve of this.#waiters.splice(0))
+            resolve();
+    }
+    async pause() {
+        if (this.#state !== "running")
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot pause ${this.#state} run`);
+        await this.#set("pausing", "pause");
+        if (this.#active === 0 && this.state === "pausing")
+            await this.#set("paused", "pause");
+    }
+    /** Resumes a paused, interrupted, or budget-exhausted run; on a `pausing` run it cancels the pending pause instead. */
+    async resume() {
+        if (this.#state !== "pausing" && this.#state !== "paused" && this.#state !== "interrupted" && this.#state !== "budget_exhausted")
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot resume ${this.#state} run`);
+        await this.#set("running", "resume");
+        for (const resolve of this.#waiters.splice(0))
+            resolve();
+    }
+    async providerPause() {
+        await this.leave();
+        if (this.#state === "running")
+            await this.pause();
+        await this.enter();
+    }
+    async terminal(state, reason) {
+        if (HARD_TERMINAL_RUN_STATES.has(this.#state))
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `${this.#state} runs are terminal`);
+        await this.#set(state, reason ?? state);
+        for (const resolve of this.#waiters.splice(0))
+            resolve();
+    }
+    async #set(state, reason) {
+        const previousState = this.#state;
+        this.#state = state;
+        await this.changed?.(state, previousState, reason);
+    }
+}
+function safeEventError(error) {
+    const code = errorCode(error) ?? "INTERNAL_ERROR";
+    return { code, message: `Workflow execution failed (${code})` };
+}
+export class WorkflowEventPublisher {
+    sink;
+    #queues = new Map();
+    #budgetEvents = new Map();
+    #worktrees = new Map();
+    constructor(sink) {
+        this.sink = sink;
+    }
+    removeRun(runId) {
+        this.#queues.delete(runId);
+        this.#budgetEvents.delete(runId);
+        this.#worktrees.delete(runId);
+    }
+    seedBudget(runId, events) {
+        const seen = this.#budgetEvents.get(runId) ?? new Set();
+        for (const event of events ?? [])
+            seen.add(this.budgetKey(event));
+        this.#budgetEvents.set(runId, seen);
+    }
+    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 } : {}), ...(isWorkflowErrorCode(reason) ? { errorCode: reason } : {}) });
+        if ((previousState === "paused" || previousState === "interrupted" || previousState === "budget_exhausted") && state === "running")
+            await this.runResumed(store, metadata);
+    }
+    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) });
+    }
+    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 });
+    }
+    async agentStates(store, metadata, previous, current) {
+        const previousById = new Map(previous.map((agent) => [agent.id, agent]));
+        for (const agent of current) {
+            const old = previousById.get(agent.id);
+            if (!old || old.state !== agent.state || old.attempts !== agent.attempts)
+                await this.agentState(store, metadata, old, agent);
+        }
+    }
+    async phase(store, metadata, previousPhase, phase) {
+        if (previousPhase !== phase)
+            await this.#publish(store, metadata, WORKFLOW_PHASE_CHANGED_EVENT, { ...(previousPhase !== undefined ? { previousPhase } : {}), phase });
+    }
+    async checkpoint(store, metadata, name, state) { await this.#publish(store, metadata, WORKFLOW_CHECKPOINT_STATE_CHANGED_EVENT, { name, state }); }
+    async budget(store, metadata, run) {
+        const seen = this.#budgetEvents.get(store.runId) ?? new Set();
+        this.#budgetEvents.set(store.runId, seen);
+        for (const event of run.budgetEvents ?? []) {
+            const key = this.budgetKey(event);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            await this.#publish(store, metadata, WORKFLOW_BUDGET_EVENT, { ...event, timestamp: event.at });
+        }
+    }
+    async worktree(store, metadata, worktree) {
+        const seen = this.#worktrees.get(store.runId) ?? new Set();
+        this.#worktrees.set(store.runId, seen);
+        if (seen.has(worktree.owner))
+            return;
+        seen.add(worktree.owner);
+        await this.#publish(store, metadata, WORKFLOW_WORKTREE_CREATED_EVENT, { owner: worktree.owner, branch: worktree.branch, path: worktree.path, base: worktree.base });
+    }
+    async #publish(store, metadata, name, payload) {
+        const base = { runId: store.runId, sessionId: store.sessionId, workflowName: metadata.name, cwd: store.cwd, runDirectory: store.directory, timestamp: Date.now() };
+        const previous = this.#queues.get(store.runId) ?? Promise.resolve();
+        const next = previous.then(() => {
+            try {
+                void Promise.resolve(this.sink?.emit(name, { ...base, ...payload })).catch(() => undefined);
+            }
+            catch { /* Best effort: listeners cannot affect a run. */ }
+        });
+        this.#queues.set(store.runId, next.catch(() => undefined));
+        await next;
+    }
+    budgetKey(event) { return `${String(event.budgetVersion)}:${event.type}:${event.proposalId ?? ""}`; }
+}
+function namedRecord(value, kind) {
+    if (!object(value))
+        fail("INVALID_METADATA", `${kind} must be a record`);
+    return Object.entries(value);
+}
+function publicWorktreeReference(reference) {
+    if (!object(reference) || typeof reference.path !== "string" || typeof reference.branch !== "string")
+        fail("WORKTREE_FAILED", "Worktree reference is invalid");
+    return Object.freeze({ path: reference.path, branch: reference.branch });
+}
+async function hostWithWorktree(name, callback, resolveWorktree, signal) {
+    if (typeof name !== "string" || !name.trim())
+        fail("INVALID_METADATA", "withWorktree name must be a non-empty string");
+    if (typeof callback !== "function")
+        fail("INVALID_METADATA", "withWorktree callback must be a function");
+    if (!resolveWorktree)
+        fail("WORKTREE_FAILED", "No worktree bridge is available");
+    const owner = operationPath("worktree", "named", name.trim());
+    const reference = publicWorktreeReference(await resolveWorktree(owner, signal));
+    return inheritedHostWorktreeOwner.run(owner, () => callback(reference));
+}
+export function workflowRunContext(cwd, sessionId, runId, workflow, args, signal) {
+    return Object.freeze({ cwd, sessionId, runId, workflow: deepFreeze(structuredClone(workflow)), args: deepFreeze(structuredClone(args)), signal });
+}
+function keyedJsonResult(entries) {
+    return Object.fromEntries(entries);
+}
+async function hostParallel(rawOperation, rawTasks) {
+    if (typeof rawOperation !== "string" || !rawOperation.trim())
+        fail("INVALID_METADATA", "parallel requires a stable explicit name");
+    const tasks = namedRecord(rawTasks, "parallel tasks");
+    for (const [name, run] of tasks) {
+        if (!name.trim())
+            fail("INVALID_METADATA", "parallel task requires a stable explicit name");
+        if (typeof run !== "function")
+            fail("INVALID_METADATA", "parallel task values must be run functions");
+    }
+    const results = await Promise.all(tasks.map(async ([name, run]) => {
+        try {
+            const parent = inheritedHostAgentPath.getStore() ?? [];
+            const value = await inheritedHostAgentPath.run([...parent, rawOperation, name], run);
+            if (!jsonValue(value))
+                fail("RESULT_INVALID", "parallel task result must be JSON-compatible");
+            return { name, value };
+        }
+        catch (error) {
+            const typed = error instanceof WorkflowError ? error : new WorkflowError("INTERNAL_ERROR", errorText(error));
+            if (typed.code === "CANCELLED")
+                throw typed;
+            return { name, error: typed };
+        }
+    }));
+    const failure = results.find((result) => result.error);
+    if (failure?.error)
+        throw failure.error;
+    return keyedJsonResult(results.flatMap((result) => "value" in result ? [[result.name, result.value]] : []));
+}
+async function hostPipeline(rawOperation, rawItems, rawStages) {
+    if (typeof rawOperation !== "string" || !rawOperation.trim())
+        fail("INVALID_METADATA", "pipeline requires a stable explicit name");
+    const items = namedRecord(rawItems, "pipeline items");
+    const stages = namedRecord(rawStages, "pipeline stages");
+    if (!stages.length)
+        fail("INVALID_METADATA", "pipeline requires at least one stage");
+    for (const [name] of items)
+        if (!name.trim())
+            fail("INVALID_METADATA", "pipeline item requires a stable explicit name");
+    for (const [stageName, run] of stages) {
+        if (!stageName.trim())
+            fail("INVALID_METADATA", "pipeline stage requires a stable explicit name");
+        if (typeof run !== "function")
+            fail("INVALID_METADATA", "pipeline stage values must be run functions");
+    }
+    const results = await Promise.all(items.map(async ([name, initial]) => {
+        let current = initial;
+        try {
+            for (const [stageName, run] of stages) {
+                const parent = inheritedHostAgentPath.getStore() ?? [];
+                const value = await inheritedHostAgentPath.run([...parent, rawOperation, name, stageName], () => run(current));
+                if (!jsonValue(value))
+                    fail("RESULT_INVALID", "pipeline stage result must be JSON-compatible");
+                current = value;
+            }
+            if (!jsonValue(current))
+                fail("RESULT_INVALID", "pipeline result must be JSON-compatible");
+            return { name, value: current };
+        }
+        catch (error) {
+            const typed = error instanceof WorkflowError ? error : new WorkflowError("INTERNAL_ERROR", errorText(error));
+            if (typed.code === "CANCELLED")
+                throw typed;
+            return { name, error: typed };
+        }
+    }));
+    const failure = results.find((result) => result.error);
+    if (failure?.error)
+        throw failure.error;
+    return Object.fromEntries(results.flatMap((result) => "value" in result ? [[result.name, result.value]] : []));
+}
+export function nextNamedOccurrence(counters, label) {
+    const count = (counters.get(label) ?? 0) + 1;
+    counters.set(label, count);
+    return count === 1 ? label : `${label}#${String(count)}`;
+}
+function functionBreadcrumb(name, occurrence) { return occurrence === 1 ? name : `${name} #${String(occurrence)}`; }
+export function withWorkflowFunctions(bridge, store, runContext, registry, settings = Object.freeze({})) {
+    const functionAgentOccurrences = new Map();
+    const functionShellOccurrences = new Map();
+    const functionInvokeOccurrences = new Map();
+    const functionInvokeBreadcrumbOccurrences = new Map();
+    const invokeFunction = async (name, input, signal, identity, breadcrumb) => {
+        const path = identity.path;
+        const structuralPath = identity.structuralPath;
+        const worktreeOwner = identity.worktreeOwner;
+        const replayed = await store.replay(path);
+        let stored;
+        const sideEffects = [];
+        const ownSideEffect = (effect) => {
+            let sideEffect;
+            try {
+                sideEffect = Promise.resolve(effect());
+            }
+            catch (error) {
+                sideEffect = Promise.resolve().then(() => { throw error; });
+            }
+            sideEffects.push(sideEffect);
+            // Own rejection immediately; Promise.all below still propagates it after the function completes.
+            void sideEffect.catch(() => undefined);
+        };
+        const parentBreadcrumb = breadcrumb ?? functionBreadcrumb(name, identity.occurrence);
+        const context = {
+            settings: deepFreeze(structuredClone(settings)),
+            run: runContext,
+            invoke: async (targetName, targetInput, label) => {
+                if (label !== undefined && (typeof label !== "string" || !label.trim()))
+                    fail("INVALID_METADATA", "invoke label must be a non-empty string");
+                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 breadcrumbName = label === undefined ? targetName : label;
+                const breadcrumbKey = JSON.stringify([path, inherited, breadcrumbName]);
+                const breadcrumbOccurrence = (functionInvokeBreadcrumbOccurrences.get(breadcrumbKey) ?? 0) + 1;
+                functionInvokeBreadcrumbOccurrences.set(breadcrumbKey, breadcrumbOccurrence);
+                const nestedPath = operationPath("function", "nested", path, ...inherited, targetName, `occurrence:${String(occurrence)}`);
+                const nestedIdentity = { path: nestedPath, structuralPath: [...inherited], occurrence, ...(scopedWorktreeOwner ? { worktreeOwner: scopedWorktreeOwner } : {}) };
+                return invokeFunction(targetName, targetInput, signal, nestedIdentity, `${parentBreadcrumb} > ${functionBreadcrumb(breadcrumbName, breadcrumbOccurrence)}`);
+            },
+            agent: async (prompt, options) => {
+                if (!bridge.agent || typeof prompt !== "string")
+                    fail("AGENT_FAILED", "No agent bridge is available");
+                const validatedOptions = validateAgentOptions(options === undefined ? {} : options);
+                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(prompt, validatedOptions, signal, { structuralPath: [...inherited], callSite: `function:${path}`, occurrence, parentBreadcrumb, ...(scopedWorktreeOwner ? { worktreeOwner: scopedWorktreeOwner } : {}) });
+            },
+            shell: async (...args) => {
+                if (!bridge.shell)
+                    fail("SHELL_FAILED", "No shell bridge is available");
+                if (typeof args[0] !== "string")
+                    fail("INVALID_METADATA", "shell command must be a string");
+                const options = validateShellOptions(args[1] === undefined ? {} : args[1]);
+                const scopedWorktreeOwner = inheritedHostWorktreeOwner.getStore() ?? worktreeOwner;
+                const inherited = inheritedHostAgentPath.getStore() ?? [];
+                const key = `${path}\0${JSON.stringify([inherited, scopedWorktreeOwner ?? null])}`;
+                const occurrence = (functionShellOccurrences.get(key) ?? 0) + 1;
+                functionShellOccurrences.set(key, occurrence);
+                return bridge.shell(args[0], options, signal, { structuralPath: [...inherited], callSite: `function:${path}`, occurrence, ...(scopedWorktreeOwner ? { worktreeOwner: scopedWorktreeOwner } : {}) });
+            },
+            prompt: workflowPrompt,
+            parallel: (operationName, tasks) => hostParallel(operationName, tasks),
+            pipeline: (operationName, items, stages) => hostPipeline(operationName, items, stages),
+            withWorktree: (name, callback) => hostWithWorktree(name, callback, bridge.worktree, signal),
+            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) => { ownSideEffect(() => bridge.phase?.(name)); },
+            log: (message) => { ownSideEffect(() => 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(), function: (name, input, signal, identity) => {
+            const expectedPath = operationPath("function", ...identity.structuralPath, name, String(identity.occurrence));
+            if (identity.path !== expectedPath)
+                fail("INTERNAL_ERROR", "Workflow function identity path is inconsistent");
+            return invokeFunction(name, input, signal, identity);
+        } };
+}

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

@@ -0,0 +1,116 @@
+import { type Theme } from "@earendil-works/pi-coding-agent";
+import { type AwaitingCheckpoint, type PersistedRun, type RunStore, type WorktreeReference } from "./persistence.js";
+import { type AgentAccounting, type AgentAttemptAction, type AgentAttemptActionContext, type AgentRecord, type LaunchSnapshot, type StandaloneAgentAttemptActionContext } from "./types.js";
+import { type WorkflowPhaseSelection } from "./host-phases.js";
+export { SETTLED_AGENT_STATES } from "./types.js";
+export interface WorkflowProgressStyles {
+    accent(text: string): string;
+    success(text: string): string;
+    error(text: string): string;
+    warning(text: string): string;
+    muted(text: string): string;
+    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 function textBlock(text: string): {
+    render(width: number): string[];
+    invalidate(): void;
+};
+export declare function styledTextBlock(text: string): {
+    render(width: number): string[];
+    invalidate(): void;
+};
+export declare function workflowCatalogBlock(text: string, expanded: boolean): {
+    render(width: number): string[];
+    invalidate(): void;
+};
+export declare function workflowControlCall(name: string, args: Record<string, unknown>, theme: Theme): string;
+export declare function workflowControlResult(name: string, args: Record<string, unknown>, result: CatalogToolResult, expanded: boolean, theme: Theme, isError: boolean): string;
+type CatalogToolResult = {
+    details?: unknown;
+    content?: readonly {
+        type: string;
+        text?: string;
+    }[];
+};
+export declare function catalogResultValue(result: CatalogToolResult): unknown;
+export declare function formatWorkflowCatalog(value: unknown, expanded: boolean, theme: Theme): string;
+export declare function truncateWorkflowProgress(text: string, width: number): string[];
+export declare function themeWorkflowProgressStyles(theme: Theme): WorkflowProgressStyles;
+export type WorkflowProgressRefreshState = {
+    runId: string;
+    inputRun: PersistedRun;
+    run: PersistedRun;
+    lastRefreshAt: number;
+    runtimeStartedAt: number;
+    runtimeBaseMs: number;
+    refresh?: Promise<void>;
+};
+export type WorkflowProgressRenderState = {
+    workflowSpinner?: ReturnType<typeof setInterval>;
+    workflowProgress?: WorkflowProgressRefreshState;
+    workflowProgressComponent?: ReturnType<typeof workflowProgressBlock>;
+    workflowProgressFrozenAt?: number;
+};
+export declare function workflowProgressBlock(run: PersistedRun, theme: Theme, progress?: WorkflowProgressRefreshState, refresh?: () => Promise<PersistedRun | undefined>, invalidate?: () => void, prefix?: string, freezeAt?: number): {
+    render(width: number): string[];
+    setExpanded(value: boolean): void;
+    invalidate(): void;
+};
+export declare function formatBudgetStatus(run: Pick<PersistedRun, "budget" | "budgetVersion" | "usage" | "budgetEvents">): string[];
+export declare function navigatorAttentionSortByState<T>(entries: readonly T[], stateOf: (entry: T) => string, resolvedAtOf: (entry: T) => number | undefined, stateOrder?: Readonly<Record<string, number>>): T[];
+export declare function navigatorAttentionSort<T extends {
+    loaded: {
+        run: PersistedRun;
+    };
+    resolvedAt?: number | undefined;
+}>(entries: readonly T[]): T[];
+export declare function navigatorRunLabels(entries: readonly {
+    store: RunStore;
+    loaded: {
+        run: PersistedRun;
+    };
+}[]): string[];
+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 interface AgentDetailPresentation {
+    readonly state: string;
+    readonly activity?: AgentRecord["activity"];
+    readonly lastEventAt?: number;
+    readonly structuralPath?: readonly string[];
+    readonly model?: AgentRecord["model"];
+    readonly role?: string;
+    readonly tools?: readonly string[];
+    readonly attempts?: number;
+    readonly startedAt?: number;
+    readonly finishedAt?: number;
+    readonly durationMs?: number;
+    readonly accounting?: AgentAccounting;
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+    };
+}
+export declare function formatAgentDetail(agent: Readonly<AgentDetailPresentation>, styles?: WorkflowProgressStyles, now?: number, options?: Readonly<{
+    includeError?: boolean;
+}>): string[];
+export interface AgentActionPresentation {
+    readonly extensionLabels: readonly string[];
+    readonly hasWorktree: boolean;
+    readonly openPrompt: boolean;
+    readonly openSystemPrompt: boolean;
+    readonly openResult: boolean;
+    readonly standaloneState?: "running" | "completed" | "failed" | "stopped";
+}
+export declare function agentActionLabels(options: Readonly<AgentActionPresentation>): string[];
+export declare function visibleAgentAttemptActions(actions: Readonly<Record<string, AgentAttemptAction>>, context: Readonly<AgentAttemptActionContext>): readonly [string, AgentAttemptAction][];
+export declare function visibleStandaloneAgentAttemptActions(actions: Readonly<Record<string, AgentAttemptAction>>, context: Readonly<StandaloneAgentAttemptActionContext>): readonly [string, AgentAttemptAction][];
+export declare function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonly AwaitingCheckpoint[], worktrees: readonly WorktreeReference[], now?: number): string;
+export declare function formatNavigatorRun(loaded: {
+    run: PersistedRun;
+    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[];
+export declare function formatCheckpointReview(checkpoint: AwaitingCheckpoint): string;