@jameslovespancakes/pi-plus 1.0.20 → 1.0.21

package/README.md

@@ -124,7 +124,8 @@ boundary, including workflow subagents—not just through prompt instructions.
 
 **Turn repeatable tasks into coordinated agent runs.** Built-in reviews,
 diagnostics, research, and refactoring workflows support parallel agents,
-worktree isolation, replay, background execution, and usage accounting.
+worktree isolation, replay, and usage accounting. Every run returns immediately;
+results arrive when it finishes. There is no separate foreground/background mode.
 
 ```text
  Task → parallel agents → findings → result
@@ -135,8 +136,25 @@ worktree isolation, replay, background execution, and usage accounting.
 /workflow research "Compare the available approaches"
 ```
 
-**`/workflow`** opens the running agent board. Limits on concurrency, agents,
-time, and output tokens are optional; set them when needed.
+**`/workflow`** opens the running agent board. Enter inspects, Esc goes back,
+and X stops the selected agent from the list. Inspection needs at least 80×24.
+The inspector uses pi's native message/tool rendering and editor. Enter steers;
+Alt+Enter queues a follow-up. `/model provider/model` and `/thinking level`
+affect only that agent. Other parent-session commands are not forwarded.
+
+Every `api.agent()` call requires `label`, `model`, and `thinkingLevel`.
+Built-ins resolve explicit routes with `api.modelProfile("small" | "medium")`;
+configure both routes in `.pi/workflow-models.json` (or the agent-directory
+`workflow-models.json`), each with `model: "provider/model-id"` and
+`thinkingLevel`. Missing routes now fail rather than inheriting the host model.
+The file shape is `{ "profiles": { "small": { "model": "provider/model-id",
+"thinkingLevel": "low" }, "medium": { "model": "provider/model-id",
+"thinkingLevel": "high" } } }`.
+
+The main agent can use `workflow({ action: "list" })`, or `inspect`/`stop` with
+`runId` and optionally `agentId`. Activity is fetched on demand, not injected
+into every turn. Limits on concurrency, agents, time, and output tokens remain
+optional.
 
 ## Remote Workers
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jameslovespancakes/pi-plus",
-  "version": "1.0.20",
+  "version": "1.0.21",
   "type": "module",
   "description": "pi and more",
   "license": "MIT",

package/src/domains/workflows/index.ts

@@ -5,8 +5,7 @@ import { Text, type AutocompleteItem } from "@earendil-works/pi-tui";
 import { isAdvisoryReport } from "./runtime/advisory-schema.ts";
 import type { WorkflowProgressSnapshot } from "./runtime/progress-types.ts";
 import type { LoadedWorkflow, WorkflowProgressSource, WorkflowRef, WorkflowRunMetadata, WorkflowRunOptions } from "./runtime/types.ts";
-import { WorkflowInspector } from "./runtime/ui/workflow-inspector.ts";
-import { WORKFLOW_VIEWER_OVERLAY_OPTIONS } from "./runtime/ui/workflow-viewer-layout.ts";
+import { WorkflowInspector, WORKFLOW_INSPECTOR_OVERLAY_OPTIONS } from "./runtime/ui/workflow-inspector.ts";
 import type { PerfSink } from "./runtime/perf.ts";
 import type { WorkflowUsageSnapshot } from "./runtime/usage.ts";
 import { ADAPTIVE_WORKFLOW_GUIDANCE, registerDynamax } from "./runtime/dynamax.ts";
@@ -37,8 +36,7 @@ import {
   WORKFLOW_USAGE_LIMIT_DELAY_MIN_MS,
 } from "./runtime/options.ts";
 import { executeWorkflowInvocation, type WorkflowExecution, type WorkflowPerfDetails } from "./runtime/workflow-execution.ts";
-import { BackgroundWorkflowCoordinator } from "./runtime/background-workflows.ts";
-import { backgroundUnavailableResult, startBackgroundWorkflowTool } from "./runtime/background-workflow-tool.ts";
+import { WorkflowLifecycle, workflowUnavailableResult } from "./runtime/workflow-lifecycle.ts";
 import { WorkflowRunController } from "./runtime/workflow-run-controller.ts";
 import { completeCurrentArgument, splitArgumentPrefix } from "./runtime/command-completions.ts";
 import { assertSupportedPiVersion } from "./runtime/pi-compat.ts";
@@ -132,7 +130,6 @@ export async function resolveWorkflowRef(ref: WorkflowRef, perf?: PerfSink): Pro
 }
 
 const WORKFLOW_OPTION_COMPLETIONS = [
-  { value: "--inspect", description: "Open the live workflow inspector" },
   { value: "--refresh", description: "Refresh dynamic workflow discovery" },
   { value: "--perf", description: "Collect workflow performance metrics" },
   { value: "--result-viewer", description: "Open supported result viewers" },
@@ -195,9 +192,10 @@ export async function openWorkflowInspector(ctx: ExtensionContext, inspection: A
           () => done(undefined),
           undefined,
           source,
+          _keybindings,
         );
       },
-      WORKFLOW_VIEWER_OVERLAY_OPTIONS,
+      WORKFLOW_INSPECTOR_OVERLAY_OPTIONS,
     );
   } finally {
     unsubscribe?.();
@@ -263,7 +261,7 @@ function parseWorkflowOptions(input: string): { args: string; options: WorkflowR
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i];
     if (token === "--inspect") {
-      options.inspect = true;
+      optionErrors.push("--inspect was removed; open the running workflow with /workflow");
       continue;
     }
     if (token === "--refresh") {
@@ -413,7 +411,6 @@ export interface WorkflowToolRequestParams {
   readonly name?: string;
   readonly script?: string;
   readonly resumeFromRunId?: string;
-  readonly background?: boolean;
 }
 
 export type WorkflowToolRequest =
@@ -445,44 +442,6 @@ export function inlineCompileErrorResult(message: string): WorkflowToolErrorResu
   return { content: [{ type: "text", text: `Inline workflow did not compile: ${message}` }], details: { error: "inline_compile_error", message } };
 }
 
-export async function sendWorkflowResult(
-  pi: ExtensionAPI,
-  ctx: ExtensionContext,
-  name: string,
-  mod: LoadedWorkflow,
-  args: string,
-  options: WorkflowRunOptions,
-  perfRecorder?: PerfSink,
-  reviewSessions: ReviewSessionCoordinator = createReviewSessionCoordinator(pi),
-): Promise<void> {
-  await sendResolvedWorkflowResult(
-    pi,
-    ctx,
-    name,
-    mod,
-    args,
-    resolveWorkflowRunOptions(options),
-    perfRecorder,
-    reviewSessions,
-  );
-}
-
-async function sendResolvedWorkflowResult(
-  pi: ExtensionAPI,
-  ctx: ExtensionContext,
-  name: string,
-  mod: LoadedWorkflow,
-  args: string,
-  options: ResolvedWorkflowRunOptions,
-  perfRecorder: PerfSink | undefined,
-  reviewSessions: ReviewSessionCoordinator,
-): Promise<void> {
-  const execution = await executeResolvedWorkflow(pi, ctx, name, mod, args, options, perfRecorder);
-  reviewSessions.remember(ctx, execution, options);
-  sendWorkflowExecution(pi, execution);
-  await reviewSessions.present(ctx, execution, options);
-}
-
 async function executeResolvedWorkflow(
   pi: ExtensionAPI,
   ctx: ExtensionContext,
@@ -548,8 +507,8 @@ function createReviewSessionCoordinator(pi: ExtensionAPI): ReviewSessionCoordina
 export default function workflowEngine(pi: ExtensionAPI, shortcuts: DynamaxShortcuts = resolveDynamaxShortcuts()): void {
   assertSupportedPiVersion(VERSION);
   const reviewSessions = createReviewSessionCoordinator(pi);
-  const backgroundWorkflows = new BackgroundWorkflowCoordinator(pi);
-  const workflowRuns = new WorkflowRunController(backgroundWorkflows, {
+  const lifecycle = new WorkflowLifecycle(pi);
+  const workflowRuns = new WorkflowRunController(lifecycle, {
     async resolveWorkflow(name) {
       const { discoverWorkflows } = await loadDiscovery();
       return (await discoverWorkflows(EXTENSION_DIR)).get(name);
@@ -560,18 +519,18 @@ export default function workflowEngine(pi: ExtensionAPI, shortcuts: DynamaxShort
       reviewSessions.remember(ctx, execution, options);
     },
   });
-  backgroundWorkflows.onRunSettled((ctx, runId) => workflowRuns.runSettled(ctx, runId));
+  lifecycle.onRunSettled((ctx, runId) => workflowRuns.runSettled(ctx, runId));
   registerDynamax(pi, shortcuts, { openInspector: (ctx) => openAvailableWorkflowInspector(pi, ctx) });
   pi.on("session_start", async (_event, ctx) => {
-    await backgroundWorkflows.sessionStarted(ctx);
+    await lifecycle.sessionStarted(ctx);
     await workflowRuns.sessionStarted(ctx);
   });
   pi.on("agent_settled", async (_event, ctx) => {
-    await backgroundWorkflows.agentSettled(ctx);
+    await lifecycle.agentSettled(ctx);
   });
   pi.on("session_shutdown", async (_event, ctx) => {
     workflowRuns.sessionShutdown(ctx);
-    await backgroundWorkflows.sessionShutdown(ctx);
+    await lifecycle.sessionShutdown(ctx);
     const key = sessionKey(ctx);
     workflowInspections.get(pi)?.delete(key);
     reviewSessions.dispose(ctx);
@@ -619,24 +578,36 @@ export default function workflowEngine(pi: ExtensionAPI, shortcuts: DynamaxShort
         ctx.ui.notify(`Unknown workflow "${direct.name}". Available: ${available}`, "error");
         return;
       }
-      await sendResolvedWorkflowResult(pi, ctx, direct.name, mod, direct.args, directOptions, perfRecorder, reviewSessions);
+      const unavailable = workflowUnavailableResult(ctx.mode);
+      if (unavailable) {
+        ctx.ui.notify(unavailable.content[0].text, "warning");
+        return;
+      }
+      const started = await lifecycle.launch({
+        ctx, name: direct.name, options: directOptions,
+        async execute(runCtx, options) {
+          const execution = await executeResolvedWorkflow(pi, runCtx, direct.name, mod, direct.args, options, perfRecorder);
+          reviewSessions.remember(ctx, execution, options);
+        },
+      });
+      ctx.ui.notify(started.content[0].text, started.details.error ? "error" : "info");
     },
   });
 
-  registerWorkflowTool(pi, reviewSessions, backgroundWorkflows);
+  registerWorkflowTool(pi, reviewSessions, lifecycle);
 }
 
 /** Register the host-facing workflow tool independently from command and lifecycle surfaces. */
 function registerWorkflowTool(
   pi: ExtensionAPI,
   reviewSessions: ReviewSessionCoordinator,
-  backgroundWorkflows: BackgroundWorkflowCoordinator,
+  lifecycle: WorkflowLifecycle,
 ): void {
   pi.registerTool({
     name: "workflow",
     label: "Workflow",
     description:
-      "ONLY call workflow when the user opted in with the literal token `dynamax`, explicitly requested a workflow, or invoked a command or skill that requires one. Runs named or inline multi-agent workflows synchronously or in the background.",
+      "ONLY call workflow when the user opted in with the literal token `dynamax`, explicitly requested a workflow, or invoked a command or skill that requires one. Starts named or inline multi-agent workflows and returns a run ID immediately. Use list, inspect, or stop to manage runs and individual agents.",
     promptSnippet: "Run an existing named workflow or an inline one-off workflow script",
     promptGuidelines: [
       "Use workflow only after a `dynamax` opt-in, an explicit workflow request, or a command or skill instruction.",
@@ -650,12 +621,16 @@ function registerWorkflowTool(
       "If an inline subagent needs grep/find/code-search helpers, use `tools: [\"read\", \"bash\", \"grep\", \"find\", \"ls\"]` plus `toolHints: [\"search\"]` so installed tools such as ast-grep, mgrep, ffgrep, or fffind are discovered dynamically.",
       "`api.budget` exposes `{ total, spent(), remaining() }` (output tokens). When the run is budgeted, scale fleets from `budget.total` and guard loops with `while (budget.total && budget.remaining() > N) { await api.agent(...) }`; `api.agent()` throws once the ceiling is reached.",
       ADAPTIVE_WORKFLOW_GUIDANCE,
-      "Set background: true only when the user explicitly wants the workflow to continue after this tool call; the tool returns a durable run ID and completion is delivered later.",
-      "Set autoResumeOnUsageLimit: true only for an explicitly backgrounded workflow when the user wants bounded automatic continuation after a recognized provider usage window.",
+      "All runs return a durable run ID immediately; completion is delivered later. Use action list/inspect/stop to observe or cancel without launching another workflow.",
+      "Every api.agent() call must explicitly supply label, model, and thinkingLevel; no implicit host model or thinking defaults.",
+      "Set autoResumeOnUsageLimit: true only when the user wants bounded automatic continuation after a recognized provider usage window.",
       "Set resumeEditedWorkflow: true only with resumeFromRunId when the user explicitly accepts reusing behaviorally identical calls after workflow source edits.",
-      "Every workflow tool call must provide exactly one of `name` or `script`, never both.",
+      "Launch calls must provide exactly one of name or script. Management calls use action, runId, and optionally agentId instead.",
     ],
     parameters: Type.Object({
+      action: Type.Optional(Type.Union([Type.Literal("start"), Type.Literal("list"), Type.Literal("inspect"), Type.Literal("stop")], { description: "Defaults to start. Management actions do not launch a workflow." })),
+      runId: Type.Optional(Type.String({ minLength: 1, description: "Run to inspect or stop" })),
+      agentId: Type.Optional(Type.Integer({ minimum: 1, description: "Inspect or stop only this agent" })),
       name: Type.Optional(Type.String({ description: "Workflow name, e.g. code-review. Provide exactly one of name or script." })),
       script: Type.Optional(Type.String({ description: "Inline workflow script. Provide exactly one of script or name." })),
       args: Type.Optional(Type.String({ description: "Arguments for the workflow (e.g. target or focus)" })),
@@ -677,7 +652,7 @@ function registerWorkflowTool(
         }),
       ),
       autoResumeOnUsageLimit: Type.Optional(
-        Type.Boolean({ description: "For a background run, opt into bounded automatic resume after a recognized provider usage limit" }),
+        Type.Boolean({ description: "Opt into bounded automatic resume after a recognized provider usage limit" }),
       ),
       usageLimitMaxAttempts: Type.Optional(
         Type.Integer({
@@ -705,17 +680,16 @@ function registerWorkflowTool(
       resumeEditedWorkflow: Type.Optional(
         Type.Boolean({ description: "With resumeFromRunId, ignore only workflow-source fingerprint changes while retaining all other replay checks" }),
       ),
-      background: Type.Optional(Type.Boolean({ description: "Return a durable run ID immediately and deliver completion to this conversation later" })),
     }),
     renderCall(args, theme) {
       const suffix = args.args ? ` ${theme.fg("dim", args.args)}` : "";
-      const background = args.background ? ` ${theme.fg("dim", "(background)")}` : "";
+      if (args.action && args.action !== "start") return new Text(`▸ ${theme.fg("toolTitle", "workflow")} ${args.action} ${args.runId ?? ""}`, 0, 0);
       if (args.name?.trim()) {
-        return new Text(`▸ ${theme.fg("toolTitle", theme.bold("workflow"))} ${theme.fg("accent", args.name.trim())}${background}${suffix}`, 0, 0);
+        return new Text(`▸ ${theme.fg("toolTitle", theme.bold("workflow"))} ${theme.fg("accent", args.name.trim())}${suffix}`, 0, 0);
       }
       const preview = compactInlinePreview(args.script);
       const previewSuffix = preview ? ` ${theme.fg("dim", preview)}` : "";
-      return new Text(`▸ ${theme.fg("toolTitle", theme.bold("workflow"))} ${theme.fg("accent", "inline")}${background}${suffix}${previewSuffix}`, 0, 0);
+      return new Text(`▸ ${theme.fg("toolTitle", theme.bold("workflow"))} ${theme.fg("accent", "inline")}${suffix}${previewSuffix}`, 0, 0);
     },
     renderResult(result, { expanded, isPartial }, theme) {
       if (isPartial) return new Text(theme.fg("accent", "Running workflow…"), 0, 0);
@@ -731,6 +705,13 @@ function registerWorkflowTool(
       return new Text(theme.fg("muted", text), 0, 0);
     },
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      if (params.action && params.action !== "start") {
+        const { manageWorkflow } = await import("./runtime/workflow-management.ts");
+        return await manageWorkflow({ ...params, action: params.action }, ctx, lifecycle, workflowInspectionState(pi, ctx).active);
+      }
+      if (params.runId !== undefined || params.agentId !== undefined) {
+        return { content: [{ type: "text", text: "runId and agentId require inspect or stop." }], details: { error: "invalid_workflow_invocation" } };
+      }
       const request = normalizeWorkflowToolRequest(params);
       if (request.kind === "error") return invalidWorkflowInvocationResult();
       const resumeFromRunId = params.resumeFromRunId?.trim();
@@ -746,13 +727,10 @@ function registerWorkflowTool(
           details: { error: "invalid_edited_workflow_resume" },
         };
       }
-      if (params.background) {
-        const unavailable = backgroundUnavailableResult(ctx.mode);
-        if (unavailable) return unavailable;
-      }
+      const unavailable = workflowUnavailableResult(ctx.mode);
+      if (unavailable) return unavailable;
 
       const runOptions = resolveWorkflowRunOptions({
-        inspect: ctx.hasUI && ctx.mode === "tui",
         concurrency: params.concurrency,
         parallelSubmissionLimit: params.parallelSubmissionLimit,
         maxAgents: params.maxAgents,
@@ -796,41 +774,15 @@ function registerWorkflowTool(
       }
 
       const resultArgs = params.args ?? "";
-      if (params.background) {
-        return await startBackgroundWorkflowTool({
-          coordinator: backgroundWorkflows,
-          ctx,
-          name: resultName,
-          options: runOptions,
-          async execute(backgroundCtx, backgroundOptions) {
-            const execution = await executeResolvedWorkflow(
-              pi,
-              backgroundCtx,
-              resultName,
-              mod,
-              resultArgs,
-              backgroundOptions,
-              perfRecorder,
-            );
-            reviewSessions.remember(ctx, execution, backgroundOptions);
-          },
-        });
-      }
-      const execution = await executeResolvedWorkflow(pi, ctx, resultName, mod, resultArgs, runOptions, perfRecorder);
-      reviewSessions.remember(ctx, execution, runOptions);
-      return {
-        content: [{
-          type: "text",
-          text: formatMessageContent(
-            resultName,
-            execution.envelope.result,
-            execution.envelope.usage,
-            execution.envelope.perf,
-            execution.metadata,
-          ),
-        }],
-        details: execution.envelope,
-      };
+      return await lifecycle.launch({
+        ctx,
+        name: resultName,
+        options: runOptions,
+        async execute(runCtx, options) {
+          const execution = await executeResolvedWorkflow(pi, runCtx, resultName, mod, resultArgs, options, perfRecorder);
+          reviewSessions.remember(ctx, execution, options);
+        },
+      });
     },
   });
 }

package/src/domains/workflows/runtime/advisory-challenge.ts

@@ -41,7 +41,7 @@ export function needsChallenge(finding: AdvisoryVerified): boolean {
 
 /** A bounded recipe using existing agent/parallel calls, not a new runtime primitive. */
 export async function challengeFindings<T extends AdvisoryVerified>(
-  api: Pick<WorkflowApi, "agent" | "parallel">,
+  api: Pick<WorkflowApi, "agent" | "modelProfile" | "parallel">,
   findings: T[],
   context: string,
   options: AdvisoryChallengeOptions,
@@ -56,12 +56,12 @@ export async function challengeFindings<T extends AdvisoryVerified>(
     replacements.set(finding.candidateId, { ...finding, verdict: "NOT_SUBSTANTIATED", challenge: { status: "failed" } });
     const challenge = await api.agent(
       `Assume this finding is a false positive. Try to DISPROVE it. Find the strongest concrete counterexample or alternative root cause. Inspect callers, invariants, tests and control flow. For a repair, seek an input, race or error path that still fails. State the smallest experiment distinguishing explanations. Do not edit files or claim tests you did not run. No counterexample found is not proof.\n\nExact review context:\n${context}\n\nCandidate and verifier evidence:\n${JSON.stringify(finding)}`,
-      { label: `challenge:${finding.candidateId}`, phase: "Challenge", profile: "medium", tools: DEFAULT_ADVISORY_TOOLS, toolHints: DEFAULT_ADVISORY_TOOL_HINTS, schema: ChallengeSchema },
+      { label: `challenge:${finding.candidateId}`, phase: "Challenge", ...api.modelProfile("medium"), tools: DEFAULT_ADVISORY_TOOLS, toolHints: DEFAULT_ADVISORY_TOOL_HINTS, schema: ChallengeSchema },
     );
     replacements.set(finding.candidateId, { ...finding, verdict: "NOT_SUBSTANTIATED", challenge: { status: "failed", challenge } });
     const adjudication = await api.agent(
       `Adjudicate the original finding, independent verifier evidence and falsification attempt below. Preserve unresolved conflict; do not force consensus. A missing counterexample alone cannot upgrade a plausible claim. Cite concrete evidence and observed test results; never invent experiments.\nContext:\n${context}\nOriginal and verifier:\n${JSON.stringify(finding)}\nChallenger:\n${JSON.stringify(challenge)}`,
-      { label: `adjudicate:${finding.candidateId}`, phase: "Challenge", profile: "medium", tools: [], schema: AdjudicationSchema },
+      { label: `adjudicate:${finding.candidateId}`, phase: "Challenge", ...api.modelProfile("medium"), tools: [], schema: AdjudicationSchema },
     );
     replacements.set(finding.candidateId, {
       ...finding,

package/src/domains/workflows/runtime/agent-attempt.ts

@@ -1,6 +1,6 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { assertWorkflowBudgetAvailable } from "./budget.ts";
-import { isWorkflowPauseError } from "./cancellation.ts";
+import { isWorkflowPauseError, WorkflowAgentStoppedError } from "./cancellation.ts";
 import type { WorkflowAgentReservation } from "./agent-limits.ts";
 import {
   type AgentExecutionOptions,
@@ -132,7 +132,7 @@ export async function executeAgentAttempt(input: {
       tags,
     });
     const result = await workspace.wrapResult(rawResult);
-    if (!identity) return { kind: "live-unrecordable", result };
+    if (!identity || handle.interacted) return { kind: "live-unrecordable", result };
     if (!isReplayEnabled(replay) || !evidence) throw new Error("Replay identity produced without complete replay evidence.");
 
     const contract = await validateReplayIdentity({
@@ -156,7 +156,7 @@ export async function executeAgentAttempt(input: {
     if (
       workspace?.kind === "isolated"
       && liveStarted
-      && !rc.signal?.aborted
+      && (!rc.signal?.aborted || rc.signal.reason instanceof WorkflowAgentStoppedError)
       && !isWorkflowPauseError(error)
     ) {
       rc.worktrees.preserve(workspace.cwd);

package/src/domains/workflows/runtime/agent-options.ts

@@ -0,0 +1,18 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { AgentOptions } from "./types.ts";
+
+export const WORKFLOW_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly ThinkingLevel[];
+
+export function isWorkflowThinkingLevel(value: string): value is ThinkingLevel {
+  return (WORKFLOW_THINKING_LEVELS as readonly string[]).includes(value);
+}
+
+/** Validate before admission or any model session can be created. */
+export function assertAgentOptions(options: unknown): asserts options is AgentOptions {
+  const opts = options as Partial<AgentOptions> | undefined;
+  if (!opts || typeof opts.label !== "string" || !opts.label.trim()
+    || typeof opts.model !== "string" || !opts.model.trim()
+    || typeof opts.thinkingLevel !== "string" || !isWorkflowThinkingLevel(opts.thinkingLevel)) {
+    throw new Error("Every agent() requires explicit label, model, and thinkingLevel.");
+  }
+}

package/src/domains/workflows/runtime/agent-runner-types.ts

@@ -13,6 +13,7 @@ import type { WorkflowJournal } from "./journal.ts";
 import type { PerfSink } from "./perf.ts";
 import type { AgentOptions, WorkflowProgressEvent } from "./types.ts";
 import type { AgentChatRole } from "./progress-types.ts";
+import type { AgentTranscript } from "./live-agent.ts";
 import type { WorkflowUsageSink } from "./usage.ts";
 import type { WorktreeBaseline, WorktreeRegistry } from "./worktree.ts";
 
@@ -34,16 +35,19 @@ export type AgentRunnerSession = Pick<
   | "getLastAssistantText"
   | "isStreaming"
   | "followUp"
->;
+> & Partial<Pick<AgentSession, "setModel" | "setThinkingLevel" | "steer" | "getSteeringMessages" | "getFollowUpMessages">>;
 
 export type CreateAgentSession = (options: CreateAgentSessionOptions) => Promise<{ session: AgentRunnerSession }>;
 
 export interface AgentProgress {
-  agentQueued(phase: string | undefined, label: string, model?: string): number;
+  agentQueued(phase: string | undefined, label: string, model?: string, modelName?: string, thinkingLevel?: string): number;
+  bindAgentStop?(id: number, stop: () => void): () => void;
   agentStart(phase: string | undefined, label: string, id?: number, model?: string): void;
   agentTool(label: string, tool: string, id?: number): void;
   agentMessage(id: number, role: AgentChatRole, text: string): void;
-  bindAgentFollowUp(id: number, send: (message: string) => Promise<void>): () => void;
+  bindAgentFollowUp(id: number, send: (message: string, steer?: boolean) => Promise<void>): () => void;
+  bindAgentTranscript?(id: number, read: () => AgentTranscript): () => void;
+  agentChanged?(id: number, model?: string, modelName?: string, thinkingLevel?: string): void;
   agentDone(label: string, id?: number): void;
   agentFailed(label: string, error: unknown, id?: number): void;
   event(event: WorkflowProgressEvent): void;

package/src/domains/workflows/runtime/agent-runner.ts

@@ -1,7 +1,8 @@
+import { assertAgentOptions } from "./agent-options.ts";
 import { assertWorkflowBudgetAvailable } from "./budget.ts";
 import { combinedAgentAttemptError } from "./agent-failure.ts";
 import { WorkflowAgentTimeoutError } from "./agent-limits.ts";
-import { abortReason, linkAbortSignal, throwIfAborted } from "./cancellation.ts";
+import { abortReason, linkAbortSignal, throwIfAborted, WorkflowAgentStoppedError } from "./cancellation.ts";
 import { executeAgentAttempt } from "./agent-attempt.ts";
 import {
   createAgentReplayPlan,
@@ -53,7 +54,8 @@ export async function runAgent(
     throw new Error(`agent() prompt must be a string; received ${describeAgentPrompt(prompt)}`);
   }
 
-  const label = opts.label ?? "agent";
+  assertAgentOptions(opts);
+  const label = opts.label;
   const phase = opts.phase ?? "Workflow";
   const tags: AgentRunTags = { label, phase };
 
@@ -62,14 +64,15 @@ export async function runAgent(
     const routing = resolveAgentRouting(rc, opts, label);
     const effectiveOpts = routing.thinkingLevel === opts.thinkingLevel
       ? opts
-      : { ...opts, thinkingLevel: routing.thinkingLevel };
+      : { ...opts, thinkingLevel: routing.thinkingLevel ?? opts.thinkingLevel };
     const replay = createAgentReplayPlan(prompt, effectiveOpts);
     if (!isReplayEnabled(replay)) assertWorkflowBudgetAvailable(rc.budget);
 
     const modelLabel = describeAgentModel(routing.model);
-    const rowId = rc.progress.agentQueued(opts.phase, label, modelLabel);
+    const rowId = rc.progress.agentQueued(opts.phase, label, modelLabel, routing.model?.name, effectiveOpts.thinkingLevel);
     rc.progress.agentMessage(rowId, "task", prompt);
     const liveScope = createAgentLiveScope(rc, label);
+    const unbindStop = rc.progress.bindAgentStop?.(rowId, liveScope.stop);
     try {
       return await rc.semaphore.run(
         async () => {
@@ -129,18 +132,20 @@ export async function runAgent(
               }
               continue;
             }
+            throwIfAborted(agentRc.signal);
             const settlement = await settleAgentAttempt({ rc: agentRc, label, tags, replay: attemptPlan, outcome });
             if (settlement.kind === "retry-live") {
               attemptPlan = { kind: "off" };
               continue;
             }
+            throwIfAborted(agentRc.signal);
             rc.progress.agentDone(label, rowId);
             return settlement.result;
           }
         },
         {
           onQueueWaitMs: (durationMs) => rc.perf.observe("agent.queue_wait_ms", durationMs, tags),
-          signal: rc.signal,
+          signal: liveScope.signal,
         },
       );
     } catch (error) {
@@ -151,6 +156,7 @@ export async function runAgent(
       rc.progress.log(`${label} failed: ${unknownErrorMessage(failure)}`);
       throw failure;
     } finally {
+      unbindStop?.();
       liveScope.dispose();
     }
   }, tags);
@@ -164,6 +170,8 @@ function createAgentLiveScope(rc: RunContext, label: string) {
 
   return {
     signal: controller.signal,
+    // A local stop is recoverable by parallel(); it must not abort sibling agents.
+    stop: () => controller.abort(new WorkflowAgentStoppedError(`Agent ${label} stopped by user.`)),
     reserve() {
       const reservation = rc.agentLimiter.reserve(controller.signal);
       let committed = false;
@@ -194,7 +202,7 @@ function resolveAgentRouting(
   rc: RunContext,
   opts: AgentExecutionOptions,
   label: string,
-): { readonly model: ResolvedAgentModel["model"]; readonly thinkingLevel: AgentExecutionOptions["thinkingLevel"] } {
+): { readonly model: ResolvedAgentModel["model"]; readonly thinkingLevel: AgentExecutionOptions["thinkingLevel"] | undefined } {
   try {
     return resolveAgentModelProfile(
       {

package/src/domains/workflows/runtime/agent-session.ts

@@ -1,3 +1,5 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { sendAgentInput, type AgentTranscript } from "./live-agent.ts";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import {
   createAgentSessionFromServices,
@@ -45,7 +47,9 @@ export interface ResolvedAgentModel {
 }
 
 export interface AgentSessionHandle {
+  interacted?: boolean;
   readonly session: AgentRunnerSession;
+  readonly cwd?: string;
   readonly selectedSkills: readonly Skill[];
   hasStructuredResult(): boolean;
   structuredResult(): unknown;
@@ -124,6 +128,7 @@ export async function openAgentSession(input: {
     throwIfAborted(rc.signal);
     return {
       session,
+      cwd,
       selectedSkills: resources.selectedSkills,
       hasStructuredResult: () => captured,
       structuredResult: () => structuredResult,
@@ -149,13 +154,38 @@ export async function promptAgentSession(input: {
 }): Promise<unknown> {
   const { rc, handle, prompt, opts, label, rowId, tags } = input;
   const { session } = handle;
-  const unbindFollowUp = rc.progress.bindAgentFollowUp(rowId, async (message) => {
-    if (!session.isStreaming) throw new Error("This agent has already finished its current turn.");
-    await session.followUp(message);
+  let streaming: AgentMessage | undefined;
+  const toolUpdates = new Map<string, NonNullable<AgentTranscript["toolUpdates"]> extends ReadonlyMap<string, infer V> ? V : never>();
+  const refresh = () => rc.progress.agentChanged?.(rowId,
+    session.model ? `${session.model.provider}/${session.model.id}` : undefined,
+    session.model?.name, session.thinkingLevel);
+  const unbindTranscript = rc.progress.bindAgentTranscript?.(rowId, () => ({
+    messages: session.messages, streaming, cwd: handle.cwd, toolUpdates,
+    steering: session.getSteeringMessages?.() ?? [],
+    followUp: session.getFollowUpMessages?.() ?? [],
+  }));
+  const unbindFollowUp = rc.progress.bindAgentFollowUp(rowId, async (message, steer) => {
+    await sendAgentInput(session, rc, message, steer);
+    handle.interacted = true;
+    refresh();
   });
   const unsubscribe = session.subscribe((event) => {
+    if (event.type === "message_update" || event.type === "message_start") streaming = event.message;
+    if (event.type === "message_end") streaming = undefined;
+    if (event.type === "tool_execution_update") {
+      toolUpdates.set(event.toolCallId, { result: event.partialResult, isPartial: true, isError: false });
+    } else if (event.type === "tool_execution_end") {
+      toolUpdates.set(event.toolCallId, { result: event.result, isPartial: false, isError: event.isError });
+    }
+    refresh();
+    if (event.type === "tool_execution_end") {
+      const output = event.result.content.filter((part: { type: string }) => part.type === "text")
+        .map((part: { text?: string }) => part.text ?? "").join("\n");
+      rc.progress.agentMessage(rowId, "tool", `${event.toolName}: ${output}`);
+    }
     if (event.type === "tool_execution_start" && event.toolName !== undefined && event.toolName !== FINAL_TOOL) {
       rc.progress.agentTool(label, event.toolName, rowId);
+      rc.progress.agentMessage(rowId, "tool", `${event.toolName} ${JSON.stringify(event.args)}`);
       return;
     }
     if (event.type === "message_end" && event.message.role === "assistant") {
@@ -217,6 +247,7 @@ export async function promptAgentSession(input: {
       unlinkPromptAbort();
     }
   } finally {
+    unbindTranscript?.();
     unbindFollowUp();
     unsubscribe();
   }

package/src/domains/workflows/runtime/cancellation.ts

@@ -1,3 +1,8 @@
+/** Agent-local cancellation is recoverable and must not stop sibling tasks. */
+export class WorkflowAgentStoppedError extends Error {
+  override readonly name = "WorkflowAgentStoppedError";
+}
+
 export class WorkflowAbortError extends Error {
   constructor(message = "Workflow aborted") {
     super(message);