@jameslovespancakes/pi-plus 1.0.20 → 1.0.21

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

@@ -3,6 +3,7 @@ import type { Static, TSchema } from "typebox";
 import { bindParallel, bindPipeline, Semaphore } from "./concurrency.ts";
 import { WorkflowAgentLimiter } from "./agent-limits.ts";
 import { defaultAgentRetryScheduler, type AgentRetryScheduler } from "./agent-retry.ts";
+import { assertAgentOptions } from "./agent-options.ts";
 import { resolveWorkflowModelProfiles, type ResolvedWorkflowModelProfiles } from "./model-profiles.ts";
 import { abortReason, isWorkflowPauseError, linkAbortSignal, throwIfAborted } from "./cancellation.ts";
 import { createBudget } from "./budget.ts";
@@ -15,8 +16,6 @@ import {
   type ResolvedWorkflowRunOptions,
 } from "./options.ts";
 import type { AgentOptions, IsolatedAgentResult, LoadedWorkflow, WorkflowApi, WorkflowProgressEvent, WorkflowRef, WorkflowRunOptions } from "./types.ts";
-import { WorkflowInspector } from "./ui/workflow-inspector.ts";
-import { WORKFLOW_VIEWER_OVERLAY_OPTIONS } from "./ui/workflow-viewer-layout.ts";
 import { createWorkflowJournal, createWorkflowRunId, pruneWorkflowJournals, workflowJournalPath } from "./journal.ts";
 import { WorktreeRegistry } from "./worktree.ts";
 import { runFinalizers } from "./finalizers.ts";
@@ -101,7 +100,9 @@ export async function runResolvedWorkflow(
   const progressSource = {
     snapshot: () => progress.snapshot(),
     conversation: (agentId: number) => progress.conversation(agentId),
-    followUp: (agentId: number, message: string) => progress.followUp(agentId, message),
+    stopAgent: (agentId: number) => progress.stopAgent(agentId),
+    transcript: (agentId: number) => progress.transcript(agentId),
+    followUp: (agentId: number, message: string, steer?: boolean) => progress.followUp(agentId, message, steer),
     subscribe: (listener: () => void) => progress.subscribe(listener),
   };
   const perf = resolvedOptions.perfRecorder ?? createPerfRecorder(resolvedOptions.perf);
@@ -133,33 +134,6 @@ export async function runResolvedWorkflow(
   const unlinkOptionAbortSignal = linkAbortSignal(resolvedOptions.signal, runAbortController);
   const workflowOutcome = await captureOutcome(async () => {
     await notifyLifecycleObserver(progress, "progress source callback", () => resolvedOptions.onProgressSource?.(progressSource));
-    if (resolvedOptions.inspect && ctx.hasUI && ctx.mode === "tui") {
-      let unsubscribe: (() => void) | undefined;
-      void ctx.ui
-        .custom<void>(
-          (tui, theme, _keybindings, done) => {
-            unsubscribe = progressSource.subscribe(() => tui.requestRender());
-            return new WorkflowInspector(
-              () => progress.snapshot(),
-              tui,
-              theme,
-              () => done(undefined),
-              undefined,
-              progressSource,
-            );
-          },
-          WORKFLOW_VIEWER_OVERLAY_OPTIONS,
-        )
-        .catch((error: unknown) => {
-          try {
-            progress.log(`inspector failed: ${unknownErrorMessage(error)}`);
-          } catch {
-            // Inspector reporting is detached and must never become another rejection.
-          }
-        })
-        .finally(() => unsubscribe?.());
-    }
-
     const journal = await createWorkflowJournal({ resumePath, writePath: journalPath });
     durableRun.transition({ state: "running", progress: progress.snapshot() });
     await durableRun.flush().catch(() => undefined);
@@ -185,7 +159,7 @@ export async function runResolvedWorkflow(
       agentLimiter: new WorkflowAgentLimiter(resolvedOptions.maxAgents),
       agentTimeoutMs: resolvedOptions.agentTimeoutMs,
       agentRetries: resolvedOptions.agentRetries,
-      pauseOnProviderUsageLimit: resolvedOptions.background !== undefined,
+      pauseOnProviderUsageLimit: resolvedOptions.origin !== undefined,
       resumeEditedWorkflow: resolvedOptions.resumeEditedWorkflow,
       retryScheduler: dependencies.retryScheduler ?? defaultAgentRetryScheduler,
       modelProfiles,
@@ -214,11 +188,8 @@ export async function runResolvedWorkflow(
     ? undefined
     : backgroundPauseError(workflowOutcome.error, ctx.signal, resolvedOptions.signal);
   const willPauseWorkflow = workflowPause !== undefined
-    && (!(workflowPause instanceof WorkflowProviderUsageLimitError) || resolvedOptions.background !== undefined);
-  const preserveFailedWorktrees = !workflowOutcome.ok
-    && !willPauseWorkflow
-    && !ctx.signal?.aborted
-    && !resolvedOptions.signal?.aborted;
+    && (!(workflowPause instanceof WorkflowProviderUsageLimitError) || resolvedOptions.origin !== undefined);
+  const preserveFailedWorktrees = !workflowOutcome.ok && !willPauseWorkflow;
   if (preserveFailedWorktrees) worktrees.preserveRecoverable();
   const finalizationOutcome = await captureOutcome(() =>
     finalizeWorkflowRun({
@@ -229,7 +200,7 @@ export async function runResolvedWorkflow(
       progress,
       runStore,
       worktrees,
-      preserveWorktrees: preserveFailedWorktrees,
+      preserveWorktrees: preserveFailedWorktrees || worktrees.preservedPaths.length > 0,
       unlinkSignals: [unlinkContextAbortSignal, unlinkOptionAbortSignal],
     }),
   );
@@ -259,7 +230,7 @@ export async function runResolvedWorkflow(
     const pauseError = backgroundPauseError(pauseCandidate, ctx.signal, resolvedOptions.signal);
     if (pauseError) {
       if (pauseError instanceof WorkflowProviderUsageLimitError) {
-        if (resolvedOptions.background === undefined) {
+        if (resolvedOptions.origin === undefined) {
           durableRun.transition({
             state: "failed",
             progress: progress.snapshot(),
@@ -428,6 +399,7 @@ function createWorkflowAgent(
   function agent<S extends TSchema>(prompt: string, opts: AgentOptions<S> & { schema: S }): Promise<Static<S>>;
   function agent(prompt: string, opts?: AgentOptions): Promise<string>;
   function agent(prompt: string, agentOpts?: AgentOptions): Promise<unknown> {
+    assertAgentOptions(agentOpts);
     const scopedOptions = scope.agentOptions(agentOpts);
     const executionOptions: AgentExecutionOptions =
       scopedOptions.isolation === "worktree" && mod.isolatedWorktreeBaseline !== undefined
@@ -486,6 +458,13 @@ export async function runWorkflowWithContext(
         };
 
   const api: WorkflowApi = {
+    modelProfile(name) {
+      const profile = rc.modelProfiles[name];
+      if (!profile || profile.source === "host" || !profile.model || !profile.thinkingLevel) {
+        throw new Error(`Configure workflow profile ${name} with an explicit model and thinkingLevel in workflow-models.json.`);
+      }
+      return { model: `${profile.model.provider}/${profile.model.id}`, thinkingLevel: profile.thinkingLevel };
+    },
     agent,
     workflow,
     parallel: bindParallel({
@@ -510,7 +489,7 @@ export async function runWorkflowWithContext(
 }
 
 interface WorkflowScope {
-  agentOptions(opts: AgentOptions | undefined): AgentOptions;
+  agentOptions(opts: AgentOptions): AgentOptions;
   phase(title: string): void;
   log(message: string): void;
   event(event: WorkflowProgressEvent): void;
@@ -523,7 +502,7 @@ function createWorkflowScope(progress: WorkflowProgress, prefix: string, namespa
   return {
     agentOptions(opts) {
       const phase = opts?.phase ? display(opts.phase) : currentPhase;
-      return opts ? { ...opts, phase } : { phase };
+      return { ...opts, phase };
     },
     phase(title) {
       currentPhase = display(title);

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

@@ -81,12 +81,12 @@ export function workflowJournalPath(cwd: string, runId: string): string {
   return join(workflowRunsDir(cwd), `${validateWorkflowRunId(runId)}.jsonl`);
 }
 
-export function agentJournalKey(prompt: string, opts: AgentOptions = {}, worktreeBaseline?: WorktreeBaseline): string {
+export function agentJournalKey(prompt: string, opts: Partial<AgentOptions> = {}, worktreeBaseline?: WorktreeBaseline): string {
   const capture = captureAgentJournalKey(prompt, opts, worktreeBaseline);
   return capture.kind === "verified" ? capture.key : `agent:unverifiable:${randomUUID()}`;
 }
 
-export function hashAgentCall(prompt: string, opts: AgentOptions = {}, worktreeBaseline?: WorktreeBaseline): string {
+export function hashAgentCall(prompt: string, opts: Partial<AgentOptions> = {}, worktreeBaseline?: WorktreeBaseline): string {
   const capture = captureAgentCallHash(prompt, opts, worktreeBaseline);
   return capture.kind === "verified"
     ? capture.hash
@@ -96,7 +96,7 @@ export function hashAgentCall(prompt: string, opts: AgentOptions = {}, worktreeB
 /** Capture a replay key without allowing hostile or oversized schemas to escape as exceptions. */
 export function captureAgentJournalKey(
   prompt: string,
-  opts: AgentOptions = {},
+  opts: Partial<AgentOptions> = {},
   worktreeBaseline?: WorktreeBaseline,
 ): AgentJournalKeyCapture {
   const behavior = captureAgentCallHash(prompt, opts, worktreeBaseline);
@@ -118,7 +118,7 @@ type AgentCallHashCapture =
 
 function captureAgentCallHash(
   prompt: string,
-  opts: AgentOptions,
+  opts: Partial<AgentOptions>,
   worktreeBaseline: WorktreeBaseline | undefined,
 ): AgentCallHashCapture {
   try {

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

@@ -0,0 +1,37 @@
+import type { AgentMessage, AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { AgentRunnerSession, RunContext } from "./agent-runner-types.ts";
+import { isWorkflowThinkingLevel } from "./agent-options.ts";
+import { resolveAgentModel } from "./agent-session.ts";
+
+export interface AgentTranscript {
+  readonly cwd?: string;
+  readonly messages: readonly AgentMessage[];
+  readonly streaming?: AgentMessage;
+  readonly steering: readonly string[];
+  readonly followUp: readonly string[];
+  readonly toolUpdates?: ReadonlyMap<string, { result: AgentToolResult<unknown>; isPartial: boolean; isError: boolean }>;
+}
+
+/** Commands are scoped to the child SDK session; parent command handlers never run here. */
+export async function sendAgentInput(session: AgentRunnerSession, rc: RunContext, text: string, steer = false): Promise<void> {
+  const [command, ...rest] = text.trim().split(/\s+/);
+  const argument = rest.join(" ");
+  if (command === "/model") {
+    if (!argument || !session.setModel) throw new Error("Usage: /model provider/model");
+    const model = resolveAgentModel(argument, rc.modelRegistry, rc.hostModel).model;
+    if (!model) throw new Error("Model is unavailable.");
+    await session.setModel(model);
+    return;
+  }
+  if (command === "/thinking") {
+    if (!isWorkflowThinkingLevel(argument) || !session.setThinkingLevel) {
+      throw new Error("Usage: /thinking off|minimal|low|medium|high|xhigh|max");
+    }
+    session.setThinkingLevel(argument);
+    return;
+  }
+  if (command.startsWith("/")) throw new Error("Supported agent commands: /model provider/model, /thinking level.");
+  if (!session.isStreaming) throw new Error("This agent has finished its current turn.");
+  if (steer && session.steer) await session.steer(text);
+  else await session.followUp(text);
+}

package/src/domains/workflows/runtime/model-profiles.ts

@@ -6,6 +6,7 @@ import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { getAgentDir, type ModelRegistry } from "@earendil-works/pi-coding-agent";
 import { isMissingPathError } from "./filesystem-error.ts";
 import { unknownErrorMessage } from "./unknown-error.ts";
+import { isWorkflowThinkingLevel } from "./agent-options.ts";
 
 export const WORKFLOW_MODEL_PROFILE_NAMES = ["small", "medium", "big"] as const;
 export type WorkflowModelProfileName = (typeof WORKFLOW_MODEL_PROFILE_NAMES)[number];
@@ -56,8 +57,7 @@ export class WorkflowModelProfileConfigError extends Error {
   }
 }
 
-export const WORKFLOW_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly ThinkingLevel[];
-const THINKING_LEVELS = new Set<ThinkingLevel>(WORKFLOW_THINKING_LEVELS);
+export { WORKFLOW_THINKING_LEVELS, isWorkflowThinkingLevel } from "./agent-options.ts";
 const HOST_FALLBACK_THINKING: Record<WorkflowModelProfileName, ThinkingLevel> = {
   small: "low",
   medium: "medium",
@@ -184,10 +184,6 @@ export function isWorkflowModelProfileName(value: string): value is WorkflowMode
   return WORKFLOW_MODEL_PROFILE_NAMES.includes(value as WorkflowModelProfileName);
 }
 
-export function isWorkflowThinkingLevel(value: string): value is ThinkingLevel {
-  return THINKING_LEVELS.has(value as ThinkingLevel);
-}
-
 function parseWorkflowModelProfileFile(value: unknown, configPath: string): WorkflowModelProfileFile {
   if (!isRecord(value)) throw invalidConfig(configPath, "the root must be an object");
   assertOnlyKeys(value, ["profiles"], configPath);

package/src/domains/workflows/runtime/progress-types.ts

@@ -1,6 +1,6 @@
 import type { WorkflowUsageSnapshot } from "./usage.ts";
 
-export type AgentRowStatus = "queued" | "running" | "done" | "failed";
+export type AgentRowStatus = "queued" | "running" | "stopping" | "stopped" | "done" | "failed";
 export type AgentChatRole = "task" | "user" | "assistant" | "tool" | "status";
 export type WorkflowLaneItemStatus = "pending" | "running" | "success" | "warning" | "error";
 
@@ -15,6 +15,8 @@ export interface AgentRowSnapshot {
   readonly label: string;
   /** provider/id of the model actually routed to this agent. */
   readonly model?: string;
+  readonly modelName?: string;
+  readonly thinkingLevel?: string;
   readonly status: AgentRowStatus;
   readonly startedAt?: number;
   readonly doneAt?: number;

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

@@ -1,4 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AgentTranscript } from "./live-agent.ts";
 import type { WorkflowProgressEvent } from "./types.ts";
 import type { AgentChatMessage, AgentChatRole, AgentRowStatus, WorkflowLaneItemStatus, WorkflowProgressSnapshot } from "./progress-types.ts";
 import type { WorkflowUsageSnapshot } from "./usage.ts";
@@ -23,6 +24,8 @@ interface AgentRow {
   id: number;
   label: string;
   model?: string;
+  modelName?: string;
+  thinkingLevel?: string;
   status: AgentRowStatus;
   startedAt?: number;
   doneAt?: number;
@@ -73,9 +76,11 @@ export class ProgressTracker {
   private readonly laneOverflow = new Map<string, number>();
   private readonly rowsById = new Map<number, AgentRow>();
   private readonly agentChats = new Map<number, AgentChatMessage[]>();
-  private readonly agentFollowUps = new Map<number, (message: string) => Promise<void>>();
+  private readonly agentTranscripts = new Map<number, () => AgentTranscript>();
+  private readonly agentStops = new Map<number, () => void>();
+  private readonly agentFollowUps = new Map<number, (message: string, steer?: boolean) => Promise<void>>();
   private readonly listeners = new Set<() => void>();
-  private readonly agentCounts: Record<AgentRowStatus, number> = { queued: 0, running: 0, done: 0, failed: 0 };
+  private readonly agentCounts: Record<AgentRowStatus, number> = { queued: 0, running: 0, stopping: 0, stopped: 0, done: 0, failed: 0 };
   private readonly startedAt = Date.now();
   private readonly laneItemLimit = laneItemLimitFromEnv();
   private doneAt: number | undefined;
@@ -161,9 +166,9 @@ export class ProgressTracker {
     this.publish();
   }
 
-  agentQueued(phase: string | undefined, label: string, model?: string): number {
+  agentQueued(phase: string | undefined, label: string, model?: string, modelName?: string, thinkingLevel?: string): number {
     const id = this.nextAgentId++;
-    const row = { label, model, id, status: "queued" as const, toolUses: 0 };
+    const row = { label, model, modelName, thinkingLevel, id, status: "queued" as const, toolUses: 0 };
     this.ensurePhase(phase ?? this.currentPhase).agents.push(row);
     this.rowsById.set(id, row);
     this.agentCounts.queued++;
@@ -208,7 +213,27 @@ export class ProgressTracker {
     this.publish();
   }
 
-  bindAgentFollowUp(id: number, send: (message: string) => Promise<void>): () => void {
+  bindAgentTranscript(id: number, read: () => AgentTranscript): () => void {
+    this.agentTranscripts.set(id, read);
+    return () => {
+      const last = read();
+      const snapshot = { ...last, messages: [...last.messages], streaming: undefined };
+      this.agentTranscripts.set(id, () => snapshot);
+    };
+  }
+
+  transcript(id: number): AgentTranscript | undefined {
+    return this.agentTranscripts.get(id)?.();
+  }
+
+  agentChanged(id: number, model?: string, modelName?: string, thinkingLevel?: string): void {
+    const row = this.rowsById.get(id);
+    if (row) Object.assign(row, { model, modelName, thinkingLevel });
+    // Stream updates are UI-only; do not rewrite the durable run on every token.
+    for (const listener of this.listeners) listener();
+  }
+
+  bindAgentFollowUp(id: number, send: (message: string, steer?: boolean) => Promise<void>): () => void {
     this.agentFollowUps.set(id, send);
     this.publish();
     return () => {
@@ -217,16 +242,32 @@ export class ProgressTracker {
     };
   }
 
+  bindAgentStop(id: number, stop: () => void): () => void {
+    this.agentStops.set(id, stop);
+    return () => this.agentStops.delete(id);
+  }
+
+  stopAgent(id: number): void {
+    const row = this.rowsById.get(id);
+    if (!row) throw new Error(`Unknown agent ${id}.`);
+    if (row.status !== "running" && row.status !== "queued") return;
+    const stop = this.agentStops.get(id);
+    if (!stop) throw new Error("Agent cannot be stopped right now.");
+    this.transitionAgentStatus(row, "stopping");
+    stop();
+    this.publish();
+  }
+
   conversation(id: number): readonly AgentChatMessage[] {
     return (this.agentChats.get(id) ?? []).map((message) => ({ ...message }));
   }
 
-  async followUp(id: number, message: string): Promise<void> {
-    const text = toDisplayLine(message, AGENT_CHAT_TEXT_LIMIT);
+  async followUp(id: number, message: string, steer = false): Promise<void> {
+    const text = message.trim();
     if (!text) throw new Error("Enter a follow-up message.");
     const send = this.agentFollowUps.get(id);
     if (!send) throw new Error("This agent is no longer accepting follow-ups.");
-    await send(text);
+    await send(text, steer);
     this.appendAgentChat(id, "user", text);
     this.publish();
   }
@@ -238,7 +279,7 @@ export class ProgressTracker {
 
   agentDone(label: string, id?: number): void {
     const row = this.findRow(label, id);
-    if (row && row.status !== "failed") {
+    if (row && (row.status === "running" || row.status === "queued")) {
       this.transitionAgentStatus(row, "done");
       row.doneAt = Date.now();
     }
@@ -248,7 +289,7 @@ export class ProgressTracker {
   agentFailed(label: string, error: unknown, id?: number): void {
     const row = this.findRow(label, id);
     if (row) {
-      this.transitionAgentStatus(row, "failed");
+      this.transitionAgentStatus(row, row.status === "stopping" ? "stopped" : "failed");
       row.doneAt = Date.now();
       row.error = toDisplayLine(unknownErrorMessage(error), AGENT_ERROR_DISPLAY_LIMIT) || "agent failed";
       this.appendAgentChat(row.id, "status", row.error);
@@ -288,10 +329,10 @@ export class ProgressTracker {
   private statusCountsSnapshot(): WorkflowStatusCounts {
     return {
       queued: this.agentCounts.queued,
-      running: this.agentCounts.running,
+      running: this.agentCounts.running + this.agentCounts.stopping,
       done: this.agentCounts.done,
-      failed: this.agentCounts.failed,
-      total: this.agentCounts.queued + this.agentCounts.running + this.agentCounts.done + this.agentCounts.failed,
+      failed: this.agentCounts.failed + this.agentCounts.stopped,
+      total: Object.values(this.agentCounts).reduce((sum, count) => sum + count, 0),
     };
   }
 
@@ -371,7 +412,6 @@ export class ProgressTracker {
     this.publishSnapshot();
     if (!this.ctx.hasUI) return;
     this.ctx.ui.setWidget(this.surfaceKey, undefined);
-    this.ctx.ui.setStatus(this.surfaceKey, undefined);
   }
 
   private publishSnapshot(): void {

package/src/domains/workflows/runtime/review/review-fix-workflow.ts

@@ -32,7 +32,7 @@ export interface ReviewFixWorkflowResult {
   readonly fixes: readonly ReviewFixOutcome[];
 }
 
-export type ReviewFixWorkflowApi = Pick<WorkflowApi, "agent" | "parallel" | "phase" | "cwd" | "signal">;
+export type ReviewFixWorkflowApi = Pick<WorkflowApi, "agent" | "modelProfile" | "parallel" | "phase" | "cwd" | "signal">;
 
 /** Build an ephemeral workflow that generates one isolated patch preview per finding. */
 export function createReviewFixWorkflow(
@@ -89,7 +89,7 @@ export async function runReviewFixWorkflow(
         isolation: "worktree",
         label: `fix:${issue.id}`,
         phase: REVIEW_FIX_PHASE,
-        profile: "medium",
+        ...api.modelProfile("medium"),
         cacheKey: `review-fix:${issue.id}`,
         tools: [...REVIEW_FIX_TOOLS],
         toolHints: ["search"],
@@ -138,7 +138,7 @@ async function evaluateReviewFix(api: ReviewFixWorkflowApi, input: {
     const evaluated = await api.agent(
       `Independently evaluate a candidate repair. Your fresh worktree contains the exact reviewed baseline plus the captured patch. The implementer's report is not validation evidence. Inspect the finding, callers and tests. Reject incorrect repairs; return blocked if required validation is unavailable. Select at most six focused deterministic checks with executable and argument arrays. Require at least one meaningful behavior check. If a regression test is applicable, supply a test-only baselinePatch and specific expectedFailure so the engine can prove it fails before the repair and passes after. Do not edit, install dependencies, commit or change branches. The engine will execute checks independently.\nFinding: ${JSON.stringify(serializeReviewIssue(issue))}\nBaseline: ${isolated.baselineOid}\nPatch SHA-256: ${validation.patchHash}\nPatch:\n${isolated.patch}`,
       { isolation: "worktree", candidatePatch: { baselineOid: isolated.baselineOid, patch: isolated.patch },
-        label: `evaluate:${issue.id}`, phase: "Validate patch previews", profile: "medium", resume: "off",
+        label: `evaluate:${issue.id}`, phase: "Validate patch previews", ...api.modelProfile("medium"), resume: "off",
         tools: ["read", "bash", "grep", "find", "ls"], toolHints: ["search"], schema: PatchEvaluationSchema },
     );
     if (evaluated.baselineOid !== isolated.baselineOid || evaluated.patch !== isolated.patch) {

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

@@ -1,5 +1,6 @@
 import type { Static, TSchema } from "typebox";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { AgentTranscript } from "./live-agent.ts";
 import type { WorkflowBudget } from "./budget.ts";
 import type { Pipeline, WorkflowParallel } from "./concurrency.ts";
 import type { PerfSink, PerfSnapshot } from "./perf.ts";
@@ -35,14 +36,13 @@ export interface WorkflowRunMetadata {
   readonly recordPath: string;
 }
 
-export interface WorkflowBackgroundOrigin {
+export interface WorkflowOrigin {
   /** Stable pi session id used to route and deduplicate completion delivery. */
   readonly sessionId: string;
   readonly requestedAt: number;
 }
 
 export interface WorkflowRunOptions {
-  inspect?: boolean;
   perf?: boolean;
   concurrency?: number;
   parallelSubmissionLimit?: number;
@@ -64,8 +64,8 @@ export interface WorkflowRunOptions {
   budget?: number;
   /** Internal/test override for the generated run id. Omit to generate a new id. */
   runId?: string;
-  /** Internal origin metadata for an explicitly backgrounded tool invocation. */
-  background?: WorkflowBackgroundOrigin;
+  /** Owning session for durable completion delivery. */
+  origin?: WorkflowOrigin;
   /** Replay completed agent results from this prior run id when call and execution context still match. */
   resumeFromRunId?: string;
   /** Explicitly allow resume to ignore only a workflow-source fingerprint mismatch. */
@@ -92,7 +92,9 @@ export interface WorkflowRunOptions {
 export interface WorkflowProgressSource {
   snapshot(): WorkflowProgressSnapshot;
   conversation(agentId: number): readonly AgentChatMessage[];
-  followUp(agentId: number, message: string): Promise<void>;
+  stopAgent?(agentId: number): void;
+  transcript?(agentId: number): AgentTranscript | undefined;
+  followUp(agentId: number, message: string, steer?: boolean): Promise<void>;
   subscribe(listener: () => void): () => void;
 }
 
@@ -122,19 +124,16 @@ export type WorkflowProgressEvent =
 
 export interface AgentOptions<S extends TSchema = TSchema> {
   /** Label shown in the progress tree (e.g. "find:logic-bugs"). */
-  label?: string;
+  label: string;
   /** Phase to group this agent under in the progress tree. */
   phase?: string;
   /**
-   * Optional model id. Overrides profile routing; when both model and profile are
-   * omitted, inherit the host model. Explicit refs are strict: bare ids resolve as
-   * Anthropic shorthand; use "provider/id" for other providers.
+   * Required model id. Bare ids resolve as Anthropic shorthand;
+   * use "provider/id" for other providers. No implicit host fallback.
    */
-  model?: string;
-  /** Reasoning effort for this agent. Overrides the profile's configured effort. */
-  thinkingLevel?: ThinkingLevel;
-  /** Exact configured model route to use when model/thinkingLevel do not override it. */
-  profile?: WorkflowModelProfileName;
+  model: string;
+  /** Required reasoning effort for this agent. */
+  thinkingLevel: ThinkingLevel;
   /**
    * Stable identity hint for resume replay. Use this for repeated logical calls
    * with identical prompts/options, e.g. `${stage}:${item.id}`.
@@ -187,6 +186,8 @@ export interface AgentOptions<S extends TSchema = TSchema> {
  * exports `meta` plus a default `async (api: WorkflowApi) => result`.
  */
 export interface WorkflowApi {
+  /** Resolve an explicitly configured route; throws instead of inheriting the host. */
+  modelProfile(name: WorkflowModelProfileName): Pick<AgentOptions, "model" | "thinkingLevel">;
   /** Run a schema subagent in an isolated worktree and return its structured result plus patch. */
   agent<S extends TSchema>(
     prompt: string,
@@ -197,7 +198,7 @@ export interface WorkflowApi {
   /** Run a subagent and return validated structured output; rejects with a recoverable typed error on repair exhaustion. */
   agent<S extends TSchema>(prompt: string, opts: AgentOptions<S> & { schema: S }): Promise<Static<S>>;
   /** Run a subagent and return its final assistant text. */
-  agent(prompt: string, opts?: AgentOptions): Promise<string>;
+  agent(prompt: string, opts: AgentOptions): Promise<string>;
   /**
    * Run another registered workflow inline as a sub-step and return its result. The child shares
    * this run's concurrency cap, abort signal, and perf sink. Nests one level only: calling

package/src/domains/workflows/runtime/ui/agent-transcript.ts

@@ -0,0 +1,59 @@
+import { AssistantMessageComponent, ToolExecutionComponent, UserMessageComponent } from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import type { AgentTranscript } from "../live-agent.ts";
+
+/** Native pi transcript components, driven by the child session's own messages. */
+export class AgentTranscriptView {
+  private readonly components = new WeakMap<object, Component>();
+  private readonly tools = new Map<string, ToolExecutionComponent>();
+  private readonly results = new Map<string, object>();
+
+  render(transcript: AgentTranscript, width: number, tui: TUI, cwd: string): string[] {
+    const messages = transcript.streaming && !transcript.messages.includes(transcript.streaming)
+      ? [...transcript.messages, transcript.streaming] : transcript.messages;
+    const rows: string[] = [];
+    for (const message of messages) {
+      if (message.role === "user") {
+        let component = this.components.get(message);
+        if (!component) {
+          const text = typeof message.content === "string" ? message.content
+            : message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+          component = new UserMessageComponent(text);
+          this.components.set(message, component);
+        }
+        rows.push(...component.render(width));
+      } else if (message.role === "assistant") {
+        // Streaming messages can be mutated by pi; update the native component every render.
+        let component = this.components.get(message) as AssistantMessageComponent | undefined;
+        if (!component) {
+          component = new AssistantMessageComponent(message, false);
+          this.components.set(message, component);
+        }
+        component.updateContent(message, message === transcript.streaming);
+        rows.push(...component.render(width));
+        for (const part of message.content) {
+          if (part.type !== "toolCall") continue;
+          let tool = this.tools.get(part.id);
+          if (!tool) {
+            tool = new ToolExecutionComponent(part.name, part.id, part.arguments, { showImages: false }, undefined, tui, cwd);
+            this.tools.set(part.id, tool);
+          }
+          tool.updateArgs(part.arguments);
+          if (message !== transcript.streaming) tool.setArgsComplete();
+          const update = transcript.toolUpdates?.get(part.id);
+          if (update && this.results.get(part.id) !== update) {
+            tool.updateResult({ ...update.result, isError: update.isError }, update.isPartial);
+            this.results.set(part.id, update);
+          }
+          const result = messages.find((candidate) => candidate.role === "toolResult" && candidate.toolCallId === part.id);
+          if (result?.role === "toolResult" && this.results.get(part.id) !== result) {
+            tool.updateResult(result);
+            this.results.set(part.id, result);
+          }
+          rows.push(...tool.render(width));
+        }
+      }
+    }
+    return rows;
+  }
+}

package/src/domains/workflows/runtime/ui/workflow-format.ts

@@ -4,7 +4,7 @@ import type { AgentRowSnapshot, WorkflowLaneItemStatus, WorkflowProgressSnapshot
 import { toDisplayLine } from "./display-text.ts";
 import { formatWorkflowUsageLine } from "../usage.ts";
 
-export type WorkflowDisplayStatus = WorkflowLaneItemStatus | "queued" | "done" | "failed";
+export type WorkflowDisplayStatus = WorkflowLaneItemStatus | "queued" | "done" | "failed" | "stopping" | "stopped";
 export type WorkflowThemeColor = Parameters<Theme["fg"]>[0];
 
 export function formatDuration(ms: number): string {
@@ -42,6 +42,10 @@ export function statusIcon(status: WorkflowDisplayStatus, theme: Theme): string
     case "error":
     case "failed":
       return theme.fg("error", "✗");
+    case "stopped":
+      return theme.fg("dim", "■");
+    case "stopping":
+      return theme.fg("warning", "◌");
     case "running":
       return theme.fg("accent", "●");
     case "queued":
@@ -151,7 +155,7 @@ function countSnapshotAgents(snapshot: WorkflowProgressSnapshot): WorkflowStatus
   const counts = { queued: 0, running: 0, done: 0, failed: 0, total: 0 };
   for (const phase of snapshot.phases) {
     for (const agent of phase.agents) {
-      counts[agent.status]++;
+      counts[agent.status === "stopped" ? "failed" : agent.status === "stopping" ? "running" : agent.status]++;
       counts.total++;
     }
   }