@gotgenes/pi-subagents 6.16.0 → 6.16.2

package/src/ui/agent-menu.ts

@@ -1,7 +1,6 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { AgentSpawnConfig } from "../agent-manager.js";
 import { AgentTypeRegistry } from "../agent-types.js";
 import type { ModelRegistry } from "../model-resolver.js";
+import type { ParentSnapshot } from "../parent-snapshot.js";
 import type { AgentConfig, AgentRecord } from "../types.js";
 import type { AgentActivityTracker } from "./agent-activity-tracker.js";
 import { createAgentConfigEditor } from "./agent-config-editor.js";
@@ -16,7 +15,12 @@ export interface AgentMenuManager {
   listAgents: () => AgentRecord[];
   getRecord: (id: string) => AgentRecord | undefined;
   /** Used by generate wizard to spawn an agent that writes the .md file. */
-  spawnAndWait: (ctx: ExtensionContext, type: string, prompt: string, opts: Omit<AgentSpawnConfig, "isBackground">) => Promise<AgentRecord>;
+  spawnAndWait: (
+    parentSnapshot: ParentSnapshot,
+    type: string,
+    prompt: string,
+    opts: { description: string; maxTurns: number },
+  ) => Promise<AgentRecord>;
 }
 
 /** Narrow settings interface required by the agent menu. */
@@ -52,35 +56,58 @@ export interface AgentMenuDeps {
 
 // ---- Narrow UI context types ----
 
+/** Narrow UI interface — only the ctx.ui methods menu handlers actually call. */
+export interface MenuUI {
+  select(title: string, options: string[]): Promise<string | undefined>;
+  confirm(title: string, message: string): Promise<boolean>;
+  input(title: string, defaultValue?: string): Promise<string | undefined>;
+  notify(message: string, level: "info" | "warning" | "error"): void;
+  editor(title: string, content: string): Promise<string | undefined>;
+  custom<R>(component: any, options?: any): Promise<R>;
+}
+
 // ---- Factory ----
 
 /**
  * Create the `/agents` command handler.
  * Returns a function suitable for `pi.registerCommand("agents", { handler })`.
  */
-export function createAgentsMenuHandler(deps: AgentMenuDeps) {
-  const editor = createAgentConfigEditor({
-    fileOps: deps.fileOps,
-    registry: deps.registry,
-    personalAgentsDir: deps.personalAgentsDir,
-    projectAgentsDir: deps.projectAgentsDir,
-  });
+export function createAgentsMenuHandler({
+  manager,
+  registry,
+  agentActivity,
+  getModelLabel,
+  settings,
+  fileOps,
+  personalAgentsDir,
+  projectAgentsDir,
+}: AgentMenuDeps) {
+  const editor = createAgentConfigEditor(
+    fileOps,
+    registry,
+    personalAgentsDir,
+    projectAgentsDir,
+  );
 
   const wizard = createAgentCreationWizard({
-    fileOps: deps.fileOps,
-    manager: deps.manager,
-    registry: deps.registry,
-    personalAgentsDir: deps.personalAgentsDir,
-    projectAgentsDir: deps.projectAgentsDir,
+    fileOps,
+    manager,
+    registry,
+    personalAgentsDir,
+    projectAgentsDir,
   });
 
-  async function showAgentsMenu(ctx: ExtensionContext) {
-    deps.registry.reload();
-    const allNames = deps.registry.getAllTypes();
+  async function showAgentsMenu(
+    ui: MenuUI,
+    modelRegistry: ModelRegistry,
+    parentSnapshot: ParentSnapshot,
+  ) {
+    registry.reload();
+    const allNames = registry.getAllTypes();
 
     const options: string[] = [];
 
-    const agents = deps.manager.listAgents();
+    const agents = manager.listAgents();
     if (agents.length > 0) {
       const running = agents.filter(
         (a) => a.status === "running" || a.status === "queued",
@@ -108,30 +135,30 @@ export function createAgentsMenuHandler(deps: AgentMenuDeps) {
         : "";
 
     if (noAgentsMsg) {
-      ctx.ui.notify(noAgentsMsg, "info");
+      ui.notify(noAgentsMsg, "info");
     }
 
-    const choice = await ctx.ui.select("Agents", options);
+    const choice = await ui.select("Agents", options);
     if (!choice) return;
 
     if (choice.startsWith("Running agents (")) {
-      await showRunningAgents(ctx);
-      await showAgentsMenu(ctx);
+      await showRunningAgents(ui);
+      await showAgentsMenu(ui, modelRegistry, parentSnapshot);
     } else if (choice.startsWith("Agent types (")) {
-      await showAllAgentsList(ctx);
-      await showAgentsMenu(ctx);
+      await showAllAgentsList(ui, modelRegistry);
+      await showAgentsMenu(ui, modelRegistry, parentSnapshot);
     } else if (choice === "Create new agent") {
-      await wizard.showCreateWizard(ctx);
+      await wizard.showCreateWizard(ui, parentSnapshot);
     } else if (choice === "Settings") {
-      await showSettings(ctx);
-      await showAgentsMenu(ctx);
+      await showSettings(ui);
+      await showAgentsMenu(ui, modelRegistry, parentSnapshot);
     }
   }
 
-  async function showAllAgentsList(ctx: ExtensionContext) {
-    const allNames = deps.registry.getAllTypes();
+  async function showAllAgentsList(ui: MenuUI, modelRegistry: ModelRegistry) {
+    const allNames = registry.getAllTypes();
     if (allNames.length === 0) {
-      ctx.ui.notify("No agents.", "info");
+      ui.notify("No agents.", "info");
       return;
     }
 
@@ -144,9 +171,9 @@ export function createAgentsMenuHandler(deps: AgentMenuDeps) {
     };
 
     const entries = allNames.map((name) => {
-      const cfg = deps.registry.resolveAgentConfig(name);
+      const cfg = registry.resolveAgentConfig(name);
       const disabled = cfg.enabled === false;
-      const model = deps.getModelLabel(name, ctx.modelRegistry);
+      const model = getModelLabel(name, modelRegistry);
       const indicator = sourceIndicator(cfg);
       const prefix = `${indicator}${name} · ${model}`;
       const desc = disabled ? "(disabled)" : cfg.description;
@@ -155,10 +182,12 @@ export function createAgentsMenuHandler(deps: AgentMenuDeps) {
     const maxPrefix = Math.max(...entries.map((e) => e.prefix.length));
 
     const hasCustom = allNames.some((n) => {
-      const c = deps.registry.resolveAgentConfig(n);
+      const c = registry.resolveAgentConfig(n);
       return !c.isDefault && c.enabled !== false;
     });
-    const hasDisabled = allNames.some((n) => deps.registry.resolveAgentConfig(n).enabled === false);
+    const hasDisabled = allNames.some(
+      (n) => registry.resolveAgentConfig(n).enabled === false,
+    );
     const legendParts: string[] = [];
     if (hasCustom) legendParts.push("• = project  ◦ = global");
     if (hasDisabled) legendParts.push("✕ = disabled");
@@ -169,47 +198,47 @@ export function createAgentsMenuHandler(deps: AgentMenuDeps) {
     );
     if (legend) options.push(legend);
 
-    const choice = await ctx.ui.select("Agent types", options);
+    const choice = await ui.select("Agent types", options);
     if (!choice) return;
 
     const agentName = choice
       .split(" · ")[0]
       .replace(/^[•◦✕\s]+/, "")
       .trim();
-    if (deps.registry.resolveType(agentName) != null) {
-      await editor.showAgentDetail(ctx, agentName);
-      await showAllAgentsList(ctx);
+    if (registry.resolveType(agentName) != null) {
+      await editor.showAgentDetail(ui, agentName);
+      await showAllAgentsList(ui, modelRegistry);
     }
   }
 
-  async function showRunningAgents(ctx: ExtensionContext) {
-    const agents = deps.manager.listAgents();
+  async function showRunningAgents(ui: MenuUI) {
+    const agents = manager.listAgents();
     if (agents.length === 0) {
-      ctx.ui.notify("No agents.", "info");
+      ui.notify("No agents.", "info");
       return;
     }
 
     const options = agents.map((a) => {
-      const dn = getDisplayName(a.type, deps.registry);
+      const dn = getDisplayName(a.type, registry);
       const dur = formatDuration(a.startedAt, a.completedAt);
       return `${dn} (${a.description}) · ${a.toolUses} tools · ${a.status} · ${dur}`;
     });
 
-    const choice = await ctx.ui.select("Running agents", options);
+    const choice = await ui.select("Running agents", options);
     if (!choice) return;
 
     const idx = options.indexOf(choice);
     if (idx < 0) return;
     const record = agents[idx];
 
-    await viewAgentConversation(ctx, record);
-    await showRunningAgents(ctx);
+    await viewAgentConversation(ui, record);
+    await showRunningAgents(ui);
   }
 
-  async function viewAgentConversation(ctx: ExtensionContext, record: AgentRecord) {
+  async function viewAgentConversation(ui: MenuUI, record: AgentRecord) {
     const session = record.session;
     if (!session) {
-      ctx.ui.notify(
+      ui.notify(
         `Agent is ${record.status === "queued" ? "queued" : "expired"} — no session available.`,
         "info",
       );
@@ -219,11 +248,19 @@ export function createAgentsMenuHandler(deps: AgentMenuDeps) {
     const { ConversationViewer, VIEWPORT_HEIGHT_PCT } = await import(
       "./conversation-viewer.js"
     );
-    const activity = deps.agentActivity.get(record.id);
+    const activity = agentActivity.get(record.id);
 
-    await ctx.ui.custom<undefined>(
+    await ui.custom<undefined>(
       (tui: any, theme: any, _keybindings: any, done: any) => {
-        return new ConversationViewer({ tui, session, record, activity, theme, done, registry: deps.registry });
+        return new ConversationViewer({
+          tui,
+          session,
+          record,
+          activity,
+          theme,
+          done,
+          registry,
+        });
       },
       {
         overlay: true,
@@ -236,61 +273,68 @@ export function createAgentsMenuHandler(deps: AgentMenuDeps) {
     );
   }
 
-  async function showSettings(ctx: ExtensionContext) {
-    const choice = await ctx.ui.select("Settings", [
-      `Max concurrency (current: ${deps.settings.maxConcurrent})`,
-      `Default max turns (current: ${deps.settings.defaultMaxTurns ?? "unlimited"})`,
-      `Grace turns (current: ${deps.settings.graceTurns})`,
+  async function showSettings(ui: MenuUI) {
+    const choice = await ui.select("Settings", [
+      `Max concurrency (current: ${settings.maxConcurrent})`,
+      `Default max turns (current: ${settings.defaultMaxTurns ?? "unlimited"})`,
+      `Grace turns (current: ${settings.graceTurns})`,
     ]);
     if (!choice) return;
 
     if (choice.startsWith("Max concurrency")) {
-      const val = await ctx.ui.input(
+      const val = await ui.input(
         "Max concurrent background agents",
-        String(deps.settings.maxConcurrent),
+        String(settings.maxConcurrent),
       );
       if (val) {
         const n = parseInt(val, 10);
         if (n >= 1) {
-          const toast = deps.settings.applyMaxConcurrent(n);
-          ctx.ui.notify(toast.message, toast.level);
+          const toast = settings.applyMaxConcurrent(n);
+          ui.notify(toast.message, toast.level);
         } else {
-          ctx.ui.notify("Must be a positive integer.", "warning");
+          ui.notify("Must be a positive integer.", "warning");
         }
       }
     } else if (choice.startsWith("Default max turns")) {
-      const val = await ctx.ui.input(
+      const val = await ui.input(
         "Default max turns before wrap-up (0 = unlimited)",
-        String(deps.settings.defaultMaxTurns ?? 0),
+        String(settings.defaultMaxTurns ?? 0),
       );
       if (val) {
         const n = parseInt(val, 10);
         if (n >= 0) {
-          const toast = deps.settings.applyDefaultMaxTurns(n);
-          ctx.ui.notify(toast.message, toast.level);
+          const toast = settings.applyDefaultMaxTurns(n);
+          ui.notify(toast.message, toast.level);
         } else {
-          ctx.ui.notify("Must be 0 (unlimited) or a positive integer.", "warning");
+          ui.notify("Must be 0 (unlimited) or a positive integer.", "warning");
         }
       }
     } else if (choice.startsWith("Grace turns")) {
-      const val = await ctx.ui.input(
+      const val = await ui.input(
         "Grace turns after wrap-up steer",
-        String(deps.settings.graceTurns),
+        String(settings.graceTurns),
       );
       if (val) {
         const n = parseInt(val, 10);
         if (n >= 1) {
-          const toast = deps.settings.applyGraceTurns(n);
-          ctx.ui.notify(toast.message, toast.level);
+          const toast = settings.applyGraceTurns(n);
+          ui.notify(toast.message, toast.level);
         } else {
-          ctx.ui.notify("Must be a positive integer.", "warning");
+          ui.notify("Must be a positive integer.", "warning");
         }
       }
     }
   }
 
-  // Return the handler function
-  return async (ctx: ExtensionContext) => {
-    await showAgentsMenu(ctx);
+  return async ({
+    ui,
+    modelRegistry,
+    parentSnapshot,
+  }: {
+    ui: MenuUI;
+    modelRegistry: ModelRegistry;
+    parentSnapshot: ParentSnapshot;
+  }) => {
+    await showAgentsMenu(ui, modelRegistry, parentSnapshot);
   };
 }

package/src/ui/agent-widget.ts

@@ -5,28 +5,11 @@
  * Uses the callback form of setWidget for themed rendering.
  */
 
-import { truncateToWidth } from "@earendil-works/pi-tui";
 import type { AgentManager } from "../agent-manager.js";
 import { AgentTypeRegistry } from "../agent-types.js";
-import type { SubagentType } from "../types.js";
-import { getLifetimeTotal, getSessionContextPercent } from "../usage.js";
 import type { AgentActivityTracker } from "./agent-activity-tracker.js";
-import {
-  describeActivity,
-  ERROR_STATUSES,
-  formatMs,
-  formatSessionTokens,
-  formatTurns,
-  getDisplayName,
-  getPromptModeLabel,
-  SPINNER,
-  type Theme,
-} from "./display.js";
-
-// ---- Constants ----
-
-/** Maximum number of rendered lines before overflow collapse kicks in. */
-const MAX_WIDGET_LINES = 12;
+import { ERROR_STATUSES, type Theme } from "./display.js";
+import { renderWidgetLines } from "./widget-renderer.js";
 
 // ---- Types ----
 
@@ -113,176 +96,17 @@ 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 }, theme: Theme): string {
-    const name = getDisplayName(a.type, this.registry);
-    const modeLabel = getPromptModeLabel(a.type, this.registry);
-    const duration = formatMs((a.completedAt ?? Date.now()) - a.startedAt);
-
-    let icon: string;
-    let statusText: string;
-    if (a.status === "completed") {
-      icon = theme.fg("success", "✓");
-      statusText = "";
-    } else if (a.status === "steered") {
-      icon = theme.fg("warning", "✓");
-      statusText = theme.fg("warning", " (turn limit)");
-    } else if (a.status === "stopped") {
-      icon = theme.fg("dim", "■");
-      statusText = theme.fg("dim", " stopped");
-    } else if (a.status === "error") {
-      icon = theme.fg("error", "✗");
-      const errMsg = a.error ? `: ${a.error.slice(0, 60)}` : "";
-      statusText = theme.fg("error", ` error${errMsg}`);
-    } else {
-      // aborted
-      icon = theme.fg("error", "✗");
-      statusText = theme.fg("warning", " aborted");
-    }
-
-    const parts: string[] = [];
-    const activity = this.agentActivity.get(a.id);
-    if (activity) parts.push(formatTurns(activity.turnCount, activity.maxTurns));
-    if (a.toolUses > 0) parts.push(`${a.toolUses} tool use${a.toolUses === 1 ? "" : "s"}`);
-    parts.push(duration);
-
-    const modeTag = modeLabel ? ` ${theme.fg("dim", `(${modeLabel})`)}` : "";
-    return `${icon} ${theme.fg("dim", name)}${modeTag}  ${theme.fg("dim", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", parts.join(" · "))}${statusText}`;
-  }
-
-  /**
-   * Render the widget content. Called from the registered widget's render() callback,
-   * reading live state each time instead of capturing it in a closure.
-   */
+  /** Delegate rendering to the pure widget-renderer module. */
   private renderWidget(tui: any, theme: Theme): string[] {
-    const allAgents = this.manager.listAgents();
-    const running = allAgents.filter(a => a.status === "running");
-    const queued = allAgents.filter(a => a.status === "queued");
-    const finished = allAgents.filter(a =>
-      a.status !== "running" && a.status !== "queued" && a.completedAt
-      && this.shouldShowFinished(a.id, a.status),
-    );
-
-    const hasActive = running.length > 0 || queued.length > 0;
-    const hasFinished = finished.length > 0;
-
-    // Nothing to show — return empty (widget will be unregistered by update())
-    if (!hasActive && !hasFinished) return [];
-
-    const w = tui.terminal.columns;
-    const truncate = (line: string) => truncateToWidth(line, w);
-    const headingColor = hasActive ? "accent" : "dim";
-    const headingIcon = hasActive ? "●" : "○";
-    const frame = SPINNER[this.widgetFrame % SPINNER.length];
-
-    // Build sections separately for overflow-aware assembly.
-    // Each running agent = 2 lines (header + activity), finished = 1 line, queued = 1 line.
-
-    const finishedLines: string[] = [];
-    for (const a of finished) {
-      finishedLines.push(truncate(theme.fg("dim", "├─") + " " + this.renderFinishedLine(a, theme)));
-    }
-
-    const runningLines: string[][] = []; // each entry is [header, activity]
-    for (const a of running) {
-      const name = getDisplayName(a.type, this.registry);
-      const modeLabel = getPromptModeLabel(a.type, this.registry);
-      const modeTag = modeLabel ? ` ${theme.fg("dim", `(${modeLabel})`)}` : "";
-      const elapsed = formatMs(Date.now() - a.startedAt);
-
-      const bg = this.agentActivity.get(a.id);
-      const tokens = getLifetimeTotal(a.lifetimeUsage);
-      const contextPercent = getSessionContextPercent(a.session);
-      const tokenText = tokens > 0 ? formatSessionTokens(tokens, contextPercent, theme, a.compactionCount) : "";
-
-      const parts: string[] = [];
-      if (bg) parts.push(formatTurns(bg.turnCount, bg.maxTurns));
-      if (a.toolUses > 0) parts.push(`${a.toolUses} tool use${a.toolUses === 1 ? "" : "s"}`);
-      if (tokenText) parts.push(tokenText);
-      parts.push(elapsed);
-      const statsText = parts.join(" · ");
-
-      const activity = bg ? describeActivity(bg.activeTools, bg.responseText) : "thinking…";
-
-      runningLines.push([
-        truncate(theme.fg("dim", "├─") + ` ${theme.fg("accent", frame)} ${theme.bold(name)}${modeTag}  ${theme.fg("muted", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", statsText)}`),
-        truncate(theme.fg("dim", "│  ") + theme.fg("dim", `  ⎿  ${activity}`)),
-      ]);
-    }
-
-    const queuedLine = queued.length > 0
-      ? truncate(theme.fg("dim", "├─") + ` ${theme.fg("muted", "◦")} ${theme.fg("dim", `${queued.length} queued`)}`)
-      : undefined;
-
-    // Assemble with overflow cap (heading + overflow indicator = 2 reserved lines).
-    const maxBody = MAX_WIDGET_LINES - 1; // heading takes 1 line
-    const totalBody = finishedLines.length + runningLines.length * 2 + (queuedLine ? 1 : 0);
-
-    const lines: string[] = [truncate(theme.fg(headingColor, headingIcon) + " " + theme.fg(headingColor, "Agents"))];
-
-    if (totalBody <= maxBody) {
-      // Everything fits — add all lines and fix up connectors for the last item.
-      lines.push(...finishedLines);
-      for (const pair of runningLines) lines.push(...pair);
-      if (queuedLine) lines.push(queuedLine);
-
-      // Fix last connector: swap ├─ → └─ and │ → space for activity lines.
-      if (lines.length > 1) {
-        const last = lines.length - 1;
-        lines[last] = lines[last].replace("├─", "└─");
-        // If last item is a running agent activity line, fix indent of that line
-        // and fix the header line above it.
-        if (runningLines.length > 0 && !queuedLine) {
-          // The last two lines are the last running agent's header + activity.
-          if (last >= 2) {
-            lines[last - 1] = lines[last - 1].replace("├─", "└─");
-            lines[last] = lines[last].replace("│  ", "   ");
-          }
-        }
-      }
-    } else {
-      // Overflow — prioritize: running > queued > finished.
-      // Reserve 1 line for overflow indicator.
-      let budget = maxBody - 1;
-      let hiddenRunning = 0;
-      let hiddenFinished = 0;
-
-      // 1. Running agents (2 lines each)
-      for (const pair of runningLines) {
-        if (budget >= 2) {
-          lines.push(...pair);
-          budget -= 2;
-        } else {
-          hiddenRunning++;
-        }
-      }
-
-      // 2. Queued line
-      if (queuedLine && budget >= 1) {
-        lines.push(queuedLine);
-        budget--;
-      }
-
-      // 3. Finished agents
-      for (const fl of finishedLines) {
-        if (budget >= 1) {
-          lines.push(fl);
-          budget--;
-        } else {
-          hiddenFinished++;
-        }
-      }
-
-      // Overflow summary
-      const overflowParts: string[] = [];
-      if (hiddenRunning > 0) overflowParts.push(`${hiddenRunning} running`);
-      if (hiddenFinished > 0) overflowParts.push(`${hiddenFinished} finished`);
-      const overflowText = overflowParts.join(", ");
-      lines.push(truncate(theme.fg("dim", "└─") + ` ${theme.fg("dim", `+${hiddenRunning + hiddenFinished} more (${overflowText})`)}`)
-      );
-    }
-
-    return lines;
+    return renderWidgetLines({
+      agents: this.manager.listAgents(),
+      activityMap: this.agentActivity,
+      registry: this.registry,
+      spinnerFrame: this.widgetFrame,
+      terminalWidth: tui.terminal.columns,
+      theme,
+      shouldShowFinished: (id, status) => this.shouldShowFinished(id, status),
+    });
   }
 
   /** Force an immediate widget update. */

package/src/ui/display.ts

@@ -94,7 +94,8 @@ export function formatSessionTokens(
     annot.push(theme.fg("dim", `↻${compactions}`));
   }
   if (annot.length === 0) return tokenStr;
-  return `${tokenStr} (${annot.join(" · ")})`;
+  const sep = theme.fg("dim", " · ");
+  return `${tokenStr} ${theme.fg("dim", "(")}${annot.join(sep)}${theme.fg("dim", ")")}`;
 }
 
 /** Format turn count with optional max limit: "⟳5≤30" or "⟳5". */