@jameslovespancakes/pi-plus 1.0.19 → 1.0.21

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

@@ -1,9 +1,10 @@
 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 { formatWorkflowUsageLine, type WorkflowUsageSnapshot } from "./usage.ts";
+import type { WorkflowUsageSnapshot } from "./usage.ts";
 import { unknownErrorMessage } from "./unknown-error.ts";
-import { statusTextFromCounts, type WorkflowStatusCounts } from "./ui/workflow-format.ts";
+import type { WorkflowStatusCounts } from "./ui/workflow-format.ts";
 import { toDisplayLine, toDisplayText } from "./ui/display-text.ts";
 import { renderWorkflowWidgetLines } from "./ui/workflow-widget.ts";
 
@@ -23,6 +24,8 @@ interface AgentRow {
   id: number;
   label: string;
   model?: string;
+  modelName?: string;
+  thinkingLevel?: string;
   status: AgentRowStatus;
   startedAt?: number;
   doneAt?: number;
@@ -61,7 +64,7 @@ const WIDGET_REFRESH_INTERVAL_MS = 1_000;
 export const DEFAULT_LANE_ITEM_LIMIT = 200;
 
 /**
- * Tracks live workflow state for widgets, footer/status text, result renderers,
+ * Tracks live workflow state for widgets, result renderers,
  * and headless stderr breadcrumbs.
  */
 export class ProgressTracker {
@@ -73,25 +76,34 @@ 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;
   private currentPhase = "Workflow";
   private nextAgentId = 1;
-  private lastStatusText: string | undefined;
   private usageSnapshot: WorkflowUsageSnapshot | undefined;
   private widgetRefreshInterval: ReturnType<typeof setInterval> | undefined;
   private readonly surfaceKey: string;
+  private readonly ctx: ExtensionContext;
+  private readonly title: string;
+  private readonly runId: string;
+  private readonly onSnapshot?: (snapshot: WorkflowProgressSnapshot) => void;
 
   constructor(
-    private readonly ctx: ExtensionContext,
-    private readonly title: string,
-    private readonly runId: string,
-    private readonly onSnapshot?: (snapshot: WorkflowProgressSnapshot) => void,
+    ctx: ExtensionContext,
+    title: string,
+    runId: string,
+    onSnapshot?: (snapshot: WorkflowProgressSnapshot) => void,
   ) {
+    this.ctx = ctx;
+    this.title = title;
+    this.runId = runId;
+    this.onSnapshot = onSnapshot;
     this.surfaceKey = `workflow:${runId}`;
     this.ensurePhase(this.currentPhase);
   }
@@ -154,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++;
@@ -201,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 () => {
@@ -210,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();
   }
@@ -231,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();
     }
@@ -241,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);
@@ -281,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),
     };
   }
 
@@ -336,7 +384,6 @@ export class ProgressTracker {
     if (!this.ctx.hasUI) return;
     this.publishWidget();
     this.startWidgetRefresh();
-    this.publishStatus();
   }
 
   private publishWidget(): void {
@@ -358,24 +405,6 @@ export class ProgressTracker {
     this.widgetRefreshInterval = undefined;
   }
 
-  private publishStatus(): void {
-    const status = statusTextFromCounts(
-      {
-        title: this.title,
-        doneAt: this.doneAt,
-        currentPhase: this.currentPhase,
-        counters: [...this.counters.values()].map((counter) => ({ ...counter })),
-      },
-      this.statusCountsSnapshot(),
-      this.ctx.ui.theme,
-    );
-    const usage = formatWorkflowUsageLine(this.usageSnapshot);
-    const next = usage ? `${status} · ${usage}` : status;
-    if (next === this.lastStatusText) return;
-    this.ctx.ui.setStatus(this.surfaceKey, next);
-    this.lastStatusText = next;
-  }
-
   /** Clear this run's live workflow surfaces. Final feedback is delivered by the result surface. */
   done(): void {
     this.doneAt = Date.now();
@@ -383,8 +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);
-    this.lastStatusText = 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++;
     }
   }