@pi-archimedes/subagent 0.7.0 → 0.9.0

package/src/agents.ts

@@ -10,12 +10,14 @@ import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
 export interface AgentConfig {
   name: string;
   description: string;
+  tools?: string[];
   model?: string;
   thinking?: string;
-  tools?: string[];
   systemPrompt: string;
   source: "user" | "project";
   filePath: string;
+  // Extra fields preserved from frontmatter but not editable in TUI
+  extraFields?: Record<string, unknown>;
 }
 
 function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig[] {
@@ -46,9 +48,26 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 
     if (!frontmatter.name || !frontmatter.description) continue;
 
-    const tools = typeof frontmatter.tools === "string"
-      ? frontmatter.tools.split(",").map((t: string) => t.trim()).filter(Boolean)
-      : undefined;
+    // Handle tools specially — preserve non-string values in extraFields
+    let parsedTools: string[] | undefined;
+    if (typeof frontmatter.tools === "string") {
+      parsedTools = frontmatter.tools.split(",").map((t: string) => t.trim()).filter(Boolean);
+    }
+
+    const knownKeys = new Set(["name", "description", "model", "thinking"]);
+    const extraFields: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(frontmatter)) {
+      if (key === "tools") continue; // tools is handled separately above/below
+      if (!knownKeys.has(key) && value != null && typeof value !== "object") {
+        extraFields[key] = String(value);
+      } else if (!knownKeys.has(key) && value != null) {
+        extraFields[key] = value;
+      }
+    }
+    // If tools was non-string, store it in extraFields for round-trip preservation
+    if (frontmatter.tools !== undefined && !parsedTools && "tools" in frontmatter) {
+      extraFields.tools = frontmatter.tools;
+    }
 
     const config: AgentConfig = {
       name: frontmatter.name as string,
@@ -59,7 +78,8 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
     };
     if (frontmatter.model) config.model = frontmatter.model as string;
     if (frontmatter.thinking) config.thinking = frontmatter.thinking as string;
-    if (tools && tools.length > 0) config.tools = tools;
+    if (parsedTools && parsedTools.length > 0) config.tools = parsedTools;
+    if (Object.keys(extraFields).length > 0) config.extraFields = extraFields;
 
     agents.push(config);
   }
@@ -67,19 +87,14 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
   return agents;
 }
 
-function isDirectory(p: string): boolean {
-  try {
-    return fs.statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
 function findNearestProjectAgentsDir(cwd: string): string | null {
+  // Walk up looking for a git repo, even if .pi/agents doesn't exist yet
   let currentDir = cwd;
   while (true) {
-    const candidate = path.join(currentDir, ".pi", "agents");
-    if (isDirectory(candidate)) return candidate;
+    const gitPath = path.join(currentDir, ".git");
+    if (fs.existsSync(gitPath)) {
+      return path.join(currentDir, ".pi", "agents");
+    }
 
     const parentDir = path.dirname(currentDir);
     if (parentDir === currentDir) return null;
@@ -87,6 +102,16 @@ function findNearestProjectAgentsDir(cwd: string): string | null {
   }
 }
 
+/**
+ * Result of discovering agents — separated by source with directory paths.
+ */
+export interface AgentsDiscoveryResult {
+  user: AgentConfig[];
+  project: AgentConfig[];
+  userDir: string;        // e.g., ~/.pi/agent/agents
+  projectDir: string | null;  // e.g., .pi/agents or null if not found
+}
+
 /**
  * Discover all available agents from user and/or project directories.
  */
@@ -105,6 +130,24 @@ export function discoverAgents(cwd: string): AgentConfig[] {
   return Array.from(agentMap.values());
 }
 
+/**
+ * Discover agents and return them separated by source with directory paths.
+ */
+export function discoverAgentsAll(cwd: string): AgentsDiscoveryResult {
+  const userDir = path.join(getAgentDir(), "agents");
+  const projectDir = findNearestProjectAgentsDir(cwd);
+
+  const userAgents = loadAgentsFromDir(userDir, "user");
+  const projectAgents = projectDir ? loadAgentsFromDir(projectDir, "project") : [];
+
+  return {
+    user: userAgents,
+    project: projectAgents,
+    userDir,
+    projectDir,
+  };
+}
+
 /**
  * Look up an agent config by name.
  */

package/src/compact.ts

@@ -7,46 +7,61 @@ type RenderContext = { state: Record<string, unknown>; invalidate: () => void };
 
 // ── Activity line builder ───────────────────────────────────────────────────
 
+interface ActivityData {
+  currentTool: string | undefined;
+  currentToolArgs: string | undefined;
+  currentToolStartedAt: number | undefined;
+  finalOutput: string | undefined;
+  status: "running" | "completed" | "failed" | undefined;
+  error: string | undefined;
+  toolCalls?: string[] | undefined;
+}
+
 export function buildActivityLine(
-  progress: {
-    currentTool: string | undefined;
-    currentToolArgs: string | undefined;
-    currentToolStartedAt: number | undefined;
-    finalOutput: string | undefined;
-    status: "running" | "completed" | "failed" | undefined;
-    error: string | undefined;
-  },
+  data: ActivityData,
   theme: Theme,
 ): string {
-  const prefix = theme.fg("dim", "  ⎿  ");
-
-  if (progress.error) {
-    return prefix + theme.fg("error", truncLine(progress.error, 80));
+  if (data.error) {
+    return theme.fg("error", "✗ " + truncLine(data.error, 80));
   }
 
-  if (progress.currentTool) {
-    const argsPreview = progress.currentToolArgs
-      ? truncLine(progress.currentToolArgs ?? "", 60)
+  if (data.currentTool) {
+    const arrow = theme.fg("muted", "↳ ");
+    const argsPreview = data.currentToolArgs
+      ? truncLine(data.currentToolArgs ?? "", 60)
       : "";
-    const durationPart = progress.currentToolStartedAt
-      ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
+    const durationPart = data.currentToolStartedAt
+      ? " | " + formatDuration(Date.now() - data.currentToolStartedAt)
       : "";
-    let line = theme.fg("syntaxFunction", progress.currentTool);
+    let line = theme.fg("syntaxFunction", data.currentTool);
     if (argsPreview) {
       line += theme.fg("dim", ": " + argsPreview);
     }
     if (durationPart) {
       line += theme.fg("dim", durationPart);
     }
-    return prefix + line;
+    return arrow + line;
+  }
+
+  // Show last completed tool call from history
+  if (data.toolCalls && data.toolCalls.length > 0) {
+    const lastCall = data.toolCalls[data.toolCalls.length - 1];
+    if (lastCall) return theme.fg("muted", "↳ " + lastCall);
+  }
+
+  if (data.finalOutput) {
+    const firstLine = data.finalOutput.split("\n")[0] ?? "";
+    return theme.fg("muted", "↳ " + truncLine(firstLine, 80));
   }
 
-  if (progress.finalOutput) {
-    const firstLine = progress.finalOutput.split("\n")[0] ?? "";
-    return prefix + truncLine(firstLine, 80);
+  // Running with no tool info yet
+  if (data.status === "running") {
+    return theme.fg("muted", "↳ Starting...");
   }
 
-  return "";
+  return data.status === "completed"
+    ? theme.fg("success", "✓ Done")
+    : theme.fg("error", "✗ Failed");
 }
 
 // ── Status glyph ────────────────────────────────────────────────────────────
@@ -90,40 +105,18 @@ export function renderCompactSingle(
   };
   const statsLine = buildStatsLine(statsData, theme);
 
-  const statsPart = statsLine ?? "";
+  const statsPart = statsLine;
 
   // Activity: arrow + current tool if running, status if finished
-  let activityLine: string;
-  if (isRunning) {
-    const arrow = theme.fg("muted", "↳ ");
-    if (progress?.currentTool) {
-      const argsPreview = progress.currentToolArgs
-        ? truncLine(progress.currentToolArgs ?? "", 60)
-        : "";
-      const durationPart = progress.currentToolStartedAt
-        ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
-        : "";
-      let line = theme.fg("syntaxFunction", progress.currentTool);
-      if (argsPreview) {
-        line += theme.fg("dim", ": " + argsPreview);
-      }
-      if (durationPart) {
-        line += theme.fg("dim", durationPart);
-      }
-      activityLine = arrow + line;
-    } else if (progress?.toolCalls && progress.toolCalls.length > 0) {
-      const lastCall = progress.toolCalls[progress.toolCalls.length - 1];
-      activityLine = theme.fg("dim", "  ⎿  ") + theme.fg("muted", lastCall ?? "");
-    } else {
-      activityLine = theme.fg("muted", "  ⎿  Working...");
-    }
-  } else if (result.error) {
-    activityLine = theme.fg("error", "✗ " + truncLine(result.error, 80));
-  } else if (status === "completed") {
-    activityLine = theme.fg("success", "✓ Done");
-  } else {
-    activityLine = theme.fg("error", "✗ Failed");
-  }
+  const activityLine = buildActivityLine({
+    currentTool: progress?.currentTool,
+    currentToolArgs: progress?.currentToolArgs,
+    currentToolStartedAt: progress?.currentToolStartedAt,
+    finalOutput: result.finalOutput,
+    status: isRunning ? "running" : status,
+    error: result.error,
+    toolCalls: progress?.toolCalls,
+  }, theme);
 
   const modelName = progress?.model ?? result.model;
   const modelLabel = modelName
@@ -176,6 +169,7 @@ export function renderCompactParallel(
       finalOutput: result.finalOutput,
       status,
       error: result.error,
+      toolCalls: progress?.toolCalls,
     };
     const activityLine = buildActivityLine(activityData, theme);
 
@@ -228,42 +222,20 @@ export function renderCompactProgress(
   const statsLine = buildStatsLine(statsData, theme);
 
   // Activity: arrow + current tool if running, status if finished
-  let activityLine: string;
-  if (isRunning) {
-    const arrow = theme.fg("muted", "↳ ");
-    if (progress.currentTool) {
-      const argsPreview = progress.currentToolArgs
-        ? truncLine(progress.currentToolArgs ?? "", 60)
-        : "";
-      const durationPart = progress.currentToolStartedAt
-        ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
-        : "";
-      let line = theme.fg("syntaxFunction", progress.currentTool);
-      if (argsPreview) {
-        line += theme.fg("dim", ": " + argsPreview);
-      }
-      if (durationPart) {
-        line += theme.fg("dim", durationPart);
-      }
-      activityLine = arrow + line;
-    } else if (progress.toolCalls && progress.toolCalls.length > 0) {
-      const lastCall = progress.toolCalls[progress.toolCalls.length - 1];
-      activityLine = arrow + theme.fg("muted", lastCall ?? "");
-    } else {
-      activityLine = arrow + theme.fg("muted", "Working...");
-    }
-  } else if (progress.error) {
-    activityLine = theme.fg("error", "✗ " + truncLine(progress.error, 80));
-  } else if (status === "completed") {
-    activityLine = theme.fg("success", "✓ Done");
-  } else {
-    activityLine = theme.fg("error", "✗ Failed");
-  }
+  const activityLine = buildActivityLine({
+    currentTool: progress.currentTool,
+    currentToolArgs: progress.currentToolArgs,
+    currentToolStartedAt: progress.currentToolStartedAt,
+    finalOutput: undefined,
+    status,
+    error: progress.error,
+    toolCalls: progress.toolCalls,
+  }, theme);
 
   const modelLabel = progress.model
     ? theme.fg("accent", progress.model)
     : "";
-  const statsPart = statsLine ?? "";
+  const statsPart = statsLine;
   const expandHint = theme.fg("muted", "(ctrl+o)");
   let output = [modelLabel, statsPart, expandHint].filter(Boolean).join(" ");
   output += "\n" + activityLine;
@@ -309,6 +281,7 @@ export function renderCompactParallelProgress(
       finalOutput: undefined,
       status,
       error: progress.error,
+      toolCalls: progress.toolCalls,
     };
     const activityLine = buildActivityLine(activityData, theme);
 

package/src/execute.ts

@@ -21,20 +21,20 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
   const agentName = options.agent ?? "subagent";
   const startTime = Date.now();
 
-  const child = spawnSubagent({
-    task: options.task,
-    model: options.model,
-    cwd: options.cwd,
-    signal: options.signal,
-    agent: options.agentConfig,
-  });
-
   // Track previously emitted values to only emit deltas
   let lastEmittedInput = 0;
   let lastEmittedOutput = 0;
   let lastEmittedCost = 0;
 
   try {
+    const child = spawnSubagent({
+      task: options.task,
+      model: options.model,
+      cwd: options.cwd,
+      signal: options.signal,
+      agent: options.agentConfig,
+    });
+
     const result = await streamEvents(child, {
       agent: agentName,
       task: options.task,

package/src/frontmatter-io.ts

@@ -0,0 +1,103 @@
+/**
+ * Frontmatter serialization and validation for agent config files.
+ */
+
+import type { AgentConfig } from "./agents.js";
+
+/**
+ * Regex for valid agentspec names: lowercase alphanumeric + hyphens, 3-50 chars.
+ * Alphanumeric start/end. Also allows single-char names.
+ */
+export const AGENT_NAME_REGEX = /^[a-z0-9][a-z0-9-]{1,48}[a-z0-9]$/;
+
+const SINGLE_CHAR_NAME_REGEX = /^[a-z0-9]$/;
+
+/**
+ * Validate an agent name against agentspec format rules.
+ * Returns an error message string if invalid, null if valid.
+ */
+export function validateAgentName(name: string): string | null {
+  if (!name || name.length === 0) {
+    return "Name is required";
+  }
+  if (SINGLE_CHAR_NAME_REGEX.test(name)) {
+    return null;
+  }
+  if (AGENT_NAME_REGEX.test(name)) {
+    return null;
+  }
+  return "Name must be 3-50 lowercase alphanumeric characters or hyphens, starting and ending with alphanumeric";
+}
+
+function needsYamlQuoting(value: string): boolean {
+  if (value === "") return true;
+  // Special YAML characters at start
+  if (/^["'#\{\[\|>&!*%?@`-]/.test(value)) return true;
+  // Contains colon (could be mistaken for mapping)
+  if (value.includes(":")) return true;
+  // Contains # (inline comment marker) anywhere
+  if (value.includes("#")) return true;
+  // Contains newline
+  if (value.includes("\n")) return true;
+  // Leading/trailing whitespace
+  if (value !== value.trim()) return true;
+  // YAML booleans/nulls
+  if (/^(true|false|yes|no|on|off|null|True|False|Yes|No|On|Off|NULL|Null)$/i.test(value)) return true;
+  return false;
+}
+
+function quoteYamlValue(value: string): string {
+  if (!needsYamlQuoting(value)) return value;
+  // Escape backslashes and double quotes, wrap in double quotes
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+
+/**
+ * Serialize an AgentConfig back to a valid .md file with frontmatter.
+ * Produces output that parseFrontmatter can re-parse faithfully.
+ */
+export function serializeAgent(config: AgentConfig): string {
+  const lines: string[] = ["---"];
+
+  // Required fields
+  lines.push(`name: ${quoteYamlValue(config.name)}`);
+  lines.push(`description: ${quoteYamlValue(config.description)}`);
+
+  // Optional known fields
+  if (config.tools && config.tools.length > 0) {
+    lines.push(`tools: ${quoteYamlValue(config.tools.join(", "))}`);
+  }
+  if (config.model) {
+    lines.push(`model: ${quoteYamlValue(config.model)}`);
+  }
+  if (config.thinking) {
+    lines.push(`thinking: ${quoteYamlValue(config.thinking)}`);
+  }
+
+  // Extra fields (sorted alphabetically)
+  if (config.extraFields) {
+    for (const key of Object.keys(config.extraFields).sort()) {
+      const value = config.extraFields[key]!;
+      if (typeof value === "string") {
+        lines.push(`${key}: ${quoteYamlValue(value)}`);
+      } else if (Array.isArray(value)) {
+        // Serialize array as YAML block sequence
+        lines.push(`${key}:`);
+        for (const item of value) {
+          lines.push(`  - ${quoteYamlValue(String(item))}`);
+        }
+      } else {
+        // Fallback: JSON stringify for objects
+        lines.push(`${key}: ${JSON.stringify(value)}`);
+      }
+    }
+  }
+
+  lines.push("---");
+  lines.push("");
+  lines.push(config.systemPrompt);
+  lines.push("");
+
+  return lines.join("\n");
+}

package/src/handlers.ts

@@ -19,11 +19,14 @@ export function extractArgsPreview(args: unknown): string {
   if (args && typeof args === "object" && !Array.isArray(args)) {
     const obj = args as Record<string, unknown>;
     const keys = Object.keys(obj);
-    // Single-key object: just show the value
+    // Single-key object: show the value directly (or serialize if complex)
     if (keys.length === 1) {
       const v = obj[keys[0]!];
       if (typeof v === "string") return v.slice(0, ARGS_PREVIEW_MAX);
       if (typeof v === "number" || typeof v === "boolean") return String(v);
+      // Complex value (array/nested object) — serialize just this value
+      const serialized = JSON.stringify(v);
+      if (serialized) return serialized.slice(0, ARGS_PREVIEW_MAX);
     }
     // Multi-key: find the longest string value (likely the main payload)
     let best: string | undefined;
@@ -104,7 +107,7 @@ export function handleMessageEnd(state: StreamState, event: JsonEvent): void {
     state.model = message.model as string;
   }
 
-  // Collect text output
+  // Collect text + thinking output
   const content = message.content as Array<Record<string, unknown>> | string | undefined;
   if (typeof content === "string" && content.trim()) {
     state.accumulatedOutput.push(content);
@@ -117,6 +120,11 @@ export function handleMessageEnd(state: StreamState, event: JsonEvent): void {
         state.accumulatedOutput.push(text);
         const lines = text.split("\n").filter((l) => l.trim());
         state.recentOutput.push(...lines.slice(-10));
+      } else if (part.type === "thinking" && (part.thinking as string)?.trim()) {
+        const thinking = part.thinking as string;
+        state.accumulatedOutput.push(`[thinking] ${thinking.trim()}`);
+        const lines = thinking.split("\n").filter((l) => l.trim());
+        state.recentOutput.push(...lines.slice(-5).map((l) => `[thinking] ${l}`));
       }
     }
   }
@@ -139,26 +147,28 @@ export function handleMessageEnd(state: StreamState, event: JsonEvent): void {
 }
 
 /**
- * Handle an agent_end event — collect all assistant text for final output.
+ * Handle an agent_end event — extract final output from the last assistant message.
  */
 export function handleAgentEnd(state: StreamState, event: JsonEvent): void {
   const messages = event.messages as Array<Record<string, unknown>> | undefined;
   if (!messages || messages.length === 0) return;
 
+  // Use only the last assistant message for final output
+  const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+  if (!lastAssistant) return;
+
   const allText: string[] = [];
-  for (const msg of messages) {
-    if (msg.role === "assistant") {
-      const content = msg.content as Array<Record<string, unknown>> | string | undefined;
-      if (typeof content === "string" && content.trim()) {
-        allText.push(content);
-      } else if (Array.isArray(content)) {
-        for (const part of content) {
-          if (part.type === "text" && (part.text as string)?.trim()) {
-            allText.push(part.text as string);
-          }
-        }
+  const content = lastAssistant.content as Array<Record<string, unknown>> | string | undefined;
+  if (typeof content === "string" && content.trim()) {
+    allText.push(content);
+  } else if (Array.isArray(content)) {
+    for (const part of content) {
+      if (part.type === "text" && (part.text as string)?.trim()) {
+        allText.push(part.text as string);
+      } else if (part.type === "thinking" && (part.thinking as string)?.trim()) {
+        allText.push(`[thinking] ${(part.thinking as string).trim()}`);
       }
     }
   }
-  state.finalOutput = allText.join("\n\n");
+  state.finalOutput = allText.length > 0 ? allText.join("\n\n") : undefined;
 }

package/src/index.ts

@@ -1,9 +1,10 @@
-import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { Text, TUI } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { executeSubagent, executeParallel } from "./execute.js";
 import { renderSubagentResult } from "./render.js";
-import { discoverAgents, findAgent } from "./agents.js";
+import { discoverAgents, discoverAgentsAll, findAgent } from "./agents.js";
+import { createAgentManager } from "./agent-manager.js";
 import type {
   SubagentDetails,
   SubagentProgress,
@@ -96,7 +97,9 @@ export function registerSubagent(pi: ExtensionAPI): void {
             agent: t.agent ?? undefined,
             agentConfig: t.agent ? findAgent(agents, t.agent) : undefined,
             task: t.task,
-            model: t.model ?? undefined,
+            // Fall back to the parent's currently-selected model when the caller
+            // (and the agent frontmatter) didn't specify one.
+            model: t.model ?? ctx.model?.id,
             cwd: t.cwd ?? undefined,
           })),
           signal: signal ?? undefined,
@@ -141,7 +144,9 @@ export function registerSubagent(pi: ExtensionAPI): void {
           agent: params.agent ?? undefined,
           agentConfig,
           task: params.task,
-          model: params.model ?? undefined,
+          // Fall back to the parent's currently-selected model when the caller
+          // (and the agent frontmatter) didn't specify one.
+          model: params.model ?? ctx.model?.id,
           cwd: params.cwd ?? undefined,
           signal: signal ?? undefined,
           onUpdate: (progress: SubagentProgress) => {
@@ -255,6 +260,35 @@ function formatResultsSummary(results: SubagentResult[]): string {
   return lines.join("\n");
 }
 
+// ── Command registration ────────────────────────────────────────────────────
+
+export function registerAgentsCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("agents", {
+    description: "Open the Agents Manager",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      const { user, project, userDir, projectDir } = discoverAgentsAll(ctx.cwd);
+
+      const availableModels = ctx.modelRegistry.getAvailable().map((m) => ({
+        id: m.id,
+        provider: m.provider,
+        fullId: `${m.provider}/${m.id}`,
+      }));
+
+      const availableTools = pi.getAllTools().map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+      }));
+
+      await ctx.ui.custom<void>(
+        (tui: TUI, theme: Theme, _keybindings, done: () => void) => {
+          return createAgentManager(user, project, userDir, projectDir, tui, theme, done, availableModels, availableTools);
+        },
+        { overlay: true, overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" } },
+      );
+    },
+  });
+}
+
 // ── Default export ──────────────────────────────────────────────────────────
 
 export default function (pi: ExtensionAPI): void {

package/src/spawn.ts

@@ -1,10 +1,21 @@
 import { spawn, type ChildProcess } from "node:child_process";
 import { execSync } from "node:child_process";
-import { existsSync, writeFileSync, unlinkSync, mkdtempSync, rmdirSync } from "node:fs";
+import { existsSync, writeFileSync, unlinkSync, mkdtempSync, rmdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { AgentConfig } from "./agents.js";
 
+// Track all temp dirs for cleanup on process exit (graceful shutdown only).
+// Note: SIGKILL/OOM cannot be caught — the exit handler only fires for
+// normal exits and catchable signals (SIGTERM, SIGINT, SIGHUP, etc.).
+const tempDirs = new Set<string>();
+
+process.on("exit", () => {
+  for (const dir of tempDirs) {
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+  }
+});
+
 export interface SpawnOptions {
   task: string;
   model: string | undefined;
@@ -42,6 +53,7 @@ export function resolvePiCommand(): { command: string; args: string[] } {
 function writePromptToFile(agentName: string, prompt: string): { dir: string; filePath: string } {
   const safeName = agentName.replace(/[^\w.-]+/g, "_");
   const tmpDir = mkdtempSync(join(tmpdir(), "pi-subagent-"));
+  tempDirs.add(tmpDir);
   const filePath = join(tmpDir, `prompt-${safeName}.md`);
   writeFileSync(filePath, prompt, { encoding: "utf-8" });
   return { dir: tmpDir, filePath };
@@ -55,7 +67,10 @@ function cleanupTempFiles(dir: string | null, filePath: string | null): void {
     try { unlinkSync(filePath); } catch { /* ignore */ }
   }
   if (dir) {
-    try { rmdirSync(dir); } catch { /* ignore */ }
+    try {
+      rmdirSync(dir);
+      tempDirs.delete(dir);
+    } catch { /* leave in Set so exit handler can retry with rmSync */ }
   }
 }
 
@@ -86,7 +101,8 @@ export function spawnSubagent(options: SpawnOptions): ChildProcess {
       args.push("--tools", agent.tools.join(","));
     }
   } else if (options.model) {
-    // Fallback: use model from tool call params (legacy)
+    // Fallback: tool-call model (which itself falls back to the parent's
+    // currently-selected model via ctx.model?.id at the call site).
     args.push("--model", options.model);
   }