supipowers 0.7.9 → 0.7.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "description": "OMP-native workflow extension inspired by supipowers.",
   "type": "module",
   "scripts": {

package/src/commands/run.ts

@@ -27,6 +27,7 @@ import { buildWorktreePrompt } from "../git/worktree.js";
 import { buildBranchFinishPrompt } from "../git/branch-finish.js";
 import { detectBaseBranch } from "../git/base-branch.js";
 import type { RunManifest, AgentResult } from "../types.js";
+import { AgentGridWidget, createAgentGridFactory } from "../orchestrator/agent-grid.js";
 
 interface ParsedRunArgs {
   profile?: string;
@@ -175,6 +176,23 @@ export function registerRunCommand(pi: ExtensionAPI): void {
       const lsp = isLspAvailable(pi.getActiveTools());
       const ctxMode = detectContextMode(pi.getActiveTools()).available;
 
+      // Mount agent grid widget for live progress visualization
+      let widget: AgentGridWidget | undefined;
+      if (ctx.hasUI) {
+        const widgetReady = new Promise<AgentGridWidget>((resolve) => {
+          ctx.ui.setWidget("supi-agents", createAgentGridFactory((w) => {
+            widget = w;
+            for (const task of plan.tasks) {
+              w.addTask(task.id, task.name);
+            }
+            resolve(w);
+          }));
+        });
+        // Wait for TUI to instantiate the widget before dispatching agents
+        widget = await widgetReady;
+      }
+
+      try {
       for (const batch of manifest.batches) {
         if (batch.status === "completed") continue;
 
@@ -200,6 +218,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
             config,
             lspAvailable: lsp,
             contextModeAvailable: ctxMode,
+            widget,
           });
         });
 
@@ -236,6 +255,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
                 config,
                 lspAvailable: lsp,
                 contextModeAvailable: ctxMode,
+                widget,
                 previousOutput: failed.output,
                 failureReason: failed.output,
               });
@@ -267,6 +287,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
       manifest.completedAt = new Date().toISOString();
       updateRun(ctx.cwd, manifest);
 
+
       const durationSec = Math.round(runSummary.totalDuration / 1000);
       notifySummary(
         ctx,
@@ -292,6 +313,13 @@ export function registerRunCommand(pi: ExtensionAPI): void {
         );
         notifyInfo(ctx, "Run succeeded", "Follow branch finish instructions to integrate your work");
       }
+      } finally {
+        // Ensure widget interval timer is cleaned up even on exception
+        widget?.dispose();
+        if (ctx.hasUI) {
+          ctx.ui.setWidget("supi-agents", undefined);
+        }
+      }
     },
   });
 }

package/src/orchestrator/agent-grid.ts

@@ -0,0 +1,439 @@
+/**
+ * Agent Grid Widget — TUI component for live sub-agent progress visualization.
+ *
+ * Renders task cards in a flexbox-like grid that reflows based on terminal width.
+ * Each card shows: status icon, task name, current thinking, tool activity log,
+ * files changed count, and elapsed time.
+ *
+ * Cards collapse when done/blocked to make room for active cards.
+ */
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const MIN_CARD_WIDTH = 38;
+const MAX_ACTIVITY_LOG = 4;
+const ANIMATION_INTERVAL_MS = 200;
+
+// ── Types ──────────────────────────────────────────────────────────
+
+export type TaskStatus =
+  | "pending"
+  | "running"
+  | "reviewing"
+  | "done"
+  | "done_with_concerns"
+  | "blocked";
+
+export interface TaskCardState {
+  taskId: number;
+  name: string;
+  status: TaskStatus;
+  currentThinking: string;
+  activityLog: string[];
+  filesChanged: number;
+  toolCount: number;
+  startedAt: number;
+  completedAt?: number;
+  errorReason?: string;
+  concerns?: string;
+}
+
+/** Minimal TUI interface — matches what setWidget factory receives */
+interface TUI {
+  requestRender(): void;
+}
+
+/** Minimal Theme interface — matches OMP's Theme class */
+interface Theme {
+  fg(color: string, text: string): string;
+  symbol(key: string): string;
+}
+
+/** Component interface as defined by @oh-my-pi/pi-tui */
+interface Component {
+  render(width: number): string[];
+  invalidate(): void;
+  dispose?(): void;
+}
+
+// ── Status Config ──────────────────────────────────────────────────
+
+interface StatusConfig {
+  color: string;
+  icon: string;
+}
+
+const STATUS_CONFIG: Record<TaskStatus, StatusConfig> = {
+  pending:            { color: "dim",     icon: "○" },
+  running:            { color: "accent",  icon: "●" },
+  reviewing:          { color: "warning", icon: "◎" },
+  done:               { color: "success", icon: "✓" },
+  done_with_concerns: { color: "warning", icon: "⚠" },
+  blocked:            { color: "error",   icon: "✗" },
+};
+
+// ── AgentGridWidget ────────────────────────────────────────────────
+
+export class AgentGridWidget implements Component {
+  #tasks = new Map<number, TaskCardState>();
+  #tui: TUI;
+  #theme: Theme;
+  #spinnerFrame = 0;
+  #intervalId: ReturnType<typeof setInterval> | null = null;
+  #cachedLines: string[] | undefined;
+  #cachedWidth: number | undefined;
+
+  constructor(tui: TUI, theme: Theme) {
+    this.#tui = tui;
+    this.#theme = theme;
+
+    // Animate spinner + elapsed time
+    this.#intervalId = setInterval(() => {
+      this.#spinnerFrame = (this.#spinnerFrame + 1) % SPINNER_FRAMES.length;
+      // Only re-render if we have active tasks
+      const hasActive = [...this.#tasks.values()].some(
+        (t) => t.status === "running" || t.status === "reviewing",
+      );
+      if (hasActive) {
+        this.invalidate();
+        this.#tui.requestRender();
+      }
+    }, ANIMATION_INTERVAL_MS);
+  }
+
+  // ── Public API (called by dispatcher) ──────────────────────────
+
+  /** Initialize a task card */
+  addTask(taskId: number, name: string): void {
+    this.#tasks.set(taskId, {
+      taskId,
+      name,
+      status: "pending",
+      currentThinking: "",
+      activityLog: [],
+      filesChanged: 0,
+      toolCount: 0,
+      startedAt: Date.now(),
+    });
+    this.#invalidateAndRender();
+  }
+
+  /** Update task status */
+  setStatus(taskId: number, status: TaskStatus, reason?: string): void {
+    const task = this.#tasks.get(taskId);
+    if (!task) return;
+    task.status = status;
+    if (status === "blocked") task.errorReason = reason;
+    if (status === "done_with_concerns") task.concerns = reason;
+    if (status === "done" || status === "done_with_concerns" || status === "blocked") {
+      task.completedAt = Date.now();
+    }
+    this.#invalidateAndRender();
+  }
+
+  /** Update thinking preview */
+  setThinking(taskId: number, text: string): void {
+    const task = this.#tasks.get(taskId);
+    if (!task) return;
+    task.currentThinking = text;
+    this.#invalidateAndRender();
+  }
+
+  /** Add a tool call to the activity log */
+  addActivity(taskId: number, description: string): void {
+    const task = this.#tasks.get(taskId);
+    if (!task) return;
+    task.toolCount++;
+    task.activityLog.push(description);
+    if (task.activityLog.length > MAX_ACTIVITY_LOG) {
+      task.activityLog.shift();
+    }
+    this.#invalidateAndRender();
+  }
+
+  /** Increment files changed count */
+  addFileChanged(taskId: number): void {
+    const task = this.#tasks.get(taskId);
+    if (!task) return;
+    task.filesChanged++;
+    this.#invalidateAndRender();
+  }
+
+  // ── Component Interface ────────────────────────────────────────
+
+  render(width: number): string[] {
+    if (this.#cachedLines && this.#cachedWidth === width) return this.#cachedLines;
+    if (this.#tasks.size === 0) return [];
+
+    const tasks = [...this.#tasks.values()];
+    const cardWidth = this.#computeCardWidth(width);
+    const cardsPerRow = Math.max(1, Math.floor(width / cardWidth));
+
+    const lines: string[] = [];
+
+    // Render in rows
+    for (let i = 0; i < tasks.length; i += cardsPerRow) {
+      const rowTasks = tasks.slice(i, i + cardsPerRow);
+      const rowCards = rowTasks.map((t) => this.#renderCard(t, cardWidth));
+      const merged = this.#mergeCardRows(rowCards, cardWidth, width);
+      lines.push(...merged);
+    }
+
+    this.#cachedLines = lines;
+    this.#cachedWidth = width;
+    return lines;
+  }
+
+  invalidate(): void {
+    this.#cachedLines = undefined;
+    this.#cachedWidth = undefined;
+  }
+
+  dispose(): void {
+    if (this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = null;
+    }
+  }
+
+  // ── Private Rendering ──────────────────────────────────────────
+
+  /** Box drawing chars shorthand */
+  get #box() {
+    return {
+      tl: this.#theme.symbol("boxRound.topLeft"),
+      tr: this.#theme.symbol("boxRound.topRight"),
+      bl: this.#theme.symbol("boxRound.bottomLeft"),
+      br: this.#theme.symbol("boxRound.bottomRight"),
+      h: this.#theme.symbol("boxRound.horizontal"),
+      v: this.#theme.symbol("boxRound.vertical"),
+    };
+  }
+
+  #invalidateAndRender(): void {
+    this.invalidate();
+    this.#tui.requestRender();
+  }
+
+  #computeCardWidth(termWidth: number): number {
+    if (termWidth < MIN_CARD_WIDTH) return termWidth; // terminal too narrow, use full width
+    const maxWidth = Math.floor(termWidth / 2);
+    const cardsPerRow = Math.max(1, Math.floor(termWidth / MIN_CARD_WIDTH));
+    const computed = Math.floor(termWidth / cardsPerRow);
+    return Math.max(MIN_CARD_WIDTH, Math.min(computed, maxWidth));
+  }
+
+  #renderCard(task: TaskCardState, width: number): string[] {
+    const isCollapsed =
+      task.status === "done" ||
+      task.status === "done_with_concerns" ||
+      task.status === "blocked" ||
+      task.status === "pending";
+
+    if (isCollapsed) {
+      return this.#renderCollapsedCard(task, width);
+    }
+    return this.#renderActiveCard(task, width);
+  }
+
+  #renderCollapsedCard(task: TaskCardState, width: number): string[] {
+    const { color, icon } = STATUS_CONFIG[task.status];
+    const box = this.#box;
+    const inner = width - 4; // 2 border + 2 padding
+
+    if (task.status === "pending") {
+      const title = this.#truncate(`${icon} Task ${task.taskId}: ${task.name}`, inner);
+      return [
+        this.#theme.fg(color, `${box.tl}${box.h} ${title} ${this.#pad(box.h, inner - title.length - 1)}${box.tr}`),
+        this.#theme.fg(color, `${box.bl}${this.#pad(box.h, width - 2)}${box.br}`),
+      ];
+    }
+
+    // Done / blocked / concerns
+    let suffix = "";
+    if (task.status === "done" || task.status === "done_with_concerns") {
+      const elapsed = this.#formatElapsed(task);
+      suffix = `${task.filesChanged} files, ${elapsed}`;
+    } else if (task.status === "blocked") {
+      suffix = "BLOCKED";
+    }
+
+    const title = this.#truncate(`${icon} Task ${task.taskId}: ${task.name}`, inner - suffix.length - 4);
+    const headerContent = `${title} ── ${suffix}`;
+    const headerPad = Math.max(0, inner - this.#visibleLength(headerContent) - 1);
+
+    const lines = [
+      this.#theme.fg(color, `${box.tl}${box.h} ${headerContent}${this.#pad(box.h, headerPad)} ${box.tr}`),
+    ];
+
+    // Show error reason for blocked, concerns for done_with_concerns
+    const detail = task.status === "blocked" ? task.errorReason : task.concerns;
+    if (detail) {
+      const detailText = this.#truncate(`  ${detail}`, inner);
+      lines.push(
+        this.#theme.fg(color, box.v) +
+        ` ${detailText}${" ".repeat(Math.max(0, inner - this.#visibleLength(detailText)))} ` +
+        this.#theme.fg(color, box.v),
+      );
+    }
+
+    lines.push(
+      this.#theme.fg(color, `${box.bl}${this.#pad(box.h, width - 2)}${box.br}`),
+    );
+    return lines;
+  }
+
+  #renderActiveCard(task: TaskCardState, width: number): string[] {
+    const { color, icon } = STATUS_CONFIG[task.status];
+    const box = this.#box;
+    const inner = width - 4; // 2 border + 2 padding
+    const spinner = SPINNER_FRAMES[this.#spinnerFrame];
+
+    const lines: string[] = [];
+
+    // ── Header
+    const title = this.#truncate(`${icon} Task ${task.taskId}: ${task.name}`, inner);
+    lines.push(
+      this.#theme.fg(color, `${box.tl}${box.h} ${title} ${this.#pad(box.h, inner - this.#visibleLength(title) - 1)}${box.tr}`),
+    );
+
+    // ── Sticky thinking line
+    const thinkingText = task.currentThinking
+      ? this.#truncate(`${spinner} ${task.currentThinking}`, inner)
+      : `${spinner} Working...`;
+    lines.push(this.#line(
+      this.#theme.fg("dim", thinkingText),
+      inner,
+      color,
+    ));
+
+    // ── Separator
+    const sep = this.#pad("─", inner);
+    lines.push(this.#line(this.#theme.fg("dim", sep), inner, color));
+
+    // ── Activity log (pad to MAX_ACTIVITY_LOG lines)
+    const logLines = task.activityLog.slice(-MAX_ACTIVITY_LOG);
+    for (let i = 0; i < MAX_ACTIVITY_LOG; i++) {
+      const entry = logLines[i];
+      if (entry) {
+        const text = this.#truncate(` ${entry}`, inner);
+        // Tool entries start with action verbs (Reading, Editing, Running, etc.)
+        // Thinking entries are plain text from the agent
+        const isToolAction = /^ (?:Reading|Editing|Writing|Running|Searching|Finding|Spawning|Glob|Grep|Bash|Edit|Read|Write)/.test(entry);
+        const styled = isToolAction ? text : this.#theme.fg("dim", text);
+        lines.push(this.#line(styled, inner, color));
+      } else {
+        lines.push(this.#line("", inner, color));
+      }
+    }
+
+    // ── Empty line
+    lines.push(this.#line("", inner, color));
+
+    // ── Footer
+    const filesLabel = `${task.filesChanged} file${task.filesChanged !== 1 ? "s" : ""}`;
+    const elapsed = `⏱ ${this.#formatElapsed(task)}`;
+    const gap = Math.max(1, inner - this.#visibleLength(filesLabel) - this.#visibleLength(elapsed));
+    const footerContent = `${filesLabel}${" ".repeat(gap)}${elapsed}`;
+    lines.push(this.#line(this.#theme.fg("dim", footerContent), inner, color));
+
+    // ── Bottom border
+    lines.push(
+      this.#theme.fg(color, `${box.bl}${this.#pad(box.h, width - 2)}${box.br}`),
+    );
+
+    return lines;
+  }
+
+  /** Render a content line with colored side borders */
+  #line(content: string, inner: number, borderColor: string): string {
+    const box = this.#box;
+    const contentLen = this.#visibleLength(content);
+    const pad = Math.max(0, inner - contentLen);
+    return (
+      this.#theme.fg(borderColor, box.v) +
+      ` ${content}${" ".repeat(pad)} ` +
+      this.#theme.fg(borderColor, box.v)
+    );
+  }
+
+  /** Merge multiple card columns into rows of lines */
+  #mergeCardRows(cards: string[][], cardWidth: number, termWidth: number): string[] {
+    const maxHeight = Math.max(...cards.map((c) => c.length));
+    const gap = 1; // space between cards
+    const merged: string[] = [];
+
+    for (let row = 0; row < maxHeight; row++) {
+      let line = "";
+      for (let col = 0; col < cards.length; col++) {
+        if (col > 0) line += " ".repeat(gap);
+        const cardLine = cards[col][row] ?? " ".repeat(cardWidth);
+        line += cardLine;
+      }
+      merged.push(line);
+    }
+    return merged;
+  }
+
+  // ── Utilities ──────────────────────────────────────────────────
+
+  #truncate(text: string, maxLen: number): string {
+    if (this.#visibleLength(text) <= maxLen) return text;
+    // Walk through the string, counting only visible chars, preserving ANSI sequences
+    const ansiRegex = /\x1b\[[0-9;]*m/g;
+    let result = "";
+    let visible = 0;
+    let lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = ansiRegex.exec(text)) !== null) {
+      // Add visible chars before this ANSI sequence
+      const before = text.slice(lastIndex, match.index);
+      const remaining = maxLen - 1 - visible;
+      if (before.length > remaining) {
+        result += before.slice(0, remaining) + "…";
+        return result + "\x1b[0m"; // reset styling
+      }
+      result += before;
+      visible += before.length;
+      result += match[0]; // preserve ANSI sequence
+      lastIndex = match.index + match[0].length;
+    }
+    // Handle remaining text after last ANSI sequence
+    const tail = text.slice(lastIndex);
+    const remaining = maxLen - 1 - visible;
+    if (tail.length > remaining) {
+      result += tail.slice(0, remaining) + "…";
+      return result + "\x1b[0m";
+    }
+    result += tail;
+    return result;
+  }
+
+  #visibleLength(text: string): number {
+    return text.replace(/\x1b\[[0-9;]*m/g, "").length;
+  }
+
+  #pad(char: string, count: number): string {
+    return char.repeat(Math.max(0, count));
+  }
+
+  #formatElapsed(task: TaskCardState): string {
+    const end = task.completedAt ?? Date.now();
+    const sec = Math.floor((end - task.startedAt) / 1000);
+    if (sec < 60) return `${sec}s`;
+    const min = Math.floor(sec / 60);
+    return `${min}m ${sec % 60}s`;
+  }
+}
+
+// ── Factory ────────────────────────────────────────────────────────
+
+/** Create the widget factory for ctx.ui.setWidget */
+export function createAgentGridFactory(
+  onCreated: (widget: AgentGridWidget) => void,
+): (tui: TUI, theme: Theme) => AgentGridWidget {
+  return (tui: TUI, theme: Theme) => {
+    const widget = new AgentGridWidget(tui, theme);
+    onCreated(widget);
+    return widget;
+  };
+}

package/src/orchestrator/dispatcher.ts

@@ -18,6 +18,7 @@ import {
   notifyError,
   notifyInfo,
 } from "../notifications/renderer.js";
+import type { AgentGridWidget } from "./agent-grid.js";
 
 export interface DispatchOptions {
   pi: ExtensionAPI;
@@ -30,18 +31,22 @@ export interface DispatchOptions {
   config: SupipowersConfig;
   lspAvailable: boolean;
   contextModeAvailable: boolean;
+  widget?: AgentGridWidget;
 }
 
 export async function dispatchAgent(
   options: DispatchOptions,
 ): Promise<AgentResult> {
-  const { pi, ctx, task, planContext, config, lspAvailable, contextModeAvailable } = options;
+  const { pi, ctx, task, planContext, config, lspAvailable, contextModeAvailable, widget } = options;
   const startTime = Date.now();
 
   const prompt = buildTaskPrompt(task, planContext, config, lspAvailable, contextModeAvailable);
 
+  // Initialize widget card if available
+  widget?.setStatus(task.id, "running");
+
   try {
-    const result = await executeSubAgent(pi, prompt, task, config);
+    const result = await executeSubAgent(pi, prompt, task, config, ctx, widget);
 
     const agentResult: AgentResult = {
       taskId: task.id,
@@ -52,28 +57,31 @@ export async function dispatchAgent(
       duration: Date.now() - startTime,
     };
 
+    // Update widget with final status
     switch (agentResult.status) {
       case "done":
+        widget?.setStatus(task.id, "done");
         notifySuccess(ctx, `Task ${task.id} completed`, task.name);
         break;
       case "done_with_concerns":
-        notifyWarning(
-          ctx,
-          `Task ${task.id} done with concerns`,
-          agentResult.concerns,
-        );
+        widget?.setStatus(task.id, "done_with_concerns", agentResult.concerns);
+        notifyWarning(ctx, `Task ${task.id} done with concerns`, agentResult.concerns);
         break;
       case "blocked":
+        widget?.setStatus(task.id, "blocked", agentResult.output);
         notifyError(ctx, `Task ${task.id} blocked`, agentResult.output);
         break;
     }
 
     return agentResult;
   } catch (error) {
+    const errorMsg = `Agent error: ${error instanceof Error ? error.message : String(error)}`;
+    widget?.setStatus(task.id, "blocked", errorMsg);
+
     const agentResult: AgentResult = {
       taskId: task.id,
       status: "blocked",
-      output: `Agent error: ${error instanceof Error ? error.message : String(error)}`,
+      output: errorMsg,
       filesChanged: [],
       duration: Date.now() - startTime,
     };
@@ -89,16 +97,152 @@ interface SubAgentResult {
   filesChanged: string[];
 }
 
+type NotifyCtx = { ui: { notify(msg: string, type?: "info" | "warning" | "error"): void } };
+
+/** Shorten a file path for display */
+function shortenPath(filePath: string): string {
+  const parts = filePath.split("/");
+  return parts.length > 3
+    ? `.../${parts.slice(-3).join("/")}`
+    : filePath;
+}
+
+/** Format a tool call for display */
+function formatToolAction(toolName: string, args?: Record<string, unknown>): string {
+  const path = args?.file_path ? shortenPath(String(args.file_path)) : "";
+  switch (toolName) {
+    case "Read": return `Reading ${path}`;
+    case "Edit": return `Editing ${path}`;
+    case "Write": return `Writing ${path}`;
+    case "Bash": {
+      const cmd = String(args?.command ?? "").slice(0, 60);
+      return `Running: ${cmd}${String(args?.command ?? "").length > 60 ? "..." : ""}`;
+    }
+    case "Grep": return `Searching for ${args?.pattern ?? "pattern"}`;
+    case "Glob": return `Finding files ${args?.pattern ?? ""}`;
+    case "Agent": return "Spawning sub-agent";
+    default: return `${toolName}${path ? ` ${path}` : ""}`;
+  }
+}
+
 async function executeSubAgent(
   pi: ExtensionAPI,
   prompt: string,
   task: PlanTask,
   config: SupipowersConfig,
+  ctx?: NotifyCtx,
+  widget?: AgentGridWidget,
 ): Promise<SubAgentResult> {
-  throw new Error(
-    "Sub-agent dispatch requires OMP runtime. " +
-      "This will be connected to createAgentSession during integration.",
-  );
+  const { createAgentSession } = pi.pi;
+
+  const { session } = await createAgentSession({
+    cwd: process.cwd(),
+    hasUI: false,
+    taskDepth: 1,
+    parentTaskPrefix: `task-${task.id}`,
+    // Prevent sub-agent from re-loading supipowers (causes recursive init error)
+    disableExtensionDiscovery: true,
+    skills: [],
+    promptTemplates: [],
+    slashCommands: [],
+  });
+
+  // Track files changed and emit live progress
+  const filesChanged = new Set<string>();
+  const FILE_TOOLS = new Set(["Edit", "Write", "NotebookEdit"]);
+  const pendingToolArgs = new Map<string, Record<string, unknown>>();
+  const tag = `Task ${task.id}`;
+  let lastThinkingPreview = "";
+  const unsubscribe = session.subscribe((event) => {
+    if (event.type === "message_update") {
+      const msg = event.message as { content?: unknown } | undefined;
+      const content = extractTextContent(msg?.content);
+      const preview = content.split("\n").filter(Boolean).pop()?.slice(0, 80) ?? "";
+      if (preview && preview !== lastThinkingPreview) {
+        lastThinkingPreview = preview;
+        if (widget) {
+          widget.setThinking(task.id, preview);
+        } else if (ctx) {
+          ctx.ui.notify(`${tag}: thinking — ${preview}`, "info");
+        }
+      }
+    }
+    if (event.type === "tool_execution_start") {
+      const args = event.args as Record<string, unknown> | undefined;
+      if (FILE_TOOLS.has(event.toolName) && args?.file_path) {
+        pendingToolArgs.set(event.toolCallId, args);
+      }
+      if (widget) {
+        widget.addActivity(task.id, formatToolAction(event.toolName, args));
+      } else if (ctx) {
+        ctx.ui.notify(`${tag}: ${formatToolAction(event.toolName, args)}`, "info");
+      }
+    }
+    if (event.type === "tool_execution_end") {
+      const args = pendingToolArgs.get(event.toolCallId);
+      if (args?.file_path && !event.isError) {
+        filesChanged.add(String(args.file_path));
+        widget?.addFileChanged(task.id);
+      }
+      pendingToolArgs.delete(event.toolCallId);
+    }
+  });
+
+  try {
+    await session.prompt(prompt, { expandPromptTemplates: false });
+
+    // Extract the last assistant message
+    const messages = session.state.messages;
+    const lastAssistant = [...messages]
+      .reverse()
+      .find((m) => m.role === "assistant");
+
+    const lastMsg = lastAssistant as { content?: unknown } | undefined;
+    const output = extractTextContent(lastMsg?.content);
+    const status = parseAgentStatus(output);
+
+    return {
+      status,
+      output,
+      concerns: status === "done_with_concerns"
+        ? extractConcerns(output)
+        : undefined,
+      filesChanged: [...filesChanged],
+    };
+  } finally {
+    unsubscribe();
+    await session.dispose();
+  }
+}
+
+function extractTextContent(content: unknown): string {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((block: { type?: string }) => block.type === "text")
+      .map((block: { text?: string }) => block.text ?? "")
+      .join("\n");
+  }
+  return String(content);
+}
+
+function parseAgentStatus(output: string): AgentStatus {
+  // Look for structured "**Status:** X" or "Status: X" patterns to avoid false positives
+  const statusMatch = output.match(/\*?\*?status\*?\*?:\s*(BLOCKED|NEEDS_CONTEXT|DONE_WITH_CONCERNS|DONE)/i);
+  if (statusMatch) {
+    const val = statusMatch[1].toUpperCase();
+    if (val === "BLOCKED" || val === "NEEDS_CONTEXT") return "blocked";
+    if (val === "DONE_WITH_CONCERNS") return "done_with_concerns";
+    return "done";
+  }
+  // Default: if agent completed without explicit status, treat as done
+  return "done";
+}
+
+function extractConcerns(output: string): string {
+  const match = output.match(/(?:concerns?|issues?|worries):\s*(.+?)(?:\n\n|$)/is);
+  return match?.[1]?.trim() ?? "";
 }
 
 /** Review result from a spec compliance or code quality reviewer */
@@ -131,6 +275,7 @@ export async function dispatchAgentWithReview(
   }
 
   // Step 2: Spec compliance review
+  options.widget?.setStatus(task.id, "reviewing");
   for (let attempt = 0; attempt <= maxReviewRetries; attempt++) {
     const specReview = await dispatchSpecReview(
       pi,
@@ -174,6 +319,7 @@ export async function dispatchAgentWithReview(
   }
 
   // Step 3: Code quality review
+  options.widget?.setStatus(task.id, "reviewing");
   for (let attempt = 0; attempt <= maxReviewRetries; attempt++) {
     const qualityReview = await dispatchQualityReview(
       pi,
@@ -276,7 +422,7 @@ async function dispatchQualityReview(
 export async function dispatchFixAgent(
   options: DispatchOptions & { previousOutput: string; failureReason: string },
 ): Promise<AgentResult> {
-  const { pi, ctx, task, config, lspAvailable, contextModeAvailable, previousOutput, failureReason } =
+  const { pi, ctx, task, config, lspAvailable, contextModeAvailable, previousOutput, failureReason, widget } =
     options;
   const startTime = Date.now();
 
@@ -288,8 +434,10 @@ export async function dispatchFixAgent(
     contextModeAvailable,
   );
 
+  widget?.setStatus(task.id, "running");
+
   try {
-    const result = await executeSubAgent(pi, prompt, task, config);
+    const result = await executeSubAgent(pi, prompt, task, config, ctx, widget);
     return {
       taskId: task.id,
       status: result.status,