pi-subagents-lite 1.0.2 → 1.1.0

package/src/types.ts

@@ -50,39 +50,16 @@ export interface AgentConfig {
 
 export interface AgentRecord {
   id: string;
-  type: SubagentType;
-  description: string;
-  status: "queued" | "running" | "completed" | "steered" | "aborted" | "stopped" | "error";
   result?: string;
   error?: string;
-  toolUses: number;
-  startedAt: number;
-  completedAt?: number;
-  session?: AgentSession;
-  abortController?: AbortController;
-  promise?: Promise<string>;
-  /** Steering messages queued before the session was ready. */
-  pendingSteers?: string[];
-  /** The tool_use_id from the original Agent tool call. */
-  toolCallId?: string;
-  /** Path to the streaming output transcript file. */
-  outputFile?: string;
-  /** Cleanup function for the output file stream subscription. */
-  outputCleanup?: () => void;
-  /**
-   * Lifetime usage breakdown, accumulated via `message_end` events. Survives
-   * compaction. Total = input + output + cacheWrite + cost (cacheRead deliberately
-   * excluded — see issue #38). Initialized to zeros at spawn.
-   */
-  lifetimeUsage: LifetimeUsage;
-  /** Final turn count (set on completion). Used by widget after activity cleanup. */
-  turnCount?: number;
-  /** Max turns limit (from invocation or default). */
-  maxTurns?: number;
-  /** Number of times this agent's session has compacted. Initialized to 0 at spawn. */
-  compactionCount: number;
-  /** Resolved spawn params, captured for UI display. Fixed at spawn time. */
-  invocation?: AgentInvocation;
+  /** Lifecycle state: status, timestamps. */
+  lifecycle: AgentLifecycle;
+  /** Display-oriented info: type, description, output file, invocation. */
+  display: AgentDisplayInfo;
+  /** Execution internals: session, abort controller, pending steers. */
+  execution: AgentExecutionState;
+  /** Accumulated statistics: usage, tool uses, turns. */
+  stats: AgentAccumulatedStats;
 }
 
 export interface AgentInvocation {
@@ -102,6 +79,30 @@ export interface EnvInfo {
 /** How many characters of agent ID to show in display. */
 export const SHORT_ID_LENGTH = 8;
 
+/**
+ * Theme for terminal rendering — used by format.ts, renderer.ts, and UI widgets.
+ * Defined here (not in ui/agent-widget.ts) so non-UI modules can import it
+ * without depending on the UI layer.
+ */
+export type Theme = {
+  fg(color: string, text: string): string;
+  bg(color: string, text: string): string;
+  bold(text: string): string;
+  italic?: (text: string) => string;
+};
+
+/** Non-model keys in config.agent — preserved when clearing all overrides. */
+export const CONFIG_AGENT_NON_MODEL_KEYS = [
+  "default",
+  "forceBackground",
+  "graceTurns",
+  "showCost",
+  "widgetMaxLines",
+  "widgetMaxLinesCompact",
+  "widgetCompact",
+  "widgetShortcut",
+];
+
 /** Reason for a context compaction event. */
 export type CompactionReason = "manual" | "threshold" | "overflow";
 
@@ -111,4 +112,72 @@ export interface CompactionInfo {
   tokensBefore: number;
 }
 
+// ---------------------------------------------------------------------------
+// Sub-object interfaces for decomposed AgentRecord
+// ---------------------------------------------------------------------------
+
+/** Possible agent lifecycle statuses. */
+export type AgentStatus = "queued" | "running" | "completed" | "steered" | "aborted" | "stopped" | "error";
+
+/**
+ * Lifecycle state: when the agent started, completed, and its current status.
+ * Used by agent-manager (lifecycle control), menus (status display), widget (linger logic).
+ */
+export interface AgentLifecycle {
+  status: AgentStatus;
+  startedAt: number;
+  completedAt?: number;
+}
+
+/**
+ * Display-oriented fields: type name, description, output file, invocation params.
+ * Used by widget (rendering), menus (listing), renderer (display).
+ */
+export interface AgentDisplayInfo {
+  type: SubagentType;
+  description: string;
+  /** Path to the streaming output transcript file. */
+  outputFile?: string;
+  /** Resolved spawn params, captured for UI display. Fixed at spawn time. */
+  invocation?: AgentInvocation;
+  /** The tool_use_id from the original Agent tool call. */
+  toolCallId?: string;
+}
+
+/**
+ * Execution internals: session handle, abort controller, pending steers.
+ * Used by agent-manager (session lifecycle), tool-execution (steering, nudge).
+ */
+export interface AgentExecutionState {
+  session?: AgentSession;
+  abortController?: AbortController;
+  promise?: Promise<string>;
+  /** Steering messages queued before the session was ready. */
+  pendingSteers?: string[];
+  /** Cleanup function for the output file stream subscription. */
+  outputCleanup?: () => void;
+}
+
+/**
+ * Accumulated statistics: usage breakdown, tool uses, turn count.
+ * Used by widget (stats display), tool-execution (details building), menus (result viewer).
+ */
+export interface AgentAccumulatedStats {
+  /**
+   * Lifetime usage breakdown, accumulated via `message_end` events. Survives
+   * compaction. Total = input + output + cacheWrite + cost (cacheRead deliberately
+   * excluded — see issue #38). Initialized to zeros at spawn.
+   */
+  lifetimeUsage: LifetimeUsage;
+  toolUses: number;
+  /** Final turn count (set on completion). Used by widget after activity cleanup. */
+  turnCount?: number;
+  /** Max turns limit (from invocation or default). */
+  maxTurns?: number;
+  /** Number of times this agent's session has compacted. Initialized to 0 at spawn. */
+  compactionCount: number;
+  /** Last-known context usage percentage (0–100), captured at completion. */
+  contextPercent?: number | null;
+}
+
 

package/src/ui/agent-widget.ts

@@ -4,20 +4,23 @@
 
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import type { AgentManager } from "../agent-manager.js";
-import { getConfig } from "../agent-types.js";
-import type { AgentRecord, SubagentType } from "../types.js";
+import type { AgentRecord, Theme } from "../types.js";
 import {
-  formatTokens,
+  formatCost,
   getLifetimeTotal,
   getSessionContextPercent,
   type LifetimeUsage,
   type SessionLike,
 } from "../usage.js";
+import { formatMs, buildStatsParts, getDisplayName } from "../format.js";
+
+// Re-export Theme so existing consumers (model-selector, result-viewer) don't break
+export type { Theme } from "../types.js";
 
 // ---- Constants ----
 
 /** Maximum number of rendered lines before overflow collapse kicks in. */
-const MAX_WIDGET_LINES = 12;
+const DEFAULT_MAX_WIDGET_LINES = 12;
 
 /** Braille spinner frames for animated running indicator. */
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -58,11 +61,6 @@ const TOOL_DISPLAY: Record<string, string> = {
 
 // ---- Types ----
 
-export type Theme = {
-  fg(color: string, text: string): string;
-  bold(text: string): string;
-  italic?: (text: string) => string;
-};
 
 export type UICtx = {
   setStatus(key: string, text: string | undefined): void;
@@ -99,95 +97,10 @@ export interface AgentActivity {
   lifetimeUsage: LifetimeUsage;
 }
 
+// ---- Re-exports from format.ts (backward compatibility) ----
+export { formatMs, buildStatsParts, getDisplayName } from "../format.js";
 
-
-// ---- Formatting helpers ----
-
-/**
- * Token count with optional context-fill % and compaction-count annotations.
- * Thresholds for percent: <70% dim, 70–85% warning, ≥85% error.
- * Compaction count rendered as `↻ N` in dim.
- *
- *   "12.3k"                     — no annotations
- *   "12.3k(45%)"                — percent only
- *   "12.3k(↻ 2)"                 — compactions only (e.g. right after compact)
- *   "12.3k(45%·↻ 2)"             — both
- */
-function formatSessionTokens(
-  tokens: number,
-  percent: number | null,
-  theme: Theme,
-  compactions = 0,
-): string {
-  const tokenStr = formatTokens(tokens);
-  const annot: string[] = [];
-  if (percent !== null) {
-    const color = percent >= 85 ? "error" : percent >= 70 ? "warning" : "dim";
-    annot.push(theme.fg(color, `${Math.round(percent)}%`));
-  }
-  if (compactions > 0) {
-    annot.push(theme.fg("dim", `↻ ${compactions}`));
-  }
-  if (annot.length === 0) return tokenStr;
-  // Include closing paren in the last annotation's color span to prevent
-  // ANSI reset from leaving `)` in default color when wrapped in outer dim.
-  const lastIdx = annot.length - 1;
-  annot[lastIdx] += ")";
-  return `${tokenStr}(${annot.join("·")}`;
-}
-
-/** Format turn count with optional max limit: "5≤30⟳" or "5⟳". */
-function formatTurns(turnCount: number, maxTurns?: number | null): string {
-  return maxTurns != null ? `${turnCount}≤${maxTurns}⟳ ` : `${turnCount}⟳ `;
-}
-
-/** Format milliseconds as a compact human-readable duration: "1h 1m 1s", "5m 37s", "10s", "<1s". */
-export function formatMs(ms: number): string {
-  if (!Number.isFinite(ms) || ms < 1000) return "<1s";
-
-  const totalSeconds = Math.floor(ms / 1000);
-  const hours = Math.floor(totalSeconds / 3600);
-  const minutes = Math.floor((totalSeconds % 3600) / 60);
-  const seconds = totalSeconds % 60;
-
-  const parts: string[] = [];
-  if (hours > 0) parts.push(`${hours}h`);
-  if (minutes > 0) parts.push(`${minutes}m`);
-  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
-
-  return parts.join(" ");
-}
-
-/**
- * Build common stats parts: toolUses · turns · tokens with context %.
- * Shared by AgentWidget and index.ts for consistent stats display.
- */
-export function buildStatsParts(
-  args: {
-    toolUses: number;
-    turnCount?: number;
-    maxTurns?: number;
-    tokens: number;
-    contextPercent: number | null;
-    compactions: number;
-  },
-  theme: Theme,
-): string[] {
-  const parts: string[] = [];
-  if (args.toolUses > 0) parts.push(`${args.toolUses}🛠 `);
-  if (args.turnCount != null) parts.push(formatTurns(args.turnCount, args.maxTurns));
-  if (args.tokens > 0) {
-    parts.push(formatSessionTokens(
-      args.tokens, args.contextPercent, theme, args.compactions,
-    ));
-  }
-  return parts;
-}
-
-/** Get display name for any agent type (built-in or custom). */
-export function getDisplayName(type: SubagentType): string {
-  return getConfig(type).displayName;
-}
+// ---- Widget-internal helpers ----
 
 /**
  * Wrap a stats line in dim ANSI codes, re-applying dim after any inner
@@ -245,6 +158,8 @@ export class AgentWidget {
   /** Finished agents: agent ID → turns since finished. */
   private finishedTurnAge = new Map<string, number>();
 
+  /** Whether to show cost in stats and status bar. */
+  private showCost = false;
 
   /** Whether the widget callback is currently registered with the TUI. */
   private widgetRegistered = false;
@@ -252,12 +167,67 @@ export class AgentWidget {
   private tui: TUI | undefined;
   /** Last status bar text, used to avoid redundant setStatus calls. */
   private lastStatusText: string | undefined;
+  /** Pending tool expansion state from onTerminalInput (push-based, no polling). */
+  private pendingToolsExpanded: boolean | undefined;
+
+  /** Whether to use compact mode (1-line per agent). */
+  private compactMode = false;
+
+  /** Whether "force compact" mode is ON — overrides ctrl+o shortcut. */
+  private forceCompact = false;
+
+  /** Whether ctrl+o shortcut is enabled (syncs compact with toolsExpanded). */
+  private widgetShortcut = false;
+
+  /** Maximum lines for full mode. */
+  private maxLines = DEFAULT_MAX_WIDGET_LINES;
+
+  /** Maximum lines for compact mode. */
+  private maxLinesCompact = Math.floor(DEFAULT_MAX_WIDGET_LINES / 2);
 
   constructor(
     private manager: AgentManager,
     private agentActivity: Map<string, AgentActivity>,
   ) {}
 
+  /** Set whether to show cost in stats and status bar. */
+  setShowCost(enabled: boolean) {
+    this.showCost = enabled;
+  }
+
+  /** Set compact mode (internal, for sync from ctrl+o). */
+  setCompactMode(enabled: boolean) {
+    if (this.compactMode === enabled) return;
+    this.compactMode = enabled;
+    this.update();
+  }
+
+  /** Set force compact mode — overrides ctrl+o shortcut. */
+  setForceCompact(enabled: boolean) {
+    this.forceCompact = enabled;
+  }
+
+  /** Set whether ctrl+o shortcut is enabled. */
+  setWidgetShortcut(enabled: boolean) {
+    this.widgetShortcut = enabled;
+  }
+
+  /** Notify widget that tool expansion state changed (push-based, no polling). */
+  notifyToolsExpansionChanged(expanded: boolean) {
+    this.pendingToolsExpanded = expanded;
+    this.update();
+  }
+
+  /** Set max lines for full mode. */
+  setMaxLines(lines: number) {
+    this.maxLines = lines;
+  }
+
+  /** Set max lines for compact mode. */
+  setMaxLinesCompact(lines: number) {
+    this.maxLinesCompact = lines;
+  }
+
   /** Set the UI context (grabbed from first tool execution). */
   setUICtx(ctx: UICtx) {
     if (ctx !== this.uiCtx) {
@@ -297,9 +267,9 @@ export class AgentWidget {
     const queued: AgentRecord[] = [];
     const finished: AgentRecord[] = [];
     for (const a of allAgents) {
-      if (a.status === "running") running.push(a);
-      else if (a.status === "queued") queued.push(a);
-      else if (a.completedAt && this.shouldShowFinished(a.id, a.status)) finished.push(a);
+      if (a.lifecycle.status === "running") running.push(a);
+      else if (a.lifecycle.status === "queued") queued.push(a);
+      else if (a.lifecycle.completedAt && this.shouldShowFinished(a.id, a.lifecycle.status)) finished.push(a);
     }
     return { running, queued, finished };
   }
@@ -342,47 +312,44 @@ export class AgentWidget {
   }
 
   /** Render a finished agent line. */
-  private renderFinishedLine(a: {
-    id: string; type: SubagentType; status: string; description: string;
-    toolUses: number; startedAt: number; completedAt?: number; error?: string;
-    compactionCount: number; lifetimeUsage: LifetimeUsage;
-    turnCount?: number; maxTurns?: number; session?: SessionLike;
-    outputFile?: string;
-  }, theme: Theme): string {
-    const name = getDisplayName(a.type);
-    const duration = formatMs((a.completedAt ?? Date.now()) - a.startedAt);
-    const { icon, statusText } = this.finishedIconAndStatus(a.status, a.error, theme);
+  private renderFinishedLine(a: AgentRecord, theme: Theme): string {
+    const name = getDisplayName(a.display.type);
+    const duration = formatMs((a.lifecycle.completedAt ?? Date.now()) - a.lifecycle.startedAt);
+    const { icon, statusText } = this.finishedIconAndStatus(a.lifecycle.status, a.error, theme);
 
     const activity = this.agentActivity.get(a.id);
+    const usage = activity?.lifetimeUsage ?? a.stats.lifetimeUsage;
     const statsParts = buildStatsParts({
-      toolUses: a.toolUses,
-      turnCount: activity?.turnCount ?? a.turnCount,
-      maxTurns: activity?.maxTurns ?? a.maxTurns,
-      tokens: getLifetimeTotal(activity?.lifetimeUsage ?? a.lifetimeUsage),
-      contextPercent: getSessionContextPercent(activity?.session ?? a.session),
-      compactions: a.compactionCount,
+      toolUses: a.stats.toolUses,
+      turnCount: activity?.turnCount ?? a.stats.turnCount,
+      maxTurns: activity?.maxTurns ?? a.stats.maxTurns,
+      tokens: getLifetimeTotal(usage),
+      contextPercent: activity?.session ? getSessionContextPercent(activity.session) : a.stats.contextPercent ?? null,
+      compactions: a.stats.compactionCount,
+      cost: this.showCost ? usage.cost : undefined,
     }, theme);
     statsParts.push(duration);
 
     const statsLine = statsParts.join("·");
-    return `${icon} ${theme.fg("dim", name)}  ${theme.fg("dim", a.description)}  ${wrapInDim(theme, statsLine)}${statusText}`;
+    return `${icon} ${theme.fg("dim", name)}  ${theme.fg("dim", a.display.description)}  ${wrapInDim(theme, statsLine)}${statusText}`;
   }
 
-  /** Build the stats line (toolUses · turns · tokens · elapsed) for a running agent. */
+  /** Build the stats line (toolUses · turns · tokens · cost · elapsed) for a running agent. */
   private buildStatsLine(
-    agent: { toolUses: number; compactionCount: number; startedAt: number },
+    agent: AgentRecord,
     activity: AgentActivity | undefined,
     theme: Theme,
   ): string {
     const parts = buildStatsParts({
-      toolUses: activity?.toolUses ?? agent.toolUses,
+      toolUses: activity?.toolUses ?? agent.stats.toolUses,
       turnCount: activity?.turnCount,
       maxTurns: activity?.maxTurns,
       tokens: getLifetimeTotal(activity?.lifetimeUsage),
       contextPercent: getSessionContextPercent(activity?.session),
-      compactions: agent.compactionCount,
+      compactions: agent.stats.compactionCount,
+      cost: this.showCost ? activity?.lifetimeUsage?.cost : undefined,
     }, theme);
-    parts.push(formatMs(Date.now() - agent.startedAt));
+    parts.push(formatMs(Date.now() - agent.lifecycle.startedAt));
     return parts.join("·");
   }
 
@@ -397,8 +364,8 @@ export class AgentWidget {
     for (const a of finished) {
       blocks.push({
         header: truncate(`${theme.fg("dim", BRANCH)} ${this.renderFinishedLine(a, theme)}`),
-        continuations: a.outputFile
-          ? [truncate(theme.fg("dim", `${VLINE}    tail -f ${a.outputFile}`))]
+        continuations: a.display.outputFile
+          ? [truncate(theme.fg("dim", `${VLINE}    tail -f ${a.display.outputFile}`))]
           : [],
       });
     }
@@ -415,21 +382,32 @@ export class AgentWidget {
     const truncate = (line: string) => truncateToWidth(line, w);
     const blocks: RenderBlock[] = [];
     for (const a of running) {
-      const name = getDisplayName(a.type);
+      const name = getDisplayName(a.display.type);
       const bg = this.agentActivity.get(a.id);
       const statsLine = this.buildStatsLine(a, bg, theme);
       const activity = bg ? describeActivity(bg.activeTools, bg.responseText) : THINKING_TEXT;
 
-      const headerLine = `${BRANCH} ${theme.fg("accent", frame)} ${theme.bold(name)}  ${a.description}  ${statsLine}`;
-      blocks.push({
-        header: truncate(headerLine),
-        continuations: [
-          ...(a.outputFile
-            ? [truncate(`${VLINE}  ` + theme.fg("dim", `${VLINE} tail -f ${a.outputFile}`))]
-            : []),
-          truncate(`${VLINE}  ` + theme.fg("dim", `└ ${activity}`)),
-        ],
-      });
+      if (this.isCompact()) {
+        // Compact: single line with activity inline, truncated description
+        const desc = a.display.description.length > 30 ? a.display.description.slice(0, 27) + "..." : a.display.description;
+        const headerLine = `${BRANCH} ${theme.fg("accent", frame)} ${theme.bold(name)}  ${desc}  ${statsLine}  ${theme.fg("dim", activity)}`;
+        blocks.push({
+          header: truncate(headerLine),
+          continuations: [],
+        });
+      } else {
+        // Full: header + continuation lines
+        const headerLine = `${BRANCH} ${theme.fg("accent", frame)} ${theme.bold(name)}  ${a.display.description}  ${statsLine}`;
+        blocks.push({
+          header: truncate(headerLine),
+          continuations: [
+            ...(a.display.outputFile
+              ? [truncate(`${VLINE}  ` + theme.fg("dim", `${VLINE} tail -f ${a.display.outputFile}`))]
+              : []),
+            truncate(`${VLINE}  ` + theme.fg("dim", `└ ${activity}`)),
+          ],
+        });
+      }
     }
     return blocks;
   }
@@ -455,6 +433,11 @@ export class AgentWidget {
    * connectors in a single pass. Last visible block gets CORNER + spaces, all others
    * keep BRANCH + VLINE.
    */
+  /** Whether the widget should render in compact mode. */
+  private isCompact(): boolean {
+    return this.forceCompact || (this.widgetShortcut && this.compactMode);
+  }
+
   private renderWidget(tui: TUI, theme: Theme): string[] {
     const { running, queued, finished } = this.categorizeAgents();
 
@@ -485,7 +468,8 @@ export class AgentWidget {
 
     // ---- Overflow logic (works with blocks, not lines) ----
 
-    const maxBody = MAX_WIDGET_LINES - 1; // heading takes 1 line
+    const maxBodyLines = this.isCompact() ? this.maxLinesCompact : this.maxLines;
+    const maxBody = maxBodyLines - 1; // heading takes 1 line
     const totalBody = blocks.reduce((sum, b) => sum + 1 + b.continuations.length, 0);
 
     const heading = `${theme.fg(headingColor, headingIcon)} ${theme.fg(headingColor, "Agents")}`;
@@ -601,21 +585,40 @@ export class AgentWidget {
   }
 
   /** Update the status bar text, only if it changed. */
-  private updateStatusBar(runningCount: number, queuedCount: number) {
-    const statusParts: string[] = [];
-    if (runningCount > 0) statusParts.push(`${runningCount} running`);
-    if (queuedCount > 0) statusParts.push(`${queuedCount} queued`);
+  private updateStatusBar(runningCount: number, queuedCount: number, running: AgentRecord[]) {
     const total = runningCount + queuedCount;
-    const newStatusText = `${statusParts.join(", ")} agent${total === 1 ? "" : "s"}`;
-    if (newStatusText !== this.lastStatusText) {
-      this.uiCtx?.setStatus(STATUS_KEY, newStatusText);
-      this.lastStatusText = newStatusText;
+    let statusText = total > 0 ? `${total} agent${total === 1 ? "" : "s"}` : `agents`;
+    if (this.showCost) {
+      const sessionCost = this.manager.getTotalAgentCost();
+      // Also include in-flight running agents (not yet completed, so not in accumulator)
+      const runningCost = running.reduce((sum, a) => sum + a.stats.lifetimeUsage.cost, 0);
+      const totalCost = sessionCost + runningCost;
+      if (totalCost > 0) statusText += `: ${formatCost(totalCost)}`;
+    }
+    if (statusText !== this.lastStatusText) {
+      this.uiCtx?.setStatus(STATUS_KEY, statusText);
+      this.lastStatusText = statusText;
     }
   }
 
   /** Force an immediate widget update. */
   update() {
+    if (!this.manager) {
+      // Widget lost its manager reference (e.g., after session shutdown)
+      clearInterval(this.widgetInterval);
+      this.widgetInterval = undefined;
+      return;
+    }
     if (!this.uiCtx) return;
+
+    // Sync compact mode with tool expansion state (ctrl+o)
+    // Tools expanded → widget full, tools collapsed → widget compact
+    // Note: sync is triggered by onTerminalInput detecting ctrl+o, not polling
+    if (this.widgetShortcut && !this.forceCompact && this.pendingToolsExpanded !== undefined) {
+      this.compactMode = !this.pendingToolsExpanded;
+      this.pendingToolsExpanded = undefined;
+    }
+
     const { running, queued, finished } = this.categorizeAgents();
 
     const hasActive = running.length > 0 || queued.length > 0;
@@ -628,7 +631,7 @@ export class AgentWidget {
     }
 
     // Status bar — only call setStatus when the text actually changes
-    this.updateStatusBar(running.length, queued.length);
+    this.updateStatusBar(running.length, queued.length, running);
 
     this.widgetFrame++;
 

package/src/usage.ts

@@ -36,6 +36,11 @@ export function formatTokens(count: number): string {
   return `${count}`;
 }
 
+/** Format cost as a dollar amount: "$0.00", "$0.01", "$1.23". */
+export function formatCost(cost: number): string {
+  return `$${cost.toFixed(2)}`;
+}
+
 /**
  * Context-window utilization (0–100), or null when unavailable
  * (no model contextWindow, or post-compaction before the next response).

package/src/stop-agent-tool.ts

@@ -1,77 +0,0 @@
-/**
- * stop-agent-tool.ts — StopAgent tool execute handler.
- *
- * Registered in index.ts alongside the Agent tool.
- * Uses manager.abort(id) to stop running or queued agents.
- *
- * Response formats:
- *   - Success: "Stopped agent <short_id>"
- *   - Not found: "Agent <id> not found. Running agents: <type>·<short_id>, ..."
- *   - Already terminal: "Agent <id> is already <status>. Running agents: ..."
- */
-
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { successResult, errorResult } from "./tool-execution.js";
-import { manager } from "./index.js";
-import { SHORT_ID_LENGTH } from "./types.js";
-
-// ============================================================================
-// Running agents list helper
-// ============================================================================
-
-/**
- * Build a compact list of running (or queued) agents.
- * Format: "type·short_id, type·short_id" — one line, easy for LLM to parse.
- */
-function formatRunningAgents(): string {
-  const agents = manager.listAgents().filter(
-    (a) => a.status === "running" || a.status === "queued",
-  );
-
-  if (agents.length === 0) return "none";
-
-  return agents
-    .map((a) => `${a.type}·${a.id.slice(0, SHORT_ID_LENGTH)}`)
-    .join(", ");
-}
-
-// ============================================================================
-// Execute handler
-// ============================================================================
-
-export async function executeStopAgentTool(
-  _toolCallId: string,
-  params: Record<string, unknown>,
-  _signal: AbortSignal | undefined,
-  _onUpdate: ((update: any) => void) | undefined,
-  _ctx: ExtensionContext,
-): Promise<any> {
-  const agentId = params.agent_id as string | undefined;
-
-  if (!agentId) {
-    return errorResult("agent_id is required");
-  }
-
-  const record = manager.getRecord(agentId);
-
-  if (!record) {
-    // Agent not found → return error + list of running agents
-    return errorResult(
-      `Agent ${agentId} not found. Running agents: ${formatRunningAgents()}`,
-    );
-  }
-
-  // Check if already in a terminal state (not running or queued)
-  if (record.status !== "running" && record.status !== "queued") {
-    return successResult(
-      `Agent ${agentId} is already ${record.status}. Running agents: ${formatRunningAgents()}`,
-    );
-  }
-
-  // Attempt to stop the running/queued agent
-  if (manager.abort(agentId)) {
-    return successResult(`Stopped agent ${agentId.slice(0, SHORT_ID_LENGTH)}`);
-  }
-
-  return errorResult(`Failed to stop agent ${agentId}`);
-}