@quintinshaw/pi-dynamic-workflows 1.9.0 → 1.9.2

package/dist/workflow-tool.js

@@ -1,11 +1,31 @@
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { createToolUpdateWorkflowDisplay, createWorkflowSnapshot, preview, recomputeWorkflowSnapshot, renderWorkflowText, } from "./display.js";
+import { listAvailableModelSpecs } from "./agent.js";
+import { createToolUpdateWorkflowDisplay, createWorkflowSnapshot, recomputeWorkflowSnapshot, renderWorkflowText, } from "./display.js";
 import { WorkflowError, WorkflowErrorCode } from "./errors.js";
-import { parseWorkflowScript, runWorkflow } from "./workflow.js";
+import { parseWorkflowScript } from "./workflow.js";
 import { WorkflowManager } from "./workflow-manager.js";
 import { createWorkflowStorage } from "./workflow-saved.js";
+/**
+ * Per-agent model-routing policy handed to the workflow author (the model). It
+ * states the rule and lists the user's currently available models, then lets the
+ * author choose each agent's model via opts.model — no hardcoded family mapping.
+ */
+function modelRoutingGuideline() {
+    const available = listAvailableModelSpecs();
+    const list = available.length
+        ? `The user's currently available models (route only to these) are: ${available.join(", ")}.`
+        : "Use models the user has configured.";
+    return [
+        "For workflow, decide each agent's model yourself via opts.model, following this policy:",
+        "If the user named a specific model, use exactly that.",
+        "Otherwise, for exploration/search/inventory/gathering agents, pick a model one tier BELOW the main model in the SAME family (e.g. Claude→Haiku, ChatGPT/GPT→a mini, DeepSeek→a lighter/flash variant), choosing the closest match from the available list.",
+        "For analysis/synthesis/judgment/decision/verification agents, omit opts.model so the agent runs on the main model.",
+        "Never route to a model that is not in the available list; if no suitable lighter sibling exists, omit opts.model (use the main model).",
+        list,
+    ].join(" ");
+}
 const workflowToolSchema = Type.Object({
     script: Type.String({
         description: [
@@ -17,7 +37,7 @@ const workflowToolSchema = Type.Object({
     }),
     args: Type.Optional(Type.Any({ description: "Optional JSON value exposed to the workflow script as global `args`." })),
     background: Type.Optional(Type.Boolean({
-        description: "Run the workflow in the background. Default: false. When true, returns immediately with a run ID.",
+        description: "Run the workflow in the background. Default: true — the tool returns immediately with a run ID, the turn ends so the user isn't blocked, and the result is delivered back into the conversation when it finishes. Set to false only when you need the result inline in this same turn (the call will block until the workflow completes).",
     })),
     maxAgents: Type.Optional(Type.Number({
         description: "Maximum number of agents allowed in this run. Default: 1000.",
@@ -28,8 +48,12 @@ const workflowToolSchema = Type.Object({
 });
 export function createWorkflowTool(options = {}) {
     const storage = options.storage ?? createWorkflowStorage(options.cwd ?? process.cwd());
-    const manager = options.manager ?? new WorkflowManager({ cwd: options.cwd, concurrency: options.concurrency });
-    const loadSavedWorkflow = (name) => storage.load(name)?.script;
+    const manager = options.manager ??
+        new WorkflowManager({
+            cwd: options.cwd,
+            concurrency: options.concurrency,
+            loadSavedWorkflow: (name) => storage.load(name)?.script,
+        });
     return defineTool({
         name: "workflow",
         label: "Workflow",
@@ -51,36 +75,33 @@ export function createWorkflowTool(options = {}) {
             "For workflow, failed agent(), parallel(), or pipeline() branches return null and log the failure unless the workflow is aborted. Check for nulls before synthesizing conclusions.",
             "For workflow, include a final synthesis/assertion agent when combining multiple subagent results; return a compact JSON-serializable value with ok/verdict plus the important outputs.",
             "For workflow, if agent() needs machine-readable output, pass a plain JSON Schema via opts.schema; agent() will return the validated object. Use JSON Schema syntax, not TypeScript or TypeBox constructors.",
+            modelRoutingGuideline(),
             "For workflow, do not assume the parent assistant has repository code context inside subagents; include enough task context and relevant paths in each agent prompt.",
-            "For workflow, set background: true to run asynchronously. The workflow will return immediately with a run ID that can be used to check status later.",
+            "For workflow, runs are background by default: the tool returns immediately with a run ID, the turn ends so the user isn't blocked, and the result is delivered back into the conversation when the run finishes. Pass background: false only when you must use the result inline in this same turn (it will block).",
             "For workflow, you may call `await workflow('saved-name', argsObject)` to run a saved workflow inline and use its result; nesting is one level deep only, and the global 16-concurrent / 1000-total caps hold across the nesting.",
         ],
         parameters: workflowToolSchema,
         prepareArguments(args) {
             return normalizeWorkflowToolArgs(args);
         },
-        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+        async execute(_toolCallId, params, signal, onUpdate, _ctx) {
             const script = normalizeWorkflowScript(params.script);
             const parsed = parseWorkflowScript(script);
-            // Background execution
-            if (params.background) {
+            // Background execution is the default: return immediately so the turn ends
+            // and the user isn't blocked. The result is delivered back into the
+            // conversation when the run finishes (see installResultDelivery). Only an
+            // explicit `background: false` blocks for the result inline.
+            if (params.background ?? true) {
                 const { runId } = manager.startInBackground(script, params.args);
                 return {
-                    content: [
-                        {
-                            type: "text",
-                            text: [
-                                `Workflow "${parsed.meta.name}" started in background.`,
-                                `Run ID: ${runId}`,
-                                `Use /workflows status ${runId} to check progress.`,
-                                `Use /workflows stop ${runId} to cancel.`,
-                            ].join("\n"),
-                        },
-                    ],
+                    content: [{ type: "text", text: backgroundStartedText(parsed.meta.name, runId) }],
                     details: { runId, background: true },
                 };
             }
-            // Synchronous execution (blocking)
+            // Synchronous execution (blocking) — but routed through the manager so the
+            // run shows up live in the /workflows navigator and the task panel while it
+            // runs, then stays in history afterwards. We still block on the result and
+            // return it inline, so the model gets the full output in the same turn.
             let snapshot = createWorkflowSnapshot(parsed.meta);
             const display = createToolUpdateWorkflowDisplay(onUpdate, undefined, {
                 key: "workflow",
@@ -89,56 +110,15 @@ export function createWorkflowTool(options = {}) {
                 maxLogs: 1,
                 showResultPreviews: false,
             });
-            const update = () => {
-                snapshot = recomputeWorkflowSnapshot(snapshot);
-                display.update(snapshot);
-            };
             let result;
             try {
-                result = await runWorkflow(script, {
-                    cwd: options.cwd ?? ctx.cwd,
-                    args: params.args,
-                    signal,
-                    concurrency: options.concurrency,
+                result = await manager.runSync(script, params.args, {
                     maxAgents: params.maxAgents,
                     agentTimeoutMs: params.agentTimeoutMs,
-                    loadSavedWorkflow,
-                    onLog(message) {
-                        snapshot.logs.push(message);
-                        update();
-                    },
-                    onPhase(title) {
-                        snapshot.currentPhase = title;
-                        if (!snapshot.phases.includes(title))
-                            snapshot.phases.push(title);
-                        update();
-                    },
-                    onAgentStart(event) {
-                        if (signal?.aborted)
-                            throw new Error("Workflow was aborted");
-                        snapshot.agents.push({
-                            id: snapshot.agents.length + 1,
-                            label: event.label,
-                            phase: event.phase,
-                            prompt: event.prompt,
-                            status: "running",
-                        });
-                        update();
-                    },
-                    onAgentEnd(event) {
-                        const agent = [...snapshot.agents]
-                            .reverse()
-                            .find((item) => item.label === event.label && item.status === "running");
-                        if (agent) {
-                            agent.status = event.result === null ? "error" : "done";
-                            agent.resultPreview = preview(event.result);
-                            agent.tokens = event.tokens;
-                        }
-                        update();
-                    },
-                    onTokenUsage(usage) {
-                        snapshot.tokenUsage = usage;
-                        update();
+                    externalSignal: signal,
+                    onProgress(live) {
+                        snapshot = recomputeWorkflowSnapshot(live);
+                        display.update(snapshot);
                     },
                 });
             }
@@ -199,6 +179,24 @@ export function createWorkflowTool(options = {}) {
         },
     });
 }
+/**
+ * The tool result returned when a workflow starts in the background. It both
+ * informs the model and tells it to reassure the user: the run continues on its
+ * own and the conversation will resume automatically when it finishes, so the
+ * user can just wait here (or go do something else).
+ */
+export function backgroundStartedText(name, runId) {
+    return [
+        `Workflow "${name}" started in the background.`,
+        `Run ID: ${runId}`,
+        "It keeps running on its own. When it finishes, the result is delivered back",
+        "here and the conversation continues automatically — the user does not need to",
+        "do anything. Tell the user they can simply wait here for it to finish (it will",
+        "resume the conversation by itself), or keep chatting / working on other things",
+        "in the meantime; either way the result will come back to this conversation.",
+        `They can also track or cancel it with /workflows status ${runId} or /workflows stop ${runId}.`,
+    ].join("\n");
+}
 function normalizeWorkflowToolArgs(args) {
     if (!args || typeof args !== "object")
         throw new Error("workflow requires an object argument with a script string");

package/dist/workflow-ui.d.ts

@@ -40,6 +40,7 @@ interface AgentRow {
     status: string;
     phase?: string;
     tokens?: number;
+    model?: string;
 }
 /** Reads run/phase/agent data from the manager, preferring live snapshots. */
 export declare class NavigatorModel {

package/dist/workflow-ui.js

@@ -25,6 +25,13 @@ const STATUS_ICON = {
     skipped: "⊘",
 };
 const PLAIN = { fg: (_c, t) => t, bold: (t) => t };
+/** Short, human-friendly model label: drop the provider prefix for display. */
+function shortModel(model) {
+    if (!model)
+        return undefined;
+    const slash = model.indexOf("/");
+    return slash > 0 ? model.slice(slash + 1) : model;
+}
 /** Reads run/phase/agent data from the manager, preferring live snapshots. */
 export class NavigatorModel {
     manager;
@@ -90,7 +97,7 @@ export class NavigatorModel {
             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 }));
+            .map((a) => ({ id: a.id, label: a.label, status: a.status, phase: a.phase, tokens: a.tokens, model: a.model }));
     }
     agentDetail(runId, agentId) {
         return this.snapshot(runId)?.snapshot.agents.find((a) => a.id === agentId);
@@ -110,6 +117,7 @@ function persistedToSnapshot(p) {
             status: a.status,
             resultPreview: a.result == null ? undefined : String(typeof a.result === "string" ? a.result : JSON.stringify(a.result)),
             error: a.error,
+            model: a.model,
         })),
         agentCount: p.agents.length,
         runningCount: p.agents.filter((a) => a.status === "running").length,
@@ -246,8 +254,9 @@ export function renderNavigator(state, model, width, theme = PLAIN) {
         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}`));
+            const mdl = shortModel(a.model);
+            const meta = [mdl, a.tokens ? fmtTokens(a.tokens) : undefined].filter(Boolean).join(" · ");
+            lines.push(sel(i, `${icon} ${a.label}${meta ? dim(`  ${meta}`) : ""}`));
         });
     }
     else if (state.kind === "detail" && state.runId && state.agentId != null) {
@@ -256,6 +265,8 @@ export function renderNavigator(state, model, width, theme = PLAIN) {
         if (a) {
             const body = [];
             body.push(dim("Status: ") + (a.status ?? ""));
+            if (a.model)
+                body.push(dim("Model: ") + (shortModel(a.model) ?? ""));
             if (a.error)
                 body.push(dim("Error: ") + a.error);
             body.push("", dim("Prompt:"));
@@ -385,9 +396,20 @@ export function openWorkflowNavigator(pi, manager, ui, opts = {}) {
                         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");
+                case "restart": {
+                    // Restart re-runs the whole workflow from scratch as a fresh
+                    // background run (per-agent restart isn't meaningful — agents are
+                    // driven by the script). The new run auto-delivers when it finishes.
+                    const id = state.activeRunId(model);
+                    const run = id ? manager.listRuns().find((r) => r.runId === id) : undefined;
+                    if (!run?.script) {
+                        ui.notify(id ? `Cannot restart ${id} (no script saved)` : "No run selected to restart", "warning");
+                        break;
+                    }
+                    const { runId: newId } = manager.startInBackground(run.script, run.args);
+                    ui.notify(`Restarted ${run.workflowName || "workflow"} as ${newId}`, "info");
                     break;
+                }
                 case "save": {
                     const id = state.activeRunId(model);
                     const run = id ? manager.listRuns().find((r) => r.runId === id) : undefined;

package/dist/workflow.d.ts

@@ -38,6 +38,8 @@ export interface SharedRuntime {
 export interface WorkflowRunOptions extends WorkflowAgentOptions {
     args?: unknown;
     agent?: Pick<WorkflowAgent, "run">;
+    /** The session's main model (provider/id), shown in /workflows for default agents. */
+    mainModel?: string;
     concurrency?: number;
     tokenBudget?: number | null;
     signal?: AbortSignal;
@@ -73,6 +75,7 @@ export interface WorkflowRunOptions extends WorkflowAgentOptions {
         result: unknown;
         tokens?: number;
         worktree?: string;
+        model?: string;
     }) => void;
     onTokenUsage?: (usage: {
         input: number;
@@ -100,6 +103,12 @@ export interface AgentOptions<TSchemaDef extends TSchema | undefined = TSchema |
     label?: string;
     phase?: string;
     schema?: TSchemaDef;
+    /**
+     * Run this agent on a specific model (`provider/modelId` or a bare `modelId`).
+     * The workflow author chooses per-agent models per the routing policy in the
+     * tool guidelines (e.g. a lighter model for exploration, the main model for
+     * analysis). When omitted, the session's main model is used.
+     */
     model?: string;
     isolation?: "worktree";
     agentType?: string;

package/dist/workflow.js

@@ -76,6 +76,10 @@ export async function runWorkflow(script, options = {}) {
         const requestedLabel = agentOptions.label?.trim();
         // Precedence: explicit agentOptions.model > phase model (meta.phases[].model).
         const modelSpec = agentOptions.model ?? resolveModelForPhase(assignedPhase, routingConfig);
+        // For display in /workflows: the model this agent runs on — its explicit/phase
+        // spec, else the session's main model. The real resolved id overrides this via
+        // onModelResolved once the subagent session is created.
+        let displayModel = modelSpec ?? options.mainModel;
         // Deterministic resume key: assigned at lexical call time, before the limiter,
         // so parallel()/pipeline() fan-out is reproducible for a fixed script.
         const callIndex = state.callSeq++;
@@ -86,15 +90,15 @@ export async function runWorkflow(script, options = {}) {
         if (cached && cached.hash === callHash) {
             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 });
+            options.onAgentStart?.({ label, phase: assignedPhase, prompt, model: displayModel });
+            options.onAgentEnd?.({ label, phase: assignedPhase, result: cached.result, tokens: 0, model: displayModel });
             return cached.result;
         }
         return limiter(async () => {
             shared.agentCount++;
             const label = requestedLabel || defaultAgentLabel(assignedPhase, shared.agentCount);
             const timeout = agentOptions.timeoutMs ?? agentTimeoutMs;
-            options.onAgentStart?.({ label, phase: assignedPhase, prompt, model: modelSpec });
+            options.onAgentStart?.({ label, phase: assignedPhase, prompt, model: displayModel });
             // Optional per-agent worktree isolation (deterministic name -> stable resume keys).
             let worktree;
             if (agentOptions.isolation === "worktree") {
@@ -127,6 +131,9 @@ export async function runWorkflow(script, options = {}) {
                     instructions: buildAgentInstructions(assignedPhase, agentOptions),
                     model: modelSpec,
                     cwd: runCwd,
+                    onModelResolved: (id) => {
+                        displayModel = id;
+                    },
                     onUsage: (u) => {
                         usage = u;
                     },
@@ -134,7 +141,7 @@ export async function runWorkflow(script, options = {}) {
                 throwIfAborted();
                 const tokens = recordTokens(result);
                 options.onAgentJournal?.({ index: callIndex, hash: callHash, result });
-                options.onAgentEnd?.({ label, phase: assignedPhase, result, tokens, worktree: runCwd });
+                options.onAgentEnd?.({ label, phase: assignedPhase, result, tokens, worktree: runCwd, model: displayModel });
                 return result;
             }
             catch (error) {

package/extensions/workflow.ts

@@ -4,6 +4,7 @@ import {
   createWorkflowTool,
   installResultDelivery,
   installTaskPanel,
+  installWorkflowEditor,
   registerAllSavedWorkflows,
   registerBuiltinWorkflows,
   registerWorkflowCommands,
@@ -24,13 +25,24 @@ export default function extension(pi: ExtensionAPI) {
   registerAllSavedWorkflows(pi, cwd, storage);
   // Deliver a background run's result into the conversation when it finishes.
   installResultDelivery(pi, manager);
+  // "Workflows mode": type `workflow(s)` to arm a forced workflow (animated),
+  // Backspace right after the word disarms it. Registers the `input` hook now;
+  // the editor itself is installed once the UI is available (session_start).
+  let editorInstalled = false;
 
   pi.on("session_start", (_event: unknown, ctx: ExtensionContext) => {
     const active = pi.getActiveTools();
     if (!active.includes(workflowTool.name)) {
       pi.setActiveTools([...active, workflowTool.name]);
     }
+    // Tell the manager the session's main model so "explore" agents auto-tier
+    // down to a lighter same-family sibling (e.g. Claude → Haiku).
+    manager.setMainModel(ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined);
     // Live "workflows running" panel below the input (focus + enter to open).
     installTaskPanel(pi, manager, ctx.ui, { storage, cwd });
+    if (!editorInstalled) {
+      installWorkflowEditor(pi, ctx.ui);
+      editorInstalled = true;
+    }
   });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@quintinshaw/pi-dynamic-workflows",
-  "version": "1.9.0",
-  "description": "Claude-Code-style dynamic workflow orchestration for Pi.",
+  "version": "1.9.2",
+  "description": "Claude-Code-style dynamic workflows for Pi — fan a task out across 100s of subagents with real model routing, token/cost accounting, resume, git-worktree isolation, an interactive /workflows TUI, and a real /deep-research.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,8 +33,21 @@
   "keywords": [
     "pi-package",
     "pi",
+    "pi-coding-agent",
     "workflow",
-    "agents"
+    "workflows",
+    "dynamic-workflows",
+    "orchestration",
+    "subagents",
+    "multi-agent",
+    "agents",
+    "ai-agents",
+    "parallel",
+    "fan-out",
+    "claude-code",
+    "deep-research",
+    "code-review",
+    "llm"
   ],
   "pi": {
     "extensions": [

package/src/agent.ts

@@ -24,6 +24,22 @@ export interface WorkflowAgentOptions {
   instructions?: string;
 }
 
+/**
+ * List the user's currently available models (those with auth configured) as
+ * `provider/modelId` specs. Used to tell the workflow author which models it may
+ * route agents to. Best-effort: returns [] if the registry can't be built.
+ */
+export function listAvailableModelSpecs(): string[] {
+  try {
+    const dir = getAgentDir();
+    const auth = AuthStorage.create(join(dir, "auth.json"));
+    const registry = ModelRegistry.create(auth, join(dir, "models.json"));
+    return registry.getAvailable().map((m) => `${m.provider}/${m.id}`);
+  } catch {
+    return [];
+  }
+}
+
 /** Real token/cost usage for a single subagent run, read from the SDK session. */
 export interface AgentUsage {
   input: number;

package/src/display.ts

@@ -13,6 +13,8 @@ export interface WorkflowAgentSnapshot {
   error?: string;
   /** Tokens used by this agent. */
   tokens?: number;
+  /** The model this agent ran on (provider/id), when known. */
+  model?: string;
 }
 
 export interface WorkflowSnapshot {

package/src/index.ts

@@ -1,7 +1,7 @@
 export type { AdversarialReviewConfig } from "./adversarial-review.js";
 export { generateAdversarialReviewWorkflow, generateMultiPerspectiveWorkflow } from "./adversarial-review.js";
 export type { AgentRunOptions, AgentRunResult, WorkflowAgentOptions } from "./agent.js";
-export { WorkflowAgent } from "./agent.js";
+export { listAvailableModelSpecs, WorkflowAgent } from "./agent.js";
 export type { AutoWorkflowConfig } from "./auto-workflow.js";
 export { shouldUseWorkflow, suggestWorkflowScript } from "./auto-workflow.js";
 export { registerBuiltinWorkflows } from "./builtin-commands.js";
@@ -58,12 +58,23 @@ export type {
 } from "./workflow.js";
 export { parseWorkflowScript, runWorkflow } from "./workflow.js";
 export { registerWorkflowCommands } from "./workflow-commands.js";
+export {
+  buildForcedWorkflowPrompt,
+  colorizeWorkflow,
+  endsWithTrigger,
+  hasTrigger,
+  installWorkflowEditor,
+  RAINBOW,
+  tokenizeAnsi,
+  WorkflowEditor,
+  type WorkflowModeState,
+} from "./workflow-editor.js";
 export type { ManagedRun, WorkflowManagerOptions } from "./workflow-manager.js";
 export { WorkflowManager } from "./workflow-manager.js";
 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 { backgroundStartedText, createWorkflowTool } from "./workflow-tool.js";
 export {
   keyToAction,
   type NavAction,

package/src/run-persistence.ts

@@ -18,6 +18,8 @@ export interface PersistedAgentState {
   error?: string;
   startedAt?: string;
   endedAt?: string;
+  /** The model this agent ran on (provider/id), when known. */
+  model?: string;
 }
 
 export interface PersistedRunState {

package/src/task-panel.ts

@@ -1,17 +1,15 @@
 /**
  * Background-run UX, mirroring Claude Code:
  *  - A live task panel below the input lists in-progress runs while you keep working.
- *    Focus it (↓) and press enter to open the full navigator.
+ *    It is informational; run /workflows to open the full navigator.
  *  - When a background run finishes, its result is delivered back into the
  *    conversation so the paused task continues with the outcome.
  */
 
 import type { ExtensionAPI, ExtensionUIContext, Theme } from "@earendil-works/pi-coding-agent";
 import type { Component, TUI } from "@earendil-works/pi-tui";
-import { parseKey } from "@earendil-works/pi-tui";
 import type { ManagedRun, WorkflowManager } from "./workflow-manager.js";
 import type { WorkflowStorage } from "./workflow-saved.js";
-import { openWorkflowNavigator } from "./workflow-ui.js";
 
 const RUN_EVENTS = ["agentStart", "agentEnd", "phase", "log", "complete", "error", "stopped", "paused", "resumed"];
 
@@ -26,31 +24,50 @@ function deliverText(run: ManagedRun): string {
     r && typeof r.report === "string" && r.report.trim() ? r.report : JSON.stringify(run.result?.result, null, 2);
   const tokens = run.result?.tokenUsage ? ` · ${run.result.tokenUsage.total.toLocaleString()} tokens` : "";
   const agents = run.result?.agentCount ?? run.snapshot.agentCount;
-  return `✓ Workflow "${run.snapshot.name}" finished (${agents} agents${tokens}).\n\n${body}`;
+  return [
+    `✓ Background workflow "${run.snapshot.name}" finished (${agents} agents${tokens}).`,
+    "Continue helping the user based on this result.",
+    "",
+    body,
+  ].join("\n");
 }
 
 /**
- * Deliver a background run's result into the conversation when it completes or
- * fails. Set up once per extension; idempotent via an internal guard.
+ * When a background run finishes (or fails), deliver its result back into the
+ * conversation AND continue the turn so the assistant can act on it — without
+ * blocking the user meanwhile:
+ *
+ *  - `triggerTurn: true` starts a fresh turn when the agent is idle, feeding the
+ *    result to the model so the paused conversation continues.
+ *  - `deliverAs: "followUp"` means that if the user is busy in another turn, the
+ *    result is queued and picked up after that turn finishes — never interrupting.
+ *
+ * Set up once per extension; idempotent via an internal guard.
  */
 export function installResultDelivery(pi: ExtensionAPI, manager: WorkflowManager): void {
   if ((manager as unknown as { __deliveryInstalled?: boolean }).__deliveryInstalled) return;
   (manager as unknown as { __deliveryInstalled?: boolean }).__deliveryInstalled = true;
 
+  const deliver = (content: string) => {
+    void pi.sendMessage(
+      { customType: "workflow-result", content, display: true },
+      { triggerTurn: true, deliverAs: "followUp" },
+    );
+  };
+
   manager.on("complete", ({ runId }: { runId: string }) => {
     const run = manager.getRun(runId);
-    if (run) void pi.sendMessage({ customType: "workflow-result", content: deliverText(run), display: true });
+    // Only background/resumed runs are delivered: a foreground (sync) run already
+    // returns its result inline as the tool result, so re-delivering would dup it.
+    if (run?.background) deliver(deliverText(run));
   });
   manager.on("error", ({ runId, error }: { runId: string; error?: { message?: string } }) => {
-    void pi.sendMessage({
-      customType: "workflow-result",
-      content: `✗ Workflow ${runId} failed: ${error?.message ?? "unknown error"}`,
-      display: true,
-    });
+    if (!manager.getRun(runId)?.background) return;
+    deliver(`✗ Background workflow ${runId} failed: ${error?.message ?? "unknown error"}`);
   });
 }
 
-function renderPanel(manager: WorkflowManager, theme: Theme, focused: boolean): string[] {
+function renderPanel(manager: WorkflowManager, theme: Theme): string[] {
   const active = manager.listRuns().filter((r) => r.status === "running" || r.status === "paused");
   if (!active.length) return [];
   const rows = active.map((r) => {
@@ -61,36 +78,30 @@ function renderPanel(manager: WorkflowManager, theme: Theme, focused: boolean):
     const phase = live?.snapshot.currentPhase ? ` · ${live.snapshot.currentPhase}` : "";
     return `  ${icon} ${r.workflowName}  ${done}/${agents.length} agents${phase}`;
   });
-  const hint = focused
-    ? theme.fg("accent", "  enter: open · esc: back")
-    : theme.fg("dim", "  ↓ then enter, or /workflows, to open");
+  const hint = theme.fg("dim", "  run /workflows to open");
   return [theme.bold(`Workflows running (${active.length}):`), ...rows, hint];
 }
 
 /**
  * Install the live "workflows running" panel below the editor. Re-rendered on
- * every manager event; focus + enter opens the navigator.
+ * every manager event. Informational only — the user opens the navigator with
+ * /workflows. (`_pi`/`_opts` are kept for signature stability.)
  */
 export function installTaskPanel(
-  pi: ExtensionAPI,
+  _pi: ExtensionAPI,
   manager: WorkflowManager,
   ui: ExtensionUIContext,
-  opts: TaskPanelOptions = {},
+  _opts: TaskPanelOptions = {},
 ): void {
   ui.setWidget(
     "workflow-tasks",
     (tui: TUI, theme: Theme) => {
       const onEvent = () => tui.requestRender();
       for (const ev of RUN_EVENTS) manager.on(ev, onEvent);
-      const comp: Component & { focused?: boolean; dispose?(): void } = {
-        focused: false,
-        render: () => renderPanel(manager, theme, comp.focused ?? false),
-        handleInput: (data: string) => {
-          const key = parseKey(data);
-          if (key === "enter" || key === "return" || key === "right") {
-            void openWorkflowNavigator(pi, manager, ui, opts);
-          }
-        },
+      // Purely informational: it lists running runs and re-renders on events. To
+      // open the navigator, the user runs /workflows (the panel takes no input).
+      const comp: Component & { dispose?(): void } = {
+        render: () => renderPanel(manager, theme),
         invalidate: () => {},
         dispose: () => {
           for (const ev of RUN_EVENTS) manager.off(ev, onEvent);