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

package/CHANGELOG.md

@@ -1,6 +1,73 @@
 # Changelog
 ## Unreleased
 
+## [5.17.0] - 2026-09-23
+
+### New capabilities
+
+- `/subagents` opens the `/workflow` dashboard layout instead of a picker followed by a `key=value` detail dump. The run list sits beside the selected run's details at 80 columns or wider and drills down from list to details to actions below that, with the same configured and vim key hints and page scrolling. While a run is active, the active runs and the selection refresh every second. Details show the run ID and the shared agent fields in the `/workflow` agent order; the prompt, live system prompt, and result open in the editor, as in `/workflow`, and editor and copy actions leave the action menu open. A running run shows its live activity through the new opt-in `includeActivity` inspection context; `subagents_inspect` still leaves activity out. A retry selects the new run, and a repeated name carries its short ID in the list, as in the `/workflow` picker. Outside the TUI, the picker rows follow the `/workflow` picker: state glyph, name, state, model, cost, and runtime.
+- `/subagents` gains the `/workflow` run actions that apply to standalone runs: `Delete`, `Delete all completed`, and `Delete all failed` (also in the picker outside the TUI), and `Copy run path`. Stop and deletions ask for confirmation. `SubagentManager` gains an optional `delete(request, context)` that removes a settled record and refuses running runs and runs whose worktree cleanup is pending; it is not a model tool.
+- Background subagents appear below the editor in the workflow widget's frame, one row per run with model, tokens, cost, elapsed time, and quiet or stalled warnings, and each leaves a receipt in the transcript when it settles, like a background workflow run.
+- The `subagents_run` result header shows tokens and cost, like the workflow header.
+
+### Fixes
+
+- Declining the Stop confirmation in the `/workflow` dashboard no longer leaves Pi stuck. Pi's confirm dialog replaced the dashboard and then restored the editor, so the `/workflow` command never finished: later messages and extension commands such as `/subagents` queued without running, and the workflow widget stayed hidden. The question now appears inside the dashboard, as in `/subagents`; declining keeps the dashboard open on the action menu.
+- A subagent that settled just before its manager was disposed, for example at session shutdown, no longer stays `running` on disk. Disposal skipped the terminal status write, and a new manager in the same Pi process treated the record as owned by a live process, so it kept showing as running and could not be retried.
+
+## [5.16.3] - 2026-09-23
+
+### Fixes
+
+- A live foreground workflow block taller than the terminal no longer snaps pi's scrollback to the bottom on every update. Past `rows - 10` lines the block turns compact: finished phases collapse to one summary line (done, failed, wall time, tokens, cost) plus their failures, and the current phase lists failed, active, and the three latest settled agents with a count of the rest. `ctrl+o` still shows everything, and a finished block keeps the full list.
+
+## [5.16.2] - 2026-09-23
+
+### New capabilities
+
+- Trajectory highlights workflow scripts, JSON values (tool and workflow arguments, environment, and output), and fenced code in messages with a vendored Prism 1.30.0 build (JavaScript, TypeScript, JSON, bash, diff, Python).
+- Trajectory lists runs by newest completion with active runs on top. Each session shows every active run or subagent and at least three in total; the rest sit behind a "+ N more" toggle that is remembered per browser, and the selected entry always stays visible.
+
+### Fixes
+
+- Pi no longer adopts a Trajectory server that answers on the port without owning the lock, such as an older server whose lock was lost. `/health` now reports the server pid and fingerprint; a mismatching server that reports its pid is replaced, and one without an identity fails the attach with a clear error instead of serving outdated code indefinitely.
+
+## [5.16.1] - 2026-09-23
+
+### Fixes
+
+- Trajectory no longer blanks a live subagent's or agent's events for about a second when its transcript grows between a state poll and the transcript read; the stale reply keeps the cached entries until the newer revision arrives.
+
+## [5.16.0] - 2026-09-23
+
+### Breaking changes
+
+- `extensionSettings.trajectory.themes` is removed; settings files that still set it fail validation. Persisted launch snapshots that carry it still load.
+
+### New capabilities
+
+- Trajectory has a paper-style look in light and dark versions. It follows the system colour scheme, and a sidebar toggle overrides it per browser. On phones it shows one panel at a time, with Runs, Trace, and Details tabs.
+- The Trajectory inspector shows workflow arguments (bounded for large values) (#300) and an Agent details Output tab (#301).
+
+### Performance
+
+- Foreground workflow progress bursts collapse to one update per 100ms, and progress reads `state.json` alone instead of state plus snapshot, so Pi no longer re-renders the whole tool block for every agent event.
+- Trajectory ships tool timing only for the run a browser shows and omits timing it already delivered at the same revision. The gantt patches only changed lanes and merges tool calls that overlap on screen.
+- Trajectory publishers poll every 10s while no browser is attached, and hidden tabs skip rendering.
+
+### Fixes
+
+- A Trajectory browser tab that drops without a WebSocket close frame is released, so viewer counts and pending requests no longer leak.
+- Live Trajectory timing keeps the newest entries within its 64 KB per-agent budget, so a long agent's gantt keeps growing instead of freezing on its first calls.
+- `piewf` `npx` examples use the scoped `@piewf/cli` package.
+
+## [5.15.0] - 2026-09-18
+
+### New capabilities
+
+- Roles are exposed as a standalone `pi-extensible-workflows/roles` subpath (`discoverRoles`, `loadRole`, `resolveRole`) that resolves a role into plain data (model, tools, skills, extensions, prompt, context file scopes, unmatched selectors) without a workflow run; the workflow executor, validation, CLI, and subagents consume the same implementation (#294).
+- `@piewf/cli` adds a `pi-role <role> [pi arguments...]` launcher that resolves a role and starts the regular Pi CLI with the matching model, tools, skills, extensions, and system prompt arguments; remaining arguments are forwarded to Pi (#295).
+
 ## [5.14.1] - 2026-09-17
 
 ### Fixes

package/dist/src/agent-execution.js

@@ -7,7 +7,7 @@ import { Type } from "@earendil-works/pi-ai";
 import { Compile } from "typebox/compile";
 import { createAgentSession, DefaultPackageManager, DefaultResourceLoader, defineTool, getAgentDir, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
 ;
-import { SerialLane, assertModelThinking, byPriorityThenName, deepFreeze, errorText, jsonObject, jsonValue, mergeWorkflowExtensionSettings, object, modelAliasName, modelCapability, resolveModelReference, resourcePatternHasMagic, selectResourcesByLayers, unmatchedResourcePatterns } from "./utils.js";
+import { SerialLane, assertModelThinking, byPriorityThenName, deepFreeze, errorText, jsonObject, jsonValue, mergeWorkflowExtensionSettings, object, resolveModelReference, resourcePatternHasMagic, unmatchedResourcePatterns } from "./utils.js";
 import { SETTLED_AGENT_STATES, WorkflowError, isContextFileScope, zeroAccounting } from "./types.js";
 import { createLiveSessionHandoff } from "./session-handoff.js";
 import { createToolTimingExtension } from "./tool-timing.js";
@@ -16,6 +16,7 @@ import { createPiRuntimeAgentRunner, isRuntimeAgentProviderError, normalizePiRun
 import { defaultWorkflowResultSchema } from "./runtime/workflow-result.js";
 import { validateAgentOptions, validateSchema } from "./validation.js";
 import { canonicalPath } from "./paths.js";
+import { canonicalExtensionSelector, resolveRole } from "./roles.js";
 const localToolTimingExtension = createToolTimingExtension();
 function parseModel(value, fallback, aliases = {}, knownModels, settingsPath) {
     if (!value)
@@ -36,16 +37,6 @@ const WORKFLOW_HOST_ENTRIES = new Set([
     canonicalPath(resolve(workflowPackageRoot, "subagents/index.ts")),
     canonicalPath(resolve(workflowPackageRoot, "dist/subagents/index.js")),
 ]);
-function canonicalExtensionSelector(selector, base = process.cwd()) {
-    const negated = selector.startsWith("!");
-    const body = negated ? selector.slice(1) : selector;
-    if (body === "*" || body === "**" || body.startsWith("**/"))
-        return selector;
-    const resolved = resolve(base, body);
-    if (resourcePatternHasMagic(body))
-        return `${negated ? "!" : ""}${resolved}`;
-    return `${negated ? "!" : ""}${canonicalPath(resolved)}`;
-}
 const WORKFLOW_DIRECTORY = "pi-extensible-workflows";
 function workflowSystemPromptPath(cwd, agentDir, projectTrusted) {
     const projectPath = join(cwd, ".pi", WORKFLOW_DIRECTORY, "SYSTEM.md");
@@ -205,20 +196,22 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
         const resolved = await packageManager.resolve();
         const discoveredExtensions = [...new Set(resolved.extensions.filter(({ enabled, metadata }) => enabled && (policy.projectTrusted || metadata.scope !== "project")).map(({ path }) => canonicalPath(path)))];
         const selectorSources = policy.selectorSources;
-        const extensionLayers = [selectorSources.global.extensions, selectorSources.project.extensions, selectorSources.role?.extensions, selectorSources.call?.extensions];
-        const extensionSelectors = extensionLayers.flatMap((layer) => (layer ?? []).map((original) => ({ original, matching: canonicalExtensionSelector(original, input.cwd) })));
-        const selectedExtensions = selectResourcesByLayers(extensionLayers.map((layer) => layer?.map((selector) => canonicalExtensionSelector(selector, input.cwd))), discoveredExtensions);
+        const selection = resolveRole(undefined, {
+            cwd: input.cwd,
+            selectorSources,
+            resources: { extensions: discoveredExtensions },
+        });
+        const selectedExtensions = selection.selectedExtensions ?? [];
         const extensionPaths = selectedExtensions.filter((path) => !WORKFLOW_HOST_ENTRIES.has(path));
-        const unmatchedExtensions = extensionSelectors.filter(({ matching }) => unmatchedResourcePatterns([matching], discoveredExtensions).length > 0).map(({ original }) => original);
         policy.selectedExtensions = selectedExtensions;
-        policy.unmatchedExtensions = unmatchedExtensions;
+        policy.unmatchedExtensions = selection.unmatchedExtensions ?? [];
         const skillPaths = [...new Set(resolved.skills.filter(({ enabled, metadata }) => enabled && (policy.projectTrusted || metadata.scope !== "project")).map(({ path }) => path))];
         const updateSkillMatches = (skills) => {
             const names = [...new Set(skills.map(({ name }) => name))];
-            const skillLayers = [selectorSources.global.skills, selectorSources.project.skills, selectorSources.role?.skills, selectorSources.call?.skills];
-            const selectedSkills = selectResourcesByLayers(skillLayers, names);
+            const selected = resolveRole(undefined, { cwd: input.cwd, selectorSources, resources: { skills: names } });
+            const selectedSkills = selected.selectedSkills ?? [];
             policy.selectedSkills = selectedSkills;
-            policy.unmatchedSkills = unmatchedResourcePatterns(skillLayers.flatMap((layer) => layer ?? []), names);
+            policy.unmatchedSkills = selected.unmatchedSkills ?? [];
             return new Set(names.filter((name) => !selectedSkills.includes(name)));
         };
         resourceLoader = new DefaultResourceLoader({
@@ -944,7 +937,6 @@ export class WorkflowAgentExecutor {
         const roleDefinition = roleName ? this.root.agentDefinitions?.[roleName] : undefined;
         if (roleName && !roleDefinition)
             throw new WorkflowError("UNKNOWN_AGENT_TYPE", `Unknown agent role: ${roleName}`);
-        const candidateTools = inheritedTools !== undefined ? [...inheritedTools] : [...this.root.tools];
         if (inheritedTools === undefined)
             for (const pattern of roleDefinition?.tools ?? []) {
                 const body = pattern.startsWith("!") ? pattern.slice(1) : pattern;
@@ -956,37 +948,30 @@ export class WorkflowAgentExecutor {
                     }
                 }
             }
-        const selectorLayers = [
-            this.root.resourceSelectors?.tools,
-            roleDefinition?.tools,
-            options.tools,
-        ];
-        for (const pattern of options.tools ?? []) {
-            const body = pattern.startsWith("!") ? pattern.slice(1) : pattern;
-            if (!pattern.startsWith("!") && !resourcePatternHasMagic(pattern) && !candidateTools.includes(body))
-                throw new WorkflowError("UNKNOWN_TOOL", `Tool is outside the launching session boundary: ${body}`);
-        }
-        const outsideEffectiveTool = options.effectiveTools?.find((tool) => !candidateTools.includes(tool));
-        if (outsideEffectiveTool)
-            throw new WorkflowError("UNKNOWN_TOOL", `Tool is outside the launching session boundary: ${outsideEffectiveTool}`);
-        const requested = options.effectiveTools ?? selectResourcesByLayers(selectorLayers, candidateTools);
-        const forbidden = requested.find((tool) => !this.root.tools.has(tool));
-        if (forbidden)
-            throw new WorkflowError("UNKNOWN_TOOL", `Tool is outside the launching session boundary: ${forbidden}`);
-        const requestedModel = options.model ?? (roleDefinition?.model && roleDefinition.thinking && !roleDefinition.model.includes(":") ? `${roleDefinition.model}:${roleDefinition.thinking}` : roleDefinition?.model);
-        const alias = requestedModel === undefined ? undefined : modelAliasName(requestedModel, this.root.modelAliases ?? {});
-        const blockedAlias = requestedModel?.split(":", 1)[0];
-        if (requestedModel !== undefined && blockedAlias && this.root.blockedAliases?.has(blockedAlias) && !alias) {
-            const target = this.root.blockedAliasTargets?.[blockedAlias];
-            throw new WorkflowError("UNKNOWN_MODEL", `Unknown model alias ${requestedModel}${target ? ` resolved to ${target}` : ""}${this.root.settingsPath ? ` (settings: ${this.root.settingsPath})` : ""}`);
-        }
-        const model = options.modelOverride ?? parseModel(requestedModel, this.root.model, this.root.modelAliases, this.root.knownModels ?? this.root.availableModels, this.root.settingsPath);
-        const availableModels = this.root.knownModels ?? this.root.availableModels ?? new Set([modelCapability(this.root.model)]);
-        if (!availableModels.has(modelCapability(model)))
-            throw new WorkflowError("UNKNOWN_MODEL", `Unknown model${requestedModel ? ` ${requestedModel} resolved to ${modelCapability(model)}` : ""}${this.root.settingsPath ? ` (settings: ${this.root.settingsPath})` : ""}`);
-        const overrideSystemPrompt = roleDefinition?.overrideSystemPrompt === true;
-        const contextFiles = options.contextFiles ?? roleDefinition?.contextFiles;
-        return { model, ...(alias && requestedModel ? { requestedModel } : {}), tools: requested, ...(overrideSystemPrompt ? { systemPrompt: roleDefinition.prompt ?? "" } : {}), systemPromptAppend: overrideSystemPrompt ? "" : roleDefinition?.prompt ?? "", ...(contextFiles === undefined ? {} : { contextFiles: [...contextFiles] }) };
+        const resolved = resolveRole(roleName, {
+            cwd: this.root.cwd,
+            ...(roleDefinition === undefined ? {} : { definition: roleDefinition }),
+            ...(this.root.agentDefinitions === undefined ? {} : { definitions: this.root.agentDefinitions }),
+            ...(this.root.agentDir === undefined ? {} : { agentDir: this.root.agentDir }),
+            selectorSources: { global: this.root.resourceSelectors ?? {}, project: {} },
+            ...(this.root.modelAliases === undefined ? {} : { modelAliases: this.root.modelAliases }),
+            ...(this.root.knownModels === undefined ? {} : { knownModels: this.root.knownModels }),
+            ...(this.root.availableModels === undefined ? {} : { availableModels: this.root.availableModels }),
+            ...(this.root.blockedAliases === undefined ? {} : { blockedAliases: this.root.blockedAliases }),
+            ...(this.root.blockedAliasTargets === undefined ? {} : { blockedAliasTargets: this.root.blockedAliasTargets }),
+            ...(this.root.settingsPath === undefined ? {} : { settingsPath: this.root.settingsPath }),
+            rootModel: this.root.model,
+            rootTools: this.root.tools,
+            ...(inheritedTools === undefined ? {} : { inheritedTools }),
+            ...(options.model === undefined ? {} : { model: options.model }),
+            ...(options.modelOverride === undefined ? {} : { modelOverride: options.modelOverride }),
+            ...(options.tools === undefined ? {} : { tools: options.tools }),
+            ...(options.skills === undefined ? {} : { skills: options.skills }),
+            ...(options.extensions === undefined ? {} : { extensions: options.extensions }),
+            ...(options.contextFiles === undefined ? {} : { contextFiles: options.contextFiles }),
+            ...(options.effectiveTools === undefined ? {} : { effectiveTools: options.effectiveTools }),
+        });
+        return { model: resolved.model ?? this.root.model, ...(resolved.requestedModel === undefined ? {} : { requestedModel: resolved.requestedModel }), tools: resolved.tools ?? [], ...(resolved.overrideSystemPrompt ? { systemPrompt: resolved.prompt } : {}), systemPromptAppend: resolved.overrideSystemPrompt ? "" : resolved.prompt, ...(resolved.contextFiles === undefined ? {} : { contextFiles: resolved.contextFiles }) };
     }
     async execute(task, options, signal, customTools = [], setSteer, beforeRetry) {
         const executionSignal = signal ?? this.root.runContext?.signal;

package/dist/src/background-widget.d.ts

@@ -22,6 +22,18 @@ export type BackgroundWidgetAPI = Pick<ExtensionAPI, "appendEntry" | "on"> & {
     registerEntryRenderer?: ExtensionAPI["registerEntryRenderer"];
     registerShortcut?: ExtensionAPI["registerShortcut"];
 };
+/**
+ * How long an agent may go without an event before the widget says so.
+ *
+ * Deliberately shorter than the core's own stall threshold. That one answers
+ * "is this agent dead"; this one answers "should you go and look". An agent
+ * asking a question in its own pane produces exactly this signature — no tool
+ * calls, no events, waiting on a person — and the core cannot see it, since the
+ * pane is a separate process. Three minutes is longer than any single stretch
+ * of thinking and far shorter than the ten minutes it takes to be declared
+ * stalled.
+ */
+export declare const QUIET_MS: number;
 /**
  * Overrides the switch above, for the tests that cover navigation.
  *
@@ -32,6 +44,11 @@ export type BackgroundWidgetAPI = Pick<ExtensionAPI, "appendEntry" | "on"> & {
 export declare const __navigationForTests: {
     enabled: boolean;
 };
+/**
+ * Paints text in a themed colour role. Falls back to the bare text when no
+ * theme is available, so a frame rendered outside the TUI is still legible.
+ */
+export type Paint = (role: Parameters<Theme["fg"]>[0], text: string) => string;
 interface ReceiptAgent {
     id?: string;
     parentId?: string;
@@ -62,8 +79,47 @@ interface Receipt {
     agents: readonly ReceiptAgent[];
     error?: string;
 }
+/** Status mark for a finished-or-running unit of work. */
+export declare function mark(state: string | undefined, now: number, paint: Paint, runState?: string): string;
+export declare function formatElapsed(ms: number): string;
 export declare function formatTokens(tokens: number | undefined): string;
 export declare function formatCost(cost: number | undefined): string;
+interface Row {
+    text: string;
+    /**
+     * Numbers to set against the right-hand rule rather than trailing the name.
+     *
+     * Names are ragged — a phase called `plan` beside one called `refactor-2` —
+     * so numbers that follow them are ragged too, and comparing the cost of one
+     * agent against another means reading across a gap that moves on every row.
+     * Held to the right edge, they form a column.
+     */
+    right?: string;
+    /** 2 = a run header or something needing an answer, 1 = live or failed work, 0 = finished detail. */
+    rank: number;
+    /**
+     * Set on the one row that stands for a whole run.
+     *
+     * Rank alone cannot protect it: a checkpoint needs an answer and so shares
+     * the top rank, and enough of them would spend the budget before a later
+     * run's header is reached. A run missing its header is not a terse run, it
+     * is an invisible one.
+     */
+    header?: boolean;
+    /**
+     * A stable name for a row that can be folded shut, and the key of the row it
+     * hangs from. Together they let the cursor walk a tree rather than a list:
+     * collapsing a phase hides its agents, collapsing a run hides everything
+     * under it, and the choice survives the repaint that follows.
+     */
+    key?: string;
+    parent?: string;
+}
+/**
+ * The box around the live rows, shared with the subagent widget so both sit
+ * under the editor in one style.
+ */
+export declare function drawFrame(title: string, hint: string, body: readonly Pick<Row, "text" | "right">[], width: number, paint: Paint, accent: (text: string) => string, scrollbar?: (index: number) => string | undefined): string[];
 /** The receipt as transcript lines: the widget's tree, one level deeper. */
 export declare function renderReceipt(data: Receipt, expanded: boolean, theme: Theme): string[];
 export interface BackgroundWidgetController {

package/dist/src/background-widget.js

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

package/dist/src/decoders.js

@@ -109,9 +109,10 @@ export function decodeWorkflowExtensions(value) {
             continue;
         }
         if (namespace === "trajectory") {
+            // Snapshots persisted before the themes setting was removed still carry a boolean `themes`; it is accepted and dropped.
             if (!object(raw) || Object.keys(raw).some((key) => key !== "port" && key !== "themes") || raw.port !== undefined && (typeof raw.port !== "number" || !Number.isSafeInteger(raw.port) || raw.port < 1 || raw.port > 65535) || raw.themes !== undefined && typeof raw.themes !== "boolean")
                 return undefined;
-            normalized.trajectory = { ...(raw.port === undefined ? {} : { port: raw.port }), ...(raw.themes === undefined ? {} : { themes: raw.themes }) };
+            normalized.trajectory = { ...(raw.port === undefined ? {} : { port: raw.port }) };
             continue;
         }
         if (!jsonValue(raw))

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

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

package/dist/src/host-navigator.js

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

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

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