@clanker-code/pi-subagents 0.10.8 → 0.11.1

package/dist/dashboard-ui.js

@@ -0,0 +1,231 @@
+/**
+ * dashboard-ui.ts — Register dashboard UI modules for subagent visibility.
+ *
+ * Provides three integration points with pi-agent-dashboard:
+ * 1. Footer-segment decorator showing running/completed agent counts
+ * 2. Management-modal module with a table view of all subagent history
+ * 3. Round-trip event handlers for data fetch, abort, and steer actions
+ */
+import { formatMs, getDisplayName } from "./ui/agent-widget.js";
+import { getLifetimeTotal } from "./usage.js";
+const NAMESPACE = "subagents";
+const MODULE_ID = "subagents-overview";
+const DATA_EVENT = "subagents:rows";
+const INVALIDATE_DEBOUNCE_MS = 500;
+/**
+ * Build a row for the management-modal table from an AgentRecord.
+ */
+function buildAgentRow(record) {
+    const durationMs = record.completedAt
+        ? record.completedAt - record.startedAt
+        : Date.now() - record.startedAt;
+    const totalTokens = getLifetimeTotal(record.lifetimeUsage);
+    return {
+        id: record.id,
+        type: getDisplayName(record.type),
+        description: record.description ?? "",
+        model: record.invocation?.modelName ?? "—",
+        status: record.status,
+        toolUses: record.toolUses ?? 0,
+        tokens: totalTokens > 0 ? formatTokenCount(totalTokens) : "—",
+        duration: formatMs(durationMs),
+        outputFile: record.outputFile ?? "",
+        startedAt: record.startedAt,
+    };
+}
+function formatTokenCount(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}k`;
+    return String(n);
+}
+/**
+ * Register all dashboard UI integration points.
+ * Call once during extension setup when pi.events is available.
+ */
+export function registerDashboardModules(pi, manager) {
+    if (!pi.events)
+        return;
+    let invalidateTimer;
+    function scheduleInvalidate() {
+        if (invalidateTimer)
+            return;
+        invalidateTimer = setTimeout(() => {
+            invalidateTimer = undefined;
+            pi.events.emit("ui:invalidate", {});
+        }, INVALIDATE_DEBOUNCE_MS);
+    }
+    // ── 1. Module Discovery (ui:list-modules) ──────────────────────────
+    // Guard against duplicate pushes: the bridge may call refreshUiModules
+    // multiple times per probe cycle when multiple sessions each register
+    // their own ui:invalidate listener. Check if our modules are already
+    // present before pushing.
+    pi.events.on("ui:list-modules", ((probe) => {
+        const alreadyContributed = probe.modules.some((m) => m.kind === "management-modal" && m.id === MODULE_ID);
+        if (alreadyContributed)
+            return;
+        const agents = manager.listAgents();
+        const running = agents.filter(a => a.status === "running").length;
+        const completed = agents.filter(a => a.status === "completed").length;
+        const total = agents.length;
+        // Footer-segment: running/completed counts
+        const parts = [];
+        if (running > 0)
+            parts.push(`● ${running} running`);
+        if (completed > 0)
+            parts.push(`✓ ${completed} done`);
+        if (total === 0)
+            parts.push("No agents");
+        probe.modules.push({
+            kind: "footer-segment",
+            namespace: NAMESPACE,
+            id: "agent-counts",
+            payload: {
+                text: parts.join(" · "),
+                tooltip: `${total} total agents (${running} running, ${completed} completed)`,
+                icon: "mdiRobot",
+            },
+        });
+        // Management-modal: subagent overview table
+        probe.modules.push({
+            kind: "management-modal",
+            id: MODULE_ID,
+            command: "/subagents",
+            title: "Subagents",
+            description: "View and manage background subagents",
+            icon: "mdiRobotOutline",
+            category: "subagents",
+            view: {
+                kind: "table",
+                dataEvent: DATA_EVENT,
+                rowKey: "id",
+                fields: [
+                    { key: "id", label: "ID", kind: "text", width: 120 },
+                    { key: "type", label: "Type", kind: "text", width: 100 },
+                    { key: "description", label: "Description", kind: "text" },
+                    { key: "model", label: "Model", kind: "text", width: 80 },
+                    { key: "status", label: "Status", kind: "text", width: 90 },
+                    { key: "toolUses", label: "Tools", kind: "number", width: 60 },
+                    { key: "tokens", label: "Tokens", kind: "text", width: 80 },
+                    { key: "duration", label: "Duration", kind: "text", width: 80 },
+                ],
+                rowActions: [
+                    {
+                        id: "view-result",
+                        label: "View Result",
+                        icon: "mdiEye",
+                        variant: "primary",
+                        event: "subagents:ui:view-result",
+                    },
+                    {
+                        id: "abort",
+                        label: "Abort",
+                        icon: "mdiStop",
+                        variant: "danger",
+                        event: "subagents:ui:abort",
+                        confirm: "Abort this running agent?",
+                    },
+                    {
+                        id: "steer",
+                        label: "Steer",
+                        icon: "mdiMessageArrowRight",
+                        variant: "secondary",
+                        event: "subagents:ui:steer",
+                    },
+                ],
+                emptyState: "No subagents have been spawned in this session.",
+                actions: [
+                    {
+                        id: "refresh",
+                        label: "Refresh",
+                        icon: "mdiRefresh",
+                        variant: "secondary",
+                        event: "subagents:ui:refresh",
+                    },
+                ],
+            },
+        });
+    }));
+    // ── 2. Data Fetch Handler ──────────────────────────────────────────
+    pi.events.on(DATA_EVENT, ((data) => {
+        const agents = manager.listAgents();
+        data.items = agents.map(buildAgentRow);
+    }));
+    // ── 3. Action Handlers ─────────────────────────────────────────────
+    // Refresh: just invalidate to re-probe + re-fetch
+    pi.events.on("subagents:ui:refresh", (() => {
+        scheduleInvalidate();
+    }));
+    // View Result: return the agent's result as table rows so the modal
+    // displays it. The bridge's synchronous fast path calls `_reply(items)`
+    // when `data.items` is populated by the handler — do NOT call
+    // `scheduleInvalidate()` here as the subsequent re-probe would
+    // overwrite the returned rows with the original table data.
+    pi.events.on("subagents:ui:view-result", ((data) => {
+        // Bridge spreads msg.params into data; row identity is at data.row.id.
+        const agentId = data.row?.id ?? data.id;
+        if (!agentId)
+            return;
+        const record = manager.getRecord(agentId);
+        if (!record)
+            return;
+        const resultText = record.result?.trim() || "No output yet.";
+        const preview = resultText.length > 2000
+            ? resultText.slice(0, 2000) + "\n…(truncated)"
+            : resultText;
+        // Populate data.items — the bridge's synchronous fast path forwards
+        // this as a `ui_data_list` message back to the dashboard.
+        data.items = [{
+                id: record.id,
+                type: getDisplayName(record.type),
+                description: record.description,
+                status: record.status,
+                result: preview,
+                outputFile: record.outputFile ?? "",
+            }];
+    }));
+    // Abort: stop the running agent via the manager's abort() method
+    // which properly cancels the AbortController and cleans up state.
+    pi.events.on("subagents:ui:abort", ((data) => {
+        const agentId = data.row?.id ?? data.id;
+        if (!agentId)
+            return;
+        manager.abort(agentId);
+        scheduleInvalidate();
+    }));
+    // Steer: send a steering message to a running agent's session.
+    // The management-modal row action carries the row identity; we steer
+    // with a default "Continue" nudge. A future form view could accept
+    // custom text.
+    pi.events.on("subagents:ui:steer", ((data) => {
+        const agentId = data.row?.id ?? data.id;
+        if (!agentId)
+            return;
+        const record = manager.getRecord(agentId);
+        if (!record)
+            return;
+        if (record.status === "running" && record.session) {
+            // Session is live — steer immediately
+            record.session.steer("Continue").catch(() => { });
+        }
+        else if (record.status === "queued") {
+            // Session not yet created — queue the steer for flush on start
+            if (!record.pendingSteers)
+                record.pendingSteers = [];
+            record.pendingSteers.push("Continue");
+        }
+        scheduleInvalidate();
+    }));
+    // ── 4. Invalidate on agent lifecycle events ────────────────────────
+    const lifecycleEvents = [
+        "subagents:created",
+        "subagents:started",
+        "subagents:completed",
+        "subagents:failed",
+        "subagents:compacted",
+    ];
+    for (const event of lifecycleEvents) {
+        pi.events.on(event, (() => scheduleInvalidate()));
+    }
+}

package/dist/default-agents.js

@@ -30,7 +30,6 @@ export const DEFAULT_AGENTS = 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/dist/index.js

@@ -23,8 +23,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";
@@ -36,8 +38,9 @@ import { SubagentScheduler } from "./schedule.js";
 import { resolveStorePath, ScheduleStore } from "./schedule-store.js";
 import { applyAndEmitLoaded, DEFAULT_WAIT_TIMEOUT_SECONDS, saveAndEmitChanged } from "./settings.js";
 import { getStatusNote } from "./status-note.js";
+import { registerSubagentListClearTools } from "./subagent-list-clear.js";
 import { MAX_RECURSIVE_DEPTH } 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 { AgentWidget, buildInvocationTags, describeActivity, formatContextWindow, formatDuration, getDisplayName, getPromptModeLabel, } from "./ui/agent-widget.js";
 import { menuSelect } from "./ui/menu-select.js";
 import { showSchedulesMenu } from "./ui/schedule-menu.js";
@@ -376,7 +379,7 @@ export default function (pi) {
                 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) {
@@ -388,6 +391,8 @@ export default function (pi) {
     // 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();
@@ -395,8 +400,10 @@ export default function (pi) {
             startScheduler(ctx);
     });
     pi.on("session_before_switch", () => {
+        clearBatchState();
+        groupJoin.dispose();
         manager.clearCompleted();
-        widget.clearSnapshots();
+        widget.dispose();
         retryStash.clear();
         scheduler.stop();
     });
@@ -405,6 +412,8 @@ export default function (pi) {
         pi,
         getCtx: () => currentCtx,
         manager,
+        depth: nextSubagentDepth,
+        parentAgentId: extensionAgentId,
     });
     // Broadcast readiness so extensions loaded after us can discover us
     pi.events.emit("subagents:ready", {});
@@ -414,13 +423,17 @@ export default function (pi) {
         unsubSpawnRpc();
         unsubStopRpc();
         unsubPingRpc();
+        unsubWidgetCreated?.();
         unsubWidgetStarted?.();
         unsubWidgetCompleted?.();
         unsubWidgetFailed?.();
         currentCtx = undefined;
         delete globalThis[MANAGER_KEY];
         scheduler.stop();
+        clearBatchState();
+        groupJoin.dispose();
         manager.abortAll();
+        widget.dispose();
         for (const timer of pendingNudges.values())
             clearTimeout(timer);
         pendingNudges.clear();
@@ -434,6 +447,7 @@ export default function (pi) {
         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);
@@ -501,6 +515,13 @@ export default function (pi) {
     let currentBatchAgents = [];
     let batchFinalizeTimer;
     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;
@@ -575,7 +596,7 @@ export default function (pi) {
     const scheduleParam = isSchedulingEnabled() ? scheduleParamShape : {};
     const agentToolDescription = buildAgentToolDescription({
         mode: getToolDescriptionMode(),
-        extensionDepth,
+        nextSubagentDepth,
         schedulingEnabled: isSchedulingEnabled(),
     });
     pi.registerTool(defineTool({
@@ -597,7 +618,7 @@ export default function (pi) {
                 description: "A short (3-5 word) description of the task (shown in UI).",
             }),
             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(Type.String({
                 description: 'Optional model override. Accepts "provider/modelId" or fuzzy name (e.g. "haiku", "sonnet"). Omit to use the agent type\'s default.',
@@ -673,14 +694,14 @@ export default function (pi) {
                 const { retry: _omit, ...overrides } = params;
                 P = { ...stashed.params, ...overrides };
             }
-            emitPromptPreview(P.prompt, P.description, P.subagent_type);
-            // 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(", ") +
-                    ".");
+            const requestedSubagentType = (P.subagent_type ?? "general-purpose");
+            emitPromptPreview(P.prompt, P.description, requestedSubagentType);
+            // 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;
+            const rawType = requestedSubagentType;
             const resolved = resolveType(rawType);
             if (!resolved) {
                 // Unknown agent type — recoverable. List valid types so the orchestrator
@@ -853,6 +874,7 @@ export default function (pi) {
                     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,
@@ -896,6 +918,10 @@ export default function (pi) {
                 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";
             return textResult(`Agent ${isQueued ? "queued" : "started"} in background.\nAgent ID: ${id}\nType: ${displayName}\nDescription: ${P.description}\n` +
@@ -928,6 +954,56 @@ export default function (pi) {
                 description: "Return a lightweight tail/filter view of the agent's result or live output file, with line numbers. Ignored when verbose is true.",
             })),
         }),
+        renderResult(result, { expanded }, theme) {
+            const details = result.details;
+            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 = [];
+                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) {
@@ -974,6 +1050,15 @@ export default function (pi) {
             if (record.compactionCount)
                 statsParts.push(`Compactions: ${record.compactionCount}`);
             statsParts.push(`Duration: ${duration}`);
+            const details = {
+                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` +
                 `Description: ${record.description}\n` +
@@ -1014,7 +1099,7 @@ export default function (pi) {
                     }
                 }
             }
-            return textResult(output);
+            return textResult(output, details);
         },
     }));
     // ---- steer_subagent tool ----
@@ -1072,6 +1157,9 @@ export default function (pi) {
             }
         },
     }));
+    // ---- list_subagents / clear_subagents tools ----
+    registerSubagentListClearTools(pi, manager);
+    registerDashboardModules(pi, manager);
     // ---- list_models tool ----
     pi.registerTool(defineTool({
         name: SUBAGENT_TOOL_NAMES.LIST_MODELS,
@@ -1547,6 +1635,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") {
             ctx.ui.notify(`Generation failed: ${record.error}`, "warning");

package/dist/peek.js

@@ -81,6 +81,12 @@ function parseOutputFileLines(path) {
         return [];
     }
     const out = [];
+    const pushRenderedLines = (text) => {
+        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)
@@ -96,12 +102,12 @@ function parseOutputFileLines(path) {
         if (!Array.isArray(content)) {
             // Some entries may carry a plain string content.
             if (typeof content === "string" && content.trim())
-                out.push(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/dist/schedule.d.ts

@@ -51,6 +51,12 @@ export interface NewJobInput {
     isolated?: boolean;
     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 declare class SubagentScheduler {
     private jobs;
     private intervals;
@@ -58,8 +64,9 @@ export declare class SubagentScheduler {
     private pi;
     private ctx;
     private manager;
+    private spawnDefaults;
     /** 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;
     /** Stop all timers; drop refs. Safe to call repeatedly. */
     stop(): void;
     /** True if start() has bound a store and the scheduler is active. */
@@ -107,3 +114,4 @@ export declare class SubagentScheduler {
     /** "10s"/"5m"/"1h"/"2d" → milliseconds. */
     static parseInterval(s: string): number | null;
 }
+export {};

package/dist/schedule.js

@@ -24,12 +24,14 @@ export class SubagentScheduler {
     pi;
     ctx;
     manager;
+    spawnDefaults = {};
     /** Start the scheduler: bind to a session's store and arm enabled jobs. */
-    start(pi, ctx, manager, store) {
+    start(pi, ctx, manager, store, spawnDefaults = {}) {
         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);
@@ -47,6 +49,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. */
     isActive() {
@@ -222,6 +225,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) {

package/dist/subagent-list-clear.d.ts

@@ -0,0 +1,57 @@
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import type { AgentManager } from "./agent-manager.js";
+import type { AgentRecord } from "./types.js";
+export interface ListSubagentsOptions {
+    all?: boolean;
+    now?: number;
+    recentSuccessLimit?: number;
+}
+export interface ListSubagentsAgentDetails {
+    id: string;
+    type: AgentRecord["type"];
+    description: string;
+    status: AgentRecord["status"];
+    startedAt: number;
+    completedAt?: number;
+}
+export interface ListSubagentsDetails {
+    total: number;
+    all: boolean;
+    visible: ListSubagentsAgentDetails[];
+    hiddenDoneCount: number;
+    activeCount: number;
+    problemCount: number;
+    recentDoneCount: number;
+    now: number;
+}
+export interface ClearSubagentsOptions {
+    agentIds?: string[];
+    now?: number;
+    olderThanMs?: number;
+    includeErrors?: boolean;
+}
+export interface ClearSelectionResult {
+    clearIds: string[];
+    errors: string[];
+    requestedCount: number;
+    keptActiveCount: number;
+    keptFailedCount: number;
+    keptYoungSuccessCount: number;
+}
+export interface ClearSubagentsDetails extends ClearSelectionResult {
+    clearedCount: number;
+}
+export type RenderTheme = {
+    fg(color: string, text: string): string;
+    bold(text: string): string;
+};
+export declare function buildListSubagentsDetails(records: AgentRecord[], options?: ListSubagentsOptions): ListSubagentsDetails;
+export declare function clearSubagentRecords(records: AgentRecord[], options?: ClearSubagentsOptions): ClearSelectionResult;
+export declare function buildClearSubagentsDetails(result: ClearSelectionResult): ClearSubagentsDetails;
+export declare function renderListSubagentsDetails(details: ListSubagentsDetails, theme: RenderTheme): Component;
+export declare function renderClearSubagentsDetails(details: ClearSubagentsDetails, theme: RenderTheme): Component;
+export declare function renderEmptyCall(): Component;
+export declare function formatListSubagentsText(details: ListSubagentsDetails): string;
+export declare function formatClearSubagentsText(details: ClearSubagentsDetails): string;
+export declare function registerSubagentListClearTools(pi: ExtensionAPI, manager: AgentManager): void;