pi-workflow-engine 0.3.0 → 0.4.0

package/package.json

@@ -1,23 +1,49 @@
 {
   "name": "pi-workflow-engine",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "A customisable multi-agent workflow-orchestration engine for the pi coding agent.",
-  "keywords": ["pi-package"],
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi-workflow",
+    "workflow-engine",
+    "multi-agent",
+    "coding-agent"
+  ],
   "license": "MIT",
+  "homepage": "https://github.com/timbrinded/pi-workflow-engine#readme",
+  "bugs": {
+    "url": "https://github.com/timbrinded/pi-workflow-engine/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/timbrinded/pi-workflow-engine.git"
   },
-  "files": ["src", "workflows"],
+  "files": [
+    ".pi/extensions/pi-workflow-engine",
+    ".pi/settings.json",
+    "assets",
+    "README.md",
+    "LICENSE"
+  ],
   "pi": {
-    "extensions": ["./src/index.ts"],
+    "extensions": [".pi/extensions/pi-workflow-engine/index.ts"],
     "image": "https://raw.githubusercontent.com/timbrinded/pi-workflow-engine/master/assets/preview.png"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "test:ui": "bun scripts/test-workflow-ui.ts",
-    "prepublishOnly": "tsc --noEmit"
+    "test": "bun test",
+    "test:changedlines": "bun test tests/changedlines.test.ts",
+    "test:concurrency": "bun test tests/concurrency.test.ts",
+    "test:smoke": "bun test tests/discovery.test.ts",
+    "test:ui": "bun test tests/workflow-ui.test.ts",
+    "bench": "bun run bench:concurrency && bun run bench:discovery && bun run bench:ui",
+    "bench:concurrency": "bun run scripts/bench/concurrency.ts",
+    "bench:discovery": "bun run scripts/bench/discovery.ts",
+    "bench:startup": "bun run scripts/bench/startup.ts",
+    "bench:ui": "bun run scripts/bench/ui.ts",
+    "prepublishOnly": "tsc --noEmit && bun run test"
   },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",

package/src/agent-runner.ts

@@ -1,122 +0,0 @@
-import { createAgentSession, defineTool, SessionManager } from "@earendil-works/pi-coding-agent";
-import type { ModelRegistry, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { Model } from "@earendil-works/pi-ai";
-import type { AgentState } from "@earendil-works/pi-agent-core";
-import type { AgentOptions } from "./types.ts";
-import type { Semaphore } from "./concurrency.ts";
-import type { ProgressTracker } from "./progress.ts";
-
-/** Name of the synthetic terminating tool that carries structured output. */
-const FINAL_TOOL = "final_answer";
-
-/** Shared per-run context threaded into every agent() call. */
-export interface RunContext {
-  cwd: string;
-  hostModel: Model<any> | undefined;
-  modelRegistry: ModelRegistry;
-  semaphore: Semaphore;
-  progress: ProgressTracker;
-  signal: AbortSignal | undefined;
-}
-
-/** Pull the last assistant message's plain text out of a finished session. */
-function lastAssistantText(state: AgentState): string {
-  const messages = state.messages;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i];
-    if ("role" in message && message.role === "assistant") {
-      const content = (message as { content?: Array<{ type: string; text?: string }> }).content ?? [];
-      return content
-        .filter((part) => part.type === "text")
-        .map((part) => part.text ?? "")
-        .join("")
-        .trim();
-    }
-  }
-  return "";
-}
-
-/**
- * Run one subagent to completion in an isolated in-memory session.
- *
- * Structured output trick: when `opts.schema` is set we register a single
- * terminating tool whose `parameters` IS the schema. The agent's last action is to
- * call it; pi validates the args against the schema, hands them to `execute`, and
- * `terminate: true` ends the turn with no extra LLM round-trip. We capture those
- * validated args in a closure — that captured object is the structured result, so
- * no event-stream parsing is needed.
- */
-export async function runAgent(rc: RunContext, prompt: string, opts: AgentOptions = {}): Promise<unknown> {
-  const label = opts.label ?? "agent";
-
-  // Track queued agents before acquiring a global concurrency slot.
-  const rowId = rc.progress.agentQueued(opts.phase, label);
-  return rc.semaphore.run(async () => {
-    rc.progress.agentStart(opts.phase, label, rowId);
-
-    let captured: unknown = null;
-    let failed = false;
-    const customTools: ToolDefinition[] = opts.schema
-      ? [
-          defineTool({
-            name: FINAL_TOOL,
-            label: "Final Answer",
-            description:
-              "Return your final structured answer. This MUST be your last action — do not write a normal reply after calling it.",
-            parameters: opts.schema,
-            async execute(_toolCallId, params) {
-              captured = params;
-              return { content: [{ type: "text", text: "Recorded." }], details: params, terminate: true };
-            },
-          }),
-        ]
-      : [];
-
-    // When the workflow restricts built-in tools, keep the terminating tool visible.
-    const allow = opts.tools
-      ? opts.schema
-        ? [...opts.tools, FINAL_TOOL]
-        : opts.tools
-      : undefined;
-
-    // Resolve the model by runtime id lookup (no compile-time model-id union); fall back to the host's model.
-    const model = opts.model ? rc.modelRegistry.find("anthropic", opts.model) ?? rc.hostModel : rc.hostModel;
-
-    const { session } = await createAgentSession({
-      cwd: rc.cwd,
-      model,
-      modelRegistry: rc.modelRegistry,
-      thinkingLevel: opts.thinkingLevel,
-      tools: allow,
-      customTools,
-      sessionManager: SessionManager.inMemory(rc.cwd),
-    });
-
-    const unsubscribe = session.subscribe((event) => {
-      if (event.type === "tool_execution_start" && event.toolName !== FINAL_TOOL) {
-        rc.progress.agentTool(label, event.toolName, rowId);
-      }
-    });
-
-    try {
-      const finalPrompt = opts.schema
-        ? `${prompt}\n\nWhen finished, return your result by calling the ${FINAL_TOOL} tool.`
-        : prompt;
-      await session.prompt(finalPrompt);
-      if (opts.schema) {
-        if (captured === null) rc.progress.log(`${label}: no structured answer returned`);
-        return captured;
-      }
-      return lastAssistantText(session.state);
-    } catch (error) {
-      failed = true;
-      rc.progress.agentFailed(label, error, rowId);
-      rc.progress.log(`${label} failed: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    } finally {
-      unsubscribe();
-      session.dispose();
-      if (!failed) rc.progress.agentDone(label, rowId);
-    }
-  });
-}

package/src/concurrency.ts

@@ -1,55 +0,0 @@
-/**
- * A counting semaphore: bounds how many async tasks run at once.
- *
- * This is the single global concurrency cap for a workflow run. Every `agent()`
- * call acquires a slot before spawning a session and releases it when done, so the
- * cap holds no matter how `parallel`/`pipeline` are nested — exactly like the
- * built-in Workflow tool, where "concurrent agent() calls are capped and excess queue".
- */
-export class Semaphore {
-  private active = 0;
-  private readonly waiters: Array<() => void> = [];
-
-  constructor(private readonly max: number) {}
-
-  async run<T>(fn: () => Promise<T>): Promise<T> {
-    if (this.active >= this.max) {
-      await new Promise<void>((resolve) => this.waiters.push(resolve));
-    }
-    this.active++;
-    try {
-      return await fn();
-    } finally {
-      this.active--;
-      this.waiters.shift()?.();
-    }
-  }
-}
-
-/** Run every thunk concurrently and wait for all results (a barrier). */
-export async function parallel<T>(thunks: Array<() => Promise<T>>): Promise<T[]> {
-  return Promise.all(thunks.map((thunk) => thunk()));
-}
-
-/**
- * Run each item through all stages independently. There is NO barrier between
- * stages: item A can be in stage 3 while item B is still in stage 1. Actual agent
- * concurrency is bounded by the run's Semaphore (inside each `agent()`), not here —
- * so launching every item at once is safe.
- *
- * Each stage receives (previousResult, originalItem, index).
- */
-export async function pipeline(
-  items: unknown[],
-  ...stages: Array<(prev: unknown, item: unknown, index: number) => Promise<unknown>>
-): Promise<unknown[]> {
-  return Promise.all(
-    items.map(async (item, index) => {
-      let acc: unknown = item;
-      for (const stage of stages) {
-        acc = await stage(acc, item, index);
-      }
-      return acc;
-    }),
-  );
-}

package/src/discovery.ts

@@ -1,54 +0,0 @@
-import { readdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import type { WorkflowModule } from "./types.ts";
-import { BUILTIN_WORKFLOWS } from "./workflows.ts";
-
-function isWorkflowModule(value: unknown): value is WorkflowModule {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value as { meta?: { name?: unknown }; default?: unknown };
-  return typeof candidate.meta?.name === "string" && typeof candidate.default === "function";
-}
-
-/** Best-effort dynamic load of every `*.ts` workflow in a directory. */
-async function loadDir(dir: string): Promise<WorkflowModule[]> {
-  let entries: string[];
-  try {
-    entries = await readdir(dir);
-  } catch {
-    return [];
-  }
-
-  const modules: WorkflowModule[] = [];
-  for (const name of entries) {
-    if (!name.endsWith(".ts") || name.startsWith("_") || name.startsWith(".")) continue;
-    try {
-      const loaded: unknown = await import(pathToFileURL(join(dir, name)).href);
-      if (isWorkflowModule(loaded)) modules.push(loaded);
-    } catch (error) {
-      // Drop-in loading depends on the runtime resolving TS + the bundled typebox.
-      // Failures here are non-fatal: the static registry still works.
-      console.error(`[workflow-engine] skipped ${name}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  return modules;
-}
-
-/**
- * All available workflows by name. Static registry wins on name collisions, so the
- * bundled example is always the verified one even if a same-named file is dropped in.
- */
-export async function discoverWorkflows(repoDir: string): Promise<Map<string, WorkflowModule>> {
-  const byName = new Map<string, WorkflowModule>();
-  for (const mod of BUILTIN_WORKFLOWS) byName.set(mod.meta.name, mod);
-
-  const dynamic = [
-    ...(await loadDir(join(repoDir, "workflows"))),
-    ...(await loadDir(join(homedir(), ".pi", "agent", "workflows"))),
-  ];
-  for (const mod of dynamic) {
-    if (!byName.has(mod.meta.name)) byName.set(mod.meta.name, mod);
-  }
-  return byName;
-}

package/src/index.ts

@@ -1,141 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { Type } from "typebox";
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { discoverWorkflows } from "./discovery.ts";
-import { runWorkflow } from "./engine.ts";
-import type { WorkflowModule, WorkflowRunOptions } from "./types.ts";
-import { isWorkflowResult, renderWorkflowResult, type WorkflowResultEnvelope } from "./ui/workflow-result-renderer.ts";
-
-/** Repo root (this file lives in <repo>/src/index.ts). */
-const REPO_DIR = fileURLToPath(new URL("..", import.meta.url));
-
-function summarize(result: unknown): string {
-  if (result && typeof result === "object" && typeof (result as { summary?: unknown }).summary === "string") {
-    return (result as { summary: string }).summary;
-  }
-  return typeof result === "string" ? result : "Workflow finished.";
-}
-
-function formatReport(name: string, result: unknown): string {
-  return [`## Workflow: ${name}`, "", "```json", JSON.stringify(result, null, 2), "```"].join("\n");
-}
-
-function workflowEnvelope(name: string, result: unknown): WorkflowResultEnvelope {
-  return { name, result, completedAt: Date.now() };
-}
-
-interface WorkflowInvocation {
-  name: string;
-  args: string;
-  options: WorkflowRunOptions;
-}
-
-function parseWorkflowInvocation(input: string): WorkflowInvocation {
-  const trimmed = input.trim();
-  const space = trimmed.indexOf(" ");
-  const name = space === -1 ? trimmed : trimmed.slice(0, space);
-  const rest = space === -1 ? "" : trimmed.slice(space + 1).trim();
-  const inspect = /(?:^|\s)--inspect(?:\s|$)/.test(rest);
-  const cleanedArgs = rest.replace(/(?:^|\s)--inspect(?=\s|$)/g, " ").trim();
-  return { name, args: cleanedArgs, options: inspect ? { inspect: true } : {} };
-}
-
-async function pickWorkflow(
-  workflows: ReadonlyMap<string, WorkflowModule>,
-  ctx: ExtensionCommandContext,
-): Promise<WorkflowInvocation | undefined> {
-  const choices = [...workflows.values()].map((mod) => `${mod.meta.name} — ${mod.meta.description}`);
-  const choice = await ctx.ui.select("Run workflow", choices);
-  if (!choice) return undefined;
-
-  const separator = choice.indexOf(" — ");
-  const name = separator === -1 ? choice : choice.slice(0, separator);
-  const args = name === "code-review" ? (await ctx.ui.input("Code-review target/instructions", "Blank = auto-detect diff"))?.trim() ?? "" : "";
-  const inspect = await ctx.ui.confirm("Open inspector?", "Open a live workflow inspector while this workflow runs?");
-  return { name, args, options: { inspect } };
-}
-
-async function sendWorkflowResult(
-  pi: ExtensionAPI,
-  ctx: ExtensionCommandContext,
-  name: string,
-  mod: WorkflowModule,
-  args: string,
-  options: WorkflowRunOptions,
-): Promise<void> {
-  const result = await runWorkflow(ctx, mod, args, options);
-  pi.sendMessage(
-    { customType: "workflow-result", content: formatReport(name, result), display: true, details: workflowEnvelope(name, result) },
-    { triggerTurn: false },
-  );
-}
-
-export default function workflowEngine(pi: ExtensionAPI): void {
-  pi.registerMessageRenderer("workflow-result", (message, { expanded }, theme) => {
-    const details = message.details;
-    if (isWorkflowResult(details)) return renderWorkflowResult(details.name, details.result, expanded, theme);
-    return renderWorkflowResult("workflow", details ?? message.content, expanded, theme);
-  });
-
-  // /workflow <name> [args] — user-invoked.
-  pi.registerCommand("workflow", {
-    description: "Run a multi-agent workflow: /workflow <name> [args]",
-    handler: async (args: string, ctx: ExtensionCommandContext) => {
-      const workflows = await discoverWorkflows(REPO_DIR);
-      const available = [...workflows.keys()].join(", ") || "(none)";
-      const direct = parseWorkflowInvocation(args);
-      const invocation = direct.name ? direct : ctx.hasUI ? await pickWorkflow(workflows, ctx) : undefined;
-
-      if (!invocation) {
-        ctx.ui.notify(`Usage: /workflow <name> [args]. Available: ${available}`, "warning");
-        return;
-      }
-
-      const mod = workflows.get(invocation.name);
-      if (!mod) {
-        ctx.ui.notify(`Unknown workflow "${invocation.name}". Available: ${available}`, "error");
-        return;
-      }
-
-      await sendWorkflowResult(pi, ctx, invocation.name, mod, invocation.args, invocation.options);
-    },
-  });
-
-  // workflow tool — lets the host agent fan out mid-conversation.
-  pi.registerTool({
-    name: "workflow",
-    label: "Workflow",
-    description:
-      "Run a named multi-agent workflow (fan-out → verify → synthesize) and return its structured result. Use for thorough reviews or audits.",
-    parameters: Type.Object({
-      name: Type.String({ description: "Workflow name, e.g. code-review" }),
-      args: Type.Optional(Type.String({ description: "Arguments for the workflow (e.g. target or focus)" })),
-    }),
-    renderCall(args, theme) {
-      const suffix = args.args ? ` ${theme.fg("dim", args.args)}` : "";
-      return new Text(`▸ ${theme.fg("toolTitle", theme.bold("workflow"))} ${theme.fg("accent", args.name)}${suffix}`, 0, 0);
-    },
-    renderResult(result, { expanded, isPartial }, theme) {
-      if (isPartial) return new Text(theme.fg("accent", "Running workflow…"), 0, 0);
-      const details = result.details;
-      if (isWorkflowResult(details)) return renderWorkflowResult(details.name, details.result, expanded, theme);
-      const first = result.content[0];
-      const text = first?.type === "text" ? first.text : "Workflow finished.";
-      return new Text(theme.fg("muted", text), 0, 0);
-    },
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const workflows = await discoverWorkflows(REPO_DIR);
-      const mod = workflows.get(params.name);
-      if (!mod) {
-        const available = [...workflows.keys()].join(", ") || "(none)";
-        return {
-          content: [{ type: "text", text: `Unknown workflow "${params.name}". Available: ${available}` }],
-          details: { error: "unknown_workflow", available },
-        };
-      }
-      const result = await runWorkflow(ctx, mod, params.args ?? "");
-      return { content: [{ type: "text", text: summarize(result) }], details: workflowEnvelope(params.name, result) };
-    },
-  });
-}

package/src/ui/workflow-widget.ts

@@ -1,143 +0,0 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { AgentRowSnapshot, PhaseSnapshot, WorkflowProgressSnapshot } from "../progress.ts";
-import { formatCount, formatDuration, statusIcon, truncateDisplay } from "./workflow-format.ts";
-
-const MAX_WIDGET_LINES = 12;
-const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-
-export interface WorkflowWidget {
-  nextFrame(): void;
-  render(width: number, theme: Theme): string[];
-  invalidate(): void;
-}
-
-export function createWorkflowWidget(snapshotProvider: () => WorkflowProgressSnapshot): WorkflowWidget {
-  return new LiveWorkflowWidget(snapshotProvider);
-}
-
-export function renderWorkflowWidgetLines(
-  snapshot: WorkflowProgressSnapshot,
-  frame: number,
-  width: number,
-  theme: Theme,
-): string[] {
-  const safeWidth = Math.max(1, width);
-  const agents = snapshot.phases.flatMap((phase) => phase.agents);
-  const running = agents.filter((agent) => agent.status === "running").length;
-  const queued = agents.filter((agent) => agent.status === "queued").length;
-  const done = agents.filter((agent) => agent.status === "done").length;
-  const failed = agents.filter((agent) => agent.status === "failed").length;
-  const active = running + queued;
-  const elapsed = formatDuration((snapshot.doneAt ?? Date.now()) - snapshot.startedAt);
-  const spinner = active > 0 ? theme.fg("accent", SPINNER[frame % SPINNER.length]) : theme.fg("success", "✓");
-
-  const headingParts = [`${done}/${agents.length} done`, elapsed];
-  if (running > 0) headingParts.unshift(`${running} running`);
-  if (queued > 0) headingParts.unshift(`${queued} queued`);
-  if (failed > 0) headingParts.unshift(theme.fg("error", `${failed} failed`));
-
-  const lines: string[] = [
-    truncateDisplay(
-      `${spinner} ${theme.bold(snapshot.title)} ${theme.fg("dim", "·")} ${theme.fg("muted", snapshot.currentPhase)} ${theme.fg("dim", "·")} ${headingParts.join(` ${theme.fg("dim", "·")} `)}`,
-      safeWidth,
-    ),
-  ];
-
-  const footer = footerLine(snapshot, theme);
-  const bodyBudget = Math.max(0, MAX_WIDGET_LINES - lines.length - (footer ? 1 : 0));
-  const bodyLines = prioritizedBodyLines(snapshot.phases, theme);
-  const visibleBody = bodyLines.slice(0, bodyBudget);
-  const hidden = bodyLines.length - visibleBody.length;
-
-  for (const line of visibleBody) lines.push(truncateDisplay(line, safeWidth));
-  if (hidden > 0 && lines.length < MAX_WIDGET_LINES) {
-    lines.push(truncateDisplay(`${theme.fg("dim", "└─")} ${theme.fg("dim", `+${hidden} more`)}`, safeWidth));
-  }
-  if (footer && lines.length < MAX_WIDGET_LINES) lines.push(truncateDisplay(footer, safeWidth));
-
-  return lines.slice(0, MAX_WIDGET_LINES).map((line) => truncateDisplay(line, safeWidth));
-}
-
-class LiveWorkflowWidget implements WorkflowWidget {
-  private frame = 0;
-  private cachedWidth: number | undefined;
-  private cachedFrame: number | undefined;
-  private cachedDoneAt: number | undefined;
-  private cachedLines: string[] | undefined;
-
-  constructor(private readonly snapshotProvider: () => WorkflowProgressSnapshot) {}
-
-  nextFrame(): void {
-    this.frame = (this.frame + 1) % SPINNER.length;
-    this.invalidate();
-  }
-
-  render(width: number, theme: Theme): string[] {
-    const snapshot = this.snapshotProvider();
-    if (
-      this.cachedLines &&
-      this.cachedWidth === width &&
-      this.cachedFrame === this.frame &&
-      this.cachedDoneAt === snapshot.doneAt
-    ) {
-      return this.cachedLines;
-    }
-
-    this.cachedLines = renderWorkflowWidgetLines(snapshot, this.frame, width, theme);
-    this.cachedWidth = width;
-    this.cachedFrame = this.frame;
-    this.cachedDoneAt = snapshot.doneAt;
-    return this.cachedLines;
-  }
-
-  invalidate(): void {
-    this.cachedWidth = undefined;
-    this.cachedFrame = undefined;
-    this.cachedDoneAt = undefined;
-    this.cachedLines = undefined;
-  }
-}
-
-function prioritizedBodyLines(phases: readonly PhaseSnapshot[], theme: Theme): string[] {
-  const activePhases = phases.filter((phase) => phase.agents.some((agent) => agent.status === "running" || agent.status === "queued"));
-  const inactivePhases = phases.filter((phase) => !activePhases.includes(phase));
-  return [...activePhases, ...inactivePhases].flatMap((phase) => phaseLines(phase, theme));
-}
-
-function phaseLines(phase: PhaseSnapshot, theme: Theme): string[] {
-  if (phase.agents.length === 0 && phase.title === "Workflow") return [];
-  const running = phase.agents.filter((agent) => agent.status === "running").length;
-  const done = phase.agents.filter((agent) => agent.status === "done").length;
-  const failed = phase.agents.filter((agent) => agent.status === "failed").length;
-  const parts: string[] = [];
-  if (running > 0) parts.push(`${running} running`);
-  if (done > 0) parts.push(`${done} done`);
-  if (failed > 0) parts.push(`${failed} failed`);
-
-  const lines = [`${theme.fg("dim", "├─")} ${theme.fg(running > 0 ? "accent" : "muted", phase.title)}${parts.length ? ` ${theme.fg("dim", `(${parts.join(" · ")})`)}` : ""}`];
-  const active = phase.agents.filter((agent) => agent.status === "running" || agent.status === "queued");
-  const failedAgents = phase.agents.filter((agent) => agent.status === "failed");
-  const completed = phase.agents.filter((agent) => agent.status === "done");
-  for (const agent of [...active, ...failedAgents, ...completed]) lines.push(agentLine(agent, theme));
-  return lines;
-}
-
-function agentLine(agent: AgentRowSnapshot, theme: Theme): string {
-  const detailParts: string[] = [];
-  if (agent.toolUses > 0) detailParts.push(`${agent.toolUses} tool${agent.toolUses === 1 ? "" : "s"}`);
-  if (agent.status === "running" && agent.lastTool) detailParts.push(agent.lastTool);
-  if (agent.startedAt !== undefined) detailParts.push(formatDuration((agent.doneAt ?? Date.now()) - agent.startedAt));
-  if (agent.status === "failed" && agent.error) detailParts.push(agent.error);
-
-  const activity = detailParts.length > 0 ? ` ${theme.fg("dim", `· ${detailParts.join(" · ")}`)}` : "";
-  return `${theme.fg("dim", "│  ")} ${statusIcon(agent.status, theme)} ${theme.fg(agent.status === "running" ? "text" : "muted", agent.label)}${activity}`;
-}
-
-function footerLine(snapshot: WorkflowProgressSnapshot, theme: Theme): string | undefined {
-  const counters = snapshot.counters.slice(0, 4).map((counter) => `${counter.label} ${formatCount(counter.value)}`);
-  const latestLog = snapshot.logs[snapshot.logs.length - 1];
-  const parts = counters.length > 0 ? counters : [];
-  if (latestLog) parts.push(latestLog);
-  if (parts.length === 0) return undefined;
-  return `${theme.fg("dim", "└─")} ${theme.fg("dim", parts.join(" · "))}`;
-}