@clanker-code/pi-subagents 0.10.8 → 0.11.1

package/src/default-agents.ts

@@ -34,7 +34,6 @@ export const DEFAULT_AGENTS: Map<string, AgentConfig> = new Map([
       builtinToolNames: READ_ONLY_TOOLS,
       extensions: true,
       skills: true,
-      model: "anthropic/claude-haiku-4-5-20251001",
       systemPrompt: `# CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS
 You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
 Your role is EXCLUSIVELY to search and analyze existing code. You do NOT have access to file editing tools.

package/src/index.ts

@@ -24,8 +24,10 @@ import { getAgentConversation, getCurrentExtensionAgentId, getCurrentExtensionDe
 import { buildAgentToolDescription, getModelLabelFromConfig } from "./agent-tool-description.js";
 import { BUILTIN_TOOL_NAMES, getAgentConfig, getAllTypes, getAvailableTypes, isDefaultsDisabled, registerAgents, resolveType, setDefaultsDisabled } from "./agent-types.js";
 import { formatOutputFileHint, limitText, MAX_RESULT_CHARS, MAX_VERBOSE_CHARS } from "./bounded-output.js";
+import { extractText } from "./context.js";
 import { registerRpcHandlers } from "./cross-extension-rpc.js";
 import { loadCustomAgents } from "./custom-agents.js";
+import { registerDashboardModules } from "./dashboard-ui.js";
 import { isModelInScope, readEnabledModels, resolveEnabledModels } from "./enabled-models.js";
 import { GroupJoinManager } from "./group-join.js";
 import { resolveAgentInvocationConfig, resolveJoinMode } from "./invocation-config.js";
@@ -37,11 +39,11 @@ import { SubagentScheduler } from "./schedule.js";
 import { resolveStorePath, ScheduleStore } from "./schedule-store.js";
 import { applyAndEmitLoaded, DEFAULT_WAIT_TIMEOUT_SECONDS, type SubagentsSettings, saveAndEmitChanged, type ToolDescriptionMode } from "./settings.js";
 import { getStatusNote } from "./status-note.js";
+import { registerSubagentListClearTools } from "./subagent-list-clear.js";
 import { type AgentConfig, type AgentInvocation, type AgentRecord, type JoinMode, MAX_RECURSIVE_DEPTH, type NotificationDetails, type SubagentType } from "./types.js";
-import { renderAgentCall, renderAgentResult, renderSteerCall, tailPreview } from "./ui/agent-tool-rendering.js";
+import { renderAgentCall, renderAgentResult, renderSteerCall, snipMiddleLines, tailPreview } from "./ui/agent-tool-rendering.js";
 import {
   type AgentActivity,
-  type AgentDetails,
   AgentWidget,
   buildInvocationTags,
   describeActivity,
@@ -60,10 +62,21 @@ import { formatWaitTimeout, pollPendingMessages, raceWait, type WaitOutcome, wai
 // ---- Shared helpers ----
 
 /** Tool execute return value for a text response. */
-function textResult(msg: string, details?: AgentDetails) {
+function textResult(msg: string, details?: unknown) {
   return { content: [{ type: "text" as const, text: msg }], details: details as any };
 }
 
+/** Metadata attached to get_subagent_result for compact UI rendering. */
+interface GetResultDetails {
+  status: AgentRecord["status"];
+  description: string;
+  toolUses: number;
+  tokens: string | null;
+  contextPercent: number | null;
+  duration: string;
+  outputFile?: string;
+}
+
 /**
  * Create an AgentActivity state and spawn callbacks for tracking tool usage.
  * Used by the background spawn path to track tool usage.
@@ -431,7 +444,7 @@ export default function (pi: ExtensionAPI) {
       if (!sessionId) return;  // sessionId not yet available — try again on next event
       const path = resolveStorePath(ctx.cwd, sessionId);
       const store = new ScheduleStore(path);
-      scheduler.start(pi, ctx, manager, store);
+      scheduler.start(pi, ctx, manager, store, { depth: nextSubagentDepth, parentAgentId: extensionAgentId });
       pi.events.emit("subagents:scheduler_ready", { sessionId, jobCount: store.list().length });
     } catch (err) {
       // Scheduling is non-essential — log and move on so the rest of the
@@ -443,6 +456,8 @@ export default function (pi: ExtensionAPI) {
   // Capture ctx from session_start for RPC spawn handler + start the scheduler.
   pi.on("session_start", async (_event, ctx) => {
     currentCtx = ctx;
+    clearBatchState();
+    groupJoin.dispose();
     manager.clearCompleted();
     widget.clearSnapshots();
     retryStash.clear();
@@ -450,8 +465,10 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.on("session_before_switch", () => {
+    clearBatchState();
+    groupJoin.dispose();
     manager.clearCompleted();
-    widget.clearSnapshots();
+    widget.dispose();
     retryStash.clear();
     scheduler.stop();
   });
@@ -461,6 +478,8 @@ export default function (pi: ExtensionAPI) {
     pi,
     getCtx: () => currentCtx,
     manager,
+    depth: nextSubagentDepth,
+    parentAgentId: extensionAgentId,
   });
 
   // Broadcast readiness so extensions loaded after us can discover us
@@ -472,13 +491,17 @@ export default function (pi: ExtensionAPI) {
     unsubSpawnRpc();
     unsubStopRpc();
     unsubPingRpc();
+    unsubWidgetCreated?.();
     unsubWidgetStarted?.();
     unsubWidgetCompleted?.();
     unsubWidgetFailed?.();
     currentCtx = undefined;
     delete (globalThis as any)[MANAGER_KEY];
     scheduler.stop();
+    clearBatchState();
+    groupJoin.dispose();
     manager.abortAll();
+    widget.dispose();
     for (const timer of pendingNudges.values()) clearTimeout(timer);
     pendingNudges.clear();
     retryStash.clear();
@@ -491,6 +514,7 @@ export default function (pi: ExtensionAPI) {
     const snapshot = widgetSnapshotFromEvent(payload);
     if (snapshot) widget.upsertSnapshot(snapshot);
   };
+  const unsubWidgetCreated = pi.events.on("subagents:created", upsertWidgetEventSnapshot);
   const unsubWidgetStarted = pi.events.on("subagents:started", upsertWidgetEventSnapshot);
   const unsubWidgetCompleted = pi.events.on("subagents:completed", upsertWidgetEventSnapshot);
   const unsubWidgetFailed = pi.events.on("subagents:failed", upsertWidgetEventSnapshot);
@@ -567,6 +591,14 @@ export default function (pi: ExtensionAPI) {
   let batchFinalizeTimer: ReturnType<typeof setTimeout> | undefined;
   let batchCounter = 0;
 
+  function clearBatchState() {
+    if (batchFinalizeTimer) {
+      clearTimeout(batchFinalizeTimer);
+      batchFinalizeTimer = undefined;
+    }
+    currentBatchAgents = [];
+  }
+
   /** Finalize the current batch: if 2+ smart-mode agents, register as a group. */
   function finalizeBatch() {
     batchFinalizeTimer = undefined;
@@ -653,7 +685,7 @@ export default function (pi: ExtensionAPI) {
 
   const agentToolDescription = buildAgentToolDescription({
     mode: getToolDescriptionMode(),
-    extensionDepth,
+    nextSubagentDepth,
     schedulingEnabled: isSchedulingEnabled(),
   });
 
@@ -679,7 +711,7 @@ export default function (pi: ExtensionAPI) {
       }),
       subagent_type: Type.Optional(
         Type.String({
-          description: `The type of specialized agent to use. Available types: ${getAvailableTypes().join(", ")}. Custom agents from .pi/agents/*.md (project) or ${getAgentDir()}/agents/*.md (global) are also available. OMIT when retrying (preserved by the handle) unless you want to override it.`,
+          description: `The type of specialized agent to use. Defaults to general-purpose when omitted. Available types: ${getAvailableTypes().join(", ")}. Custom agents from .pi/agents/*.md (project) or ${getAgentDir()}/agents/*.md (global) are also available. OMIT when retrying (preserved by the handle) unless you want to override it.`,
         }),
       ),
       model: Type.Optional(
@@ -782,18 +814,16 @@ export default function (pi: ExtensionAPI) {
         const { retry: _omit, ...overrides } = params;
         P = { ...stashed.params, ...overrides } as typeof params;
       }
-      emitPromptPreview(P.prompt, P.description, P.subagent_type);
+      const requestedSubagentType = (P.subagent_type ?? "general-purpose") as SubagentType;
+      emitPromptPreview(P.prompt, P.description, requestedSubagentType);
 
-      // Retry supplied the prompt/type from the stash; otherwise both are required.
-      if (!retryHandle && (!P.prompt || !P.subagent_type)) {
-        return textResult(
-          `Missing required argument${!P.prompt && !P.subagent_type ? "s" : ""}: ` +
-          [!P.prompt && "prompt", !P.subagent_type && "subagent_type"].filter(Boolean).join(", ") +
-          ".",
-        );
+      // Retry supplied the prompt from the stash; otherwise prompt is required.
+      // subagent_type defaults to general-purpose when omitted.
+      if (!retryHandle && !P.prompt) {
+        return textResult("Missing required argument: prompt.");
       }
 
-      const rawType = P.subagent_type as SubagentType;
+      const rawType = requestedSubagentType;
       const resolved = resolveType(rawType);
       if (!resolved) {
         // Unknown agent type — recoverable. List valid types so the orchestrator
@@ -988,6 +1018,7 @@ export default function (pi: ExtensionAPI) {
           invocation: agentInvocation,
           depth: nextSubagentDepth,
           parentAgentId: extensionAgentId,
+          eventBus: pi.events,
           outputFileForAgent: (agentId) => createOutputFilePath(ctx.cwd, agentId, ctx.sessionManager.getSessionId()),
           onOutputFileCreated: (outputFile, agentId) => writeInitialEntry(outputFile, agentId, P.prompt!, ctx.cwd),
           ...bgCallbacks,
@@ -1032,6 +1063,10 @@ export default function (pi: ExtensionAPI) {
         isBackground: true,
         depth: record?.depth ?? nextSubagentDepth,
         parentAgentId: extensionAgentId,
+        status: record?.status ?? "running",
+        startedAt: record?.startedAt,
+        toolUses: record?.toolUses ?? 0,
+        invocation: record?.invocation,
       });
 
       const isQueued = record?.status === "queued";
@@ -1077,6 +1112,57 @@ export default function (pi: ExtensionAPI) {
         }),
       ),
     }),
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as GetResultDetails | undefined;
+      const text = extractText(result.content);
+
+      // Header: status + stats + description
+      let line = "";
+      if (details) {
+        const icon = details.status === "error" || details.status === "stopped" || details.status === "aborted"
+          ? theme.fg("error", "✗")
+          : details.status === "running" || details.status === "queued"
+            ? theme.fg("accent", "◌")
+            : theme.fg("success", "✓");
+
+        const parts: string[] = [];
+        if (details.toolUses > 0) parts.push(`${details.toolUses} tool use${details.toolUses === 1 ? "" : "s"}`);
+        if (details.tokens) parts.push(details.tokens);
+        if (details.contextPercent !== null) parts.push(`ctx ${Math.round(details.contextPercent)}%`);
+        if (details.duration) parts.push(details.duration);
+        const stats = parts.map(p => theme.fg("dim", p)).join(" " + theme.fg("dim", "·") + " ");
+
+        line = `${icon} ${theme.bold(details.description)} ${theme.fg("dim", details.status)}`;
+        if (stats) line += "\n  " + stats;
+      }
+
+      // Body: snip when collapsed, full when expanded
+      // Extract the body portion (after the first blank line) to keep the
+      // tool-output header always visible and only snip the actual result.
+      if (text.trim()) {
+        const firstBlank = text.indexOf("\n\n");
+        const body = firstBlank >= 0 ? text.slice(firstBlank + 2) : text;
+
+        if (expanded) {
+          for (const l of text.split("\n")) {
+            line += "\n" + theme.fg("dim", `  ${l}`);
+          }
+        } else {
+          // Show the tool-output header verbatim, then snip only the body
+          if (firstBlank >= 0) {
+            for (const l of text.slice(0, firstBlank).split("\n")) {
+              line += "\n" + theme.fg("dim", `  ${l}`);
+            }
+          }
+          for (const l of snipMiddleLines(body, 20)) {
+            line += "\n" + theme.fg("dim", `  ${l}`);
+          }
+        }
+      }
+
+      return new Text(line, 0, 0);
+    },
+
     execute: async (_toolCallId, params, signal, _onUpdate, ctx) => {
       const record = manager.getRecord(params.agent_id);
       if (!record) {
@@ -1125,6 +1211,16 @@ export default function (pi: ExtensionAPI) {
       if (record.compactionCount) statsParts.push(`Compactions: ${record.compactionCount}`);
       statsParts.push(`Duration: ${duration}`);
 
+      const details: GetResultDetails = {
+        status: record.status,
+        description: record.description,
+        toolUses: record.toolUses,
+        tokens: tokens || null,
+        contextPercent,
+        duration,
+        outputFile: record.outputFile,
+      };
+
       let output =
         `Agent: ${record.id}\n` +
         `Type: ${displayName} | Status: ${record.status}${getStatusNote(record.status)} | ${statsParts.join(" | ")}\n` +
@@ -1168,7 +1264,7 @@ export default function (pi: ExtensionAPI) {
         }
       }
 
-      return textResult(output);
+      return textResult(output, details);
     },
   }));
 
@@ -1228,6 +1324,11 @@ export default function (pi: ExtensionAPI) {
     },
   }));
 
+  // ---- list_subagents / clear_subagents tools ----
+
+  registerSubagentListClearTools(pi, manager);
+  registerDashboardModules(pi, manager);
+
   // ---- list_models tool ----
 
   pi.registerTool(defineTool({
@@ -1728,6 +1829,9 @@ Write the file using the write tool. Only write the file, nothing else.`;
     const record = await manager.spawnAndWait(pi, ctx, "general-purpose", generatePrompt, {
       description: `Generate ${name} agent`,
       maxTurns: 5,
+      eventBus: pi.events,
+      depth: nextSubagentDepth,
+      parentAgentId: extensionAgentId,
     });
 
     if (record.status === "error") {

package/src/peek.ts

@@ -112,6 +112,11 @@ function parseOutputFileLines(path: string): string[] {
     return [];
   }
   const out: string[] = [];
+  const pushRenderedLines = (text: string) => {
+    for (const renderedLine of text.trimEnd().split("\n")) {
+      if (renderedLine.trim()) out.push(renderedLine);
+    }
+  };
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
@@ -124,12 +129,12 @@ function parseOutputFileLines(path: string): string[] {
     const content = entry?.message?.content;
     if (!Array.isArray(content)) {
       // Some entries may carry a plain string content.
-      if (typeof content === "string" && content.trim()) out.push(content.trim());
+      if (typeof content === "string" && content.trim()) pushRenderedLines(content);
       continue;
     }
     for (const block of content) {
       if (block?.type === "text" && typeof block.text === "string" && block.text.trim()) {
-        out.push(block.text.trimEnd());
+        pushRenderedLines(block.text);
       }
     }
   }

package/src/schedule.ts

@@ -45,6 +45,13 @@ export interface NewJobInput {
   isolation?: IsolationMode;
 }
 
+interface SchedulerSpawnDefaults {
+  /** Recursive depth for scheduled subagents fired from this session. */
+  depth?: number;
+  /** Parent subagent id for scheduled subagents fired from this session. */
+  parentAgentId?: string;
+}
+
 export class SubagentScheduler {
   private jobs = new Map<string, Cron>();
   private intervals = new Map<string, NodeJS.Timeout>();
@@ -52,13 +59,21 @@ export class SubagentScheduler {
   private pi: ExtensionAPI | undefined;
   private ctx: ExtensionContext | undefined;
   private manager: AgentManager | undefined;
+  private spawnDefaults: SchedulerSpawnDefaults = {};
 
   /** Start the scheduler: bind to a session's store and arm enabled jobs. */
-  start(pi: ExtensionAPI, ctx: ExtensionContext, manager: AgentManager, store: ScheduleStore): void {
+  start(
+    pi: ExtensionAPI,
+    ctx: ExtensionContext,
+    manager: AgentManager,
+    store: ScheduleStore,
+    spawnDefaults: SchedulerSpawnDefaults = {},
+  ): void {
     this.pi = pi;
     this.ctx = ctx;
     this.manager = manager;
     this.store = store;
+    this.spawnDefaults = spawnDefaults;
 
     for (const job of store.list()) {
       if (job.enabled) this.scheduleJob(job);
@@ -75,6 +90,7 @@ export class SubagentScheduler {
     this.pi = undefined;
     this.ctx = undefined;
     this.manager = undefined;
+    this.spawnDefaults = {};
   }
 
   /** True if start() has bound a store and the scheduler is active. */
@@ -247,6 +263,9 @@ export class SubagentScheduler {
         isolated: job.isolated,
         thinkingLevel: job.thinking,
         isolation: job.isolation,
+        eventBus: pi.events,
+        depth: this.spawnDefaults.depth,
+        parentAgentId: this.spawnDefaults.parentAgentId,
       });
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);