killeros 1.5.4 → 1.5.6

package/killeros/subagents.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { closeSync, openSync, readSync, readdirSync, statSync } from "node:fs";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -19,7 +19,7 @@ import { SubagentThreadRegistry, type SubagentThread, type SubagentThreadId, typ
 import { MAX_NODE_TIMER_MS, runSubagentProcess, type SubagentProcessHandle, type SubagentProcessResult } from "./subagent-process.ts";
 import { formatThreadBoard, formatThreadInspection, type ThreadRecord as ThreadBoardRecord } from "./subagent-ui.ts";
 
-export const SUBAGENT_LIMITS = {
+export const SUBAGENT_LIMITS = {
   maxTasks: 10,
   maxReadConcurrency: 4,
   toolOutputBytes: 50 * 1024,
@@ -29,11 +29,11 @@ export const SUBAGENT_LIMITS = {
   threadRetentionRecords: 64,
   threadRetentionBytes: 128 * 1024 * 1024,
   roleFileBytes: 64 * 1024,
-  taskCharacters: 20_000,
-  killGraceMs: 5_000,
-  defaultWallTimeMs: 1_800_000,
-  processExitWaitMs: 10_000,
-} as const;
+  taskCharacters: 20_000,
+  killGraceMs: 5_000,
+  defaultWallTimeMs: 1_800_000,
+  processExitWaitMs: 10_000,
+} as const;
 
 const WEB_TOOLS = new Set(["web_search", "source_check", "fetch_content", "get_search_content"]);
 const READ_TOOLS = new Set(["read", "grep", "find", "ls", ...WEB_TOOLS]);
@@ -46,9 +46,9 @@ const ROLE_FIELDS = new Set(["name", "description", "access", "tools", "model",
 
 type ThinkingLevel = ModelThinkingLevel;
 export type AgentAccess = "read" | "write";
-export type AgentSource = "bundled" | "personal" | "project";
+export type AgentSource = "bundled" | "personal" | "project" | "inline";
 export type AgentScope = "user" | "project" | "both";
-export type SubagentStatus = "queued" | "running" | "complete" | "failed" | "cancelled" | "limited" | "orphaned";
+export type SubagentStatus = "queued" | "running" | "complete" | "failed" | "cancelled" | "limited" | "orphaned";
 
 export interface AgentRole {
   name: string;
@@ -63,6 +63,15 @@ export interface AgentRole {
   filePath: string;
 }
 
+export interface InlineAgentRole {
+  name: string;
+  description: string;
+  access: AgentAccess;
+  tools: string[];
+}
+
+export type AgentSpec = string | InlineAgentRole;
+
 export interface AgentDiscoveryResult {
   agents: AgentRole[];
   projectAgentsDir: string | null;
@@ -84,10 +93,10 @@ export interface SubagentUsage {
   turns: number;
 }
 
-export interface SubagentTaskResult {
-  id: string;
-  name?: string;
-  attempt: number;
+export interface SubagentTaskResult {
+  id: string;
+  name?: string;
+  attempt: number;
   agent: string;
   agentSource: AgentSource | "unknown";
   sourcePath?: string;
@@ -109,14 +118,14 @@ export interface SubagentTaskResult {
   toolCallCount: number;
   usage: SubagentUsage;
   durationMs: number;
-  exitCode: number | null;
-  exitConfirmed: boolean;
-  terminationReason?: string;
+  exitCode: number | null;
+  exitConfirmed: boolean;
+  terminationReason?: string;
   errorMessage?: string;
   step?: number;
 }
 
-export interface SubagentDetails {
+export interface SubagentDetails {
   mode: "single" | "parallel" | "chain";
   agentScope: AgentScope;
   projectAgentsDir: string | null;
@@ -127,38 +136,38 @@ export interface SubagentDetails {
   threads?: SubagentThread[];
   activeThreads?: SubagentThread[];
   doneThreads?: SubagentThread[];
-  selectedThreadId?: string;
-  wait?: SubagentWaitSummary;
-}
-
-export interface SubagentWaitSummary {
-  targetThreadIds: string[];
-  completedThreadIds: string[];
-  pendingThreadIds: string[];
-  timedOut: boolean;
-  waitedMs: number;
-}
-
-export interface SubagentControlRequest {
-  action: "list" | "inspect" | "wait" | "steer" | "interrupt" | "collect" | "resume" | "close";
-  threadId?: string;
-  all?: true;
-  message?: string;
-  task?: string;
-  timeoutMs?: number;
-}
-
-export interface SubagentControlResult {
-  text: string;
-  details: SubagentDetails;
-  usage: SubagentUsage;
-}
-
-export interface SubagentControlApi {
-  execute(request: SubagentControlRequest, ctx: ExtensionContext): Promise<SubagentControlResult>;
-}
-
-export const SUBAGENT_PERSISTENCE_TYPE = "killeros-subagent-v1";
+  selectedThreadId?: string;
+  wait?: SubagentWaitSummary;
+}
+
+export interface SubagentWaitSummary {
+  targetThreadIds: string[];
+  completedThreadIds: string[];
+  pendingThreadIds: string[];
+  timedOut: boolean;
+  waitedMs: number;
+}
+
+export interface SubagentControlRequest {
+  action: "list" | "inspect" | "wait" | "steer" | "interrupt" | "collect" | "resume" | "close";
+  threadId?: string;
+  all?: true;
+  message?: string;
+  task?: string;
+  timeoutMs?: number;
+}
+
+export interface SubagentControlResult {
+  text: string;
+  details: SubagentDetails;
+  usage: SubagentUsage;
+}
+
+export interface SubagentControlApi {
+  execute(request: SubagentControlRequest, ctx: ExtensionContext): Promise<SubagentControlResult>;
+}
+
+export const SUBAGENT_PERSISTENCE_TYPE = "killeros-subagent-v1";
 
 interface ModelContext {
   model?: Model<any>;
@@ -183,7 +192,7 @@ interface SpawnedProcess {
   once(event: "close", listener: (code: number | null) => void): this;
 }
 
-type SubagentLimits = { [Key in keyof typeof SUBAGENT_LIMITS]: number } & {
+type SubagentLimits = { [Key in keyof typeof SUBAGENT_LIMITS]: number } & {
   wallTimeMs?: number;
   jsonlLineBytes?: number;
   traceBytes?: number;
@@ -193,7 +202,7 @@ type SubagentLimits = { [Key in keyof typeof SUBAGENT_LIMITS]: number } & {
   quotaUsd?: number;
 };
 
-export interface SubagentRuntimeOptions {
+export interface SubagentRuntimeOptions {
   bundledAgentsDir?: string;
   userAgentsDir?: string;
   webExtension?: string;
@@ -520,11 +529,11 @@ function truncateUtf8(text: string, maxBytes: number): { text: string; omittedBy
   return { text: truncated, omittedBytes: bytes.length - Buffer.byteLength(truncated, "utf8") };
 }
 
-function makeQueuedResult(id: string, agent: string, task: string, step?: number, name?: string, attempt = 1): SubagentTaskResult {
-  return {
-    id,
-    name,
-    attempt,
+function makeQueuedResult(id: string, agent: string, task: string, step?: number, name?: string, attempt = 1): SubagentTaskResult {
+  return {
+    id,
+    name,
+    attempt,
     agent,
     agentSource: "unknown",
     task,
@@ -541,12 +550,12 @@ function makeQueuedResult(id: string, agent: string, task: string, step?: number
     outputTruncatedBytes: 0,
     toolCallCount: 0,
     usage: emptyUsage(),
-    durationMs: 0,
-    exitCode: null,
-    exitConfirmed: false,
-    step,
-  };
-}
+    durationMs: 0,
+    exitCode: null,
+    exitConfirmed: false,
+    step,
+  };
+}
 
 function cloneResult(result: SubagentTaskResult): SubagentTaskResult {
   return {
@@ -606,13 +615,13 @@ async function writeRolePrompt(agent: AgentRole): Promise<{ directory: string; f
   return { directory, filePath };
 }
 
-interface RunTaskOptions {
+interface RunTaskOptions {
   cwd: string;
   agent: AgentRole;
   task: string;
-  id: string;
-  displayName: string;
-  attempt: number;
+  id: string;
+  displayName: string;
+  attempt: number;
   step?: number;
   model: ResolvedModel;
   signal?: AbortSignal;
@@ -620,8 +629,8 @@ interface RunTaskOptions {
   webExtension?: string;
   projectTrusted: boolean;
   limits: SubagentLimits;
-  sessionDirectory: string;
-  sessionId: string;
+  sessionDirectory: string;
+  sessionId: string;
   timeoutMs?: number;
   onChange: (result: SubagentTaskResult) => void;
   onHandle?: (handle: SubagentProcessHandle) => void;
@@ -647,16 +656,16 @@ function applyProcessResult(
   target.usage = { ...source.usage, cost: { ...source.usage.cost } };
   target.model = source.model ?? target.model;
   target.terminationReason = source.terminationReason;
-  target.errorMessage = source.errorMessage;
-  target.exitCode = source.exitCode;
-  target.exitConfirmed = source.exitConfirmed;
-  target.durationMs = source.durationMs || Date.now() - startedAt;
+  target.errorMessage = source.errorMessage;
+  target.exitCode = source.exitCode;
+  target.exitConfirmed = source.exitConfirmed;
+  target.durationMs = source.durationMs || Date.now() - startedAt;
   onChange(target);
 }
 
-async function runTask(options: RunTaskOptions): Promise<SubagentTaskResult> {
-  const { agent, limits } = options;
-  const result = makeQueuedResult(options.id, agent.name, options.task, options.step, options.displayName, options.attempt);
+async function runTask(options: RunTaskOptions): Promise<SubagentTaskResult> {
+  const { agent, limits } = options;
+  const result = makeQueuedResult(options.id, agent.name, options.task, options.step, options.displayName, options.attempt);
   result.agentSource = agent.source;
   result.sourcePath = agent.filePath;
   result.access = agent.access;
@@ -696,10 +705,10 @@ async function runTask(options: RunTaskOptions): Promise<SubagentTaskResult> {
     const args = [
       "--mode", "json",
       "-p",
-      "--session-dir", options.sessionDirectory,
-      "--session-id", options.sessionId,
-      "--name", options.displayName,
-      "--no-extensions",
+      "--session-dir", options.sessionDirectory,
+      "--session-id", options.sessionId,
+      "--name", options.displayName,
+      "--no-extensions",
       "--extension", options.webExtension ?? SUBAGENT_WEB_EXTENSION,
       "--no-prompt-templates",
       options.projectTrusted ? "--approve" : "--no-approve",
@@ -721,9 +730,9 @@ async function runTask(options: RunTaskOptions): Promise<SubagentTaskResult> {
         ...(limits.stderrBytes === undefined ? {} : { stderrBytes: limits.stderrBytes }),
         ...(limits.taskOutputBytes === undefined ? {} : { outputBytes: limits.taskOutputBytes }),
         ...(limits.quotaTokens === undefined ? {} : { quotaTokens: limits.quotaTokens }),
-        ...(limits.quotaUsd === undefined ? {} : { quotaUsd: limits.quotaUsd }),
-        killGraceMs: limits.killGraceMs,
-        processExitWaitMs: limits.processExitWaitMs,
+        ...(limits.quotaUsd === undefined ? {} : { quotaUsd: limits.quotaUsd }),
+        killGraceMs: limits.killGraceMs,
+        processExitWaitMs: limits.processExitWaitMs,
       },
       retention: {
         traceBytes: limits.traceRetentionBytes,
@@ -767,7 +776,7 @@ async function mapReadTasks<T>(items: T[], concurrency: number, run: (item: T, i
   await Promise.all(workers);
 }
 
-function waitForConfirmedProcessExit(handle: SubagentProcessHandle, timeoutMs = 1_000): Promise<boolean> {
+function waitForConfirmedProcessExit(handle: SubagentProcessHandle, timeoutMs = 1_000): Promise<boolean> {
   if (handle.hasExited) return Promise.resolve(true);
   return new Promise((resolve) => {
     let settled = false;
@@ -783,17 +792,17 @@ function waitForConfirmedProcessExit(handle: SubagentProcessHandle, timeoutMs =
   });
 }
 
-const SUBAGENT_ACTION = {
-  spawn: "spawn",
-  list: "list",
-  inspect: "inspect",
-  steer: "steer",
-  interrupt: "interrupt",
-  collect: "collect",
-  wait: "wait",
-  resume: "resume",
-  close: "close",
-} as const;
+const SUBAGENT_ACTION = {
+  spawn: "spawn",
+  list: "list",
+  inspect: "inspect",
+  steer: "steer",
+  interrupt: "interrupt",
+  collect: "collect",
+  wait: "wait",
+  resume: "resume",
+  close: "close",
+} as const;
 type SubagentAction = typeof SUBAGENT_ACTION[keyof typeof SUBAGENT_ACTION];
 
 type SpawnOptions = {
@@ -802,12 +811,12 @@ type SpawnOptions = {
   agentScope?: AgentScope;
 };
 
-type SpawnSingleRequest = SpawnOptions & {
-  action?: "spawn";
-  agent: string;
-  task: string;
-  name?: string;
-};
+type SpawnSingleRequest = SpawnOptions & {
+  action?: "spawn";
+  agent: AgentSpec;
+  task: string;
+  name?: string;
+};
 
 type SpawnParallelRequest = SpawnOptions & {
   action?: "spawn";
@@ -828,37 +837,37 @@ export type NormalizedSubagentRequest =
   | { kind: "inspect"; input: { action: "inspect"; threadId: string } }
   | { kind: "steer"; input: { action: "steer"; threadId: string; message: string } }
   | { kind: "interrupt-one"; input: { action: "interrupt"; threadId: string } }
-  | { kind: "interrupt-all"; input: { action: "interrupt"; all: true } }
-  | { kind: "collect"; input: { action: "collect"; threadId: string } }
-  | { kind: "wait"; input: { action: "wait"; threadId?: string; all?: true; timeoutMs: number } }
-  | { kind: "resume"; input: { action: "resume"; threadId: string; task?: string } }
-  | { kind: "close"; input: { action: "close"; threadId: string } };
+  | { kind: "interrupt-all"; input: { action: "interrupt"; all: true } }
+  | { kind: "collect"; input: { action: "collect"; threadId: string } }
+  | { kind: "wait"; input: { action: "wait"; threadId?: string; all?: true; timeoutMs: number } }
+  | { kind: "resume"; input: { action: "resume"; threadId: string; task?: string } }
+  | { kind: "close"; input: { action: "close"; threadId: string } };
 
 type SubagentRequestParse =
   | { ok: true; request: NormalizedSubagentRequest }
   | { ok: false; message: string };
 
-const SUBAGENT_ACTIONS = Object.values(SUBAGENT_ACTION);
-const SPAWN_OPTION_FIELDS = ["model", "thinking", "agentScope"] as const;
-const THREAD_NAME_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._ -]{0,47}$";
-const THREAD_NAME_RE = new RegExp(THREAD_NAME_PATTERN, "u");
-const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
-const MAX_WAIT_TIMEOUT_MS = 3_600_000;
-
-export function validateThreadName(name: string): void {
-  if (!name.trim()) throw new Error("Invalid subagent request: name must be a non-empty string.");
-  if ([...name].length > 48 || !THREAD_NAME_RE.test(name)) {
-    throw new Error(`Invalid subagent request: name must match ${THREAD_NAME_PATTERN}.`);
-  }
-}
-
-function optionalThreadName(record: Record<string, unknown>): string | undefined {
-  if (!Object.hasOwn(record, "name")) return undefined;
-  const value = record.name;
-  if (typeof value !== "string") throw new Error("Invalid subagent request: name must be a non-empty string.");
-  validateThreadName(value);
-  return value;
-}
+const SUBAGENT_ACTIONS = Object.values(SUBAGENT_ACTION);
+const SPAWN_OPTION_FIELDS = ["model", "thinking", "agentScope"] as const;
+const THREAD_NAME_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._ -]{0,47}$";
+const THREAD_NAME_RE = new RegExp(THREAD_NAME_PATTERN, "u");
+const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
+const MAX_WAIT_TIMEOUT_MS = 3_600_000;
+
+export function validateThreadName(name: string): void {
+  if (!name.trim()) throw new Error("Invalid subagent request: name must be a non-empty string.");
+  if ([...name].length > 48 || !THREAD_NAME_RE.test(name)) {
+    throw new Error(`Invalid subagent request: name must match ${THREAD_NAME_PATTERN}.`);
+  }
+}
+
+function optionalThreadName(record: Record<string, unknown>): string | undefined {
+  if (!Object.hasOwn(record, "name")) return undefined;
+  const value = record.name;
+  if (typeof value !== "string") throw new Error("Invalid subagent request: name must be a non-empty string.");
+  validateThreadName(value);
+  return value;
+}
 
 function requireRecord(value: unknown, name: string): Record<string, unknown> {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
@@ -891,21 +900,73 @@ function requireOnlyFields(record: Record<string, unknown>, allowed: readonly st
   if (invalid) throw new Error(`Invalid subagent request: field ${JSON.stringify(invalid)} is not valid with action ${JSON.stringify(action)}.`);
 }
 
+function parseAgentSpec(value: unknown): AgentSpec {
+  if (typeof value === "string") {
+    if (!value.length) throw new Error("Invalid subagent request: agent must be a non-empty string or inline role.");
+    if ([...value].length > 64) throw new Error("Invalid subagent request: agent must be no longer than 64 characters.");
+    return value;
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid subagent request: agent must be a non-empty string or inline role.");
+  }
+  const role = requireRecord(value, "inline role");
+  for (const field of Object.keys(role)) {
+    if (!["name", "description", "access", "tools"].includes(field)) {
+      throw new AgentConfigurationError("inline role", field, "unknown role field");
+    }
+  }
+  const name = requiredString(role, "inline role", "name");
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/u.test(name)) {
+    throw new AgentConfigurationError("inline role", "name", "must use 1-64 letters, numbers, dots, underscores, or hyphens");
+  }
+  const description = requiredString(role, "inline role", "description");
+  if (description.length > 500) throw new AgentConfigurationError("inline role", "description", "must not exceed 500 characters");
+  const access = requiredString(role, "inline role", "access");
+  if (access !== "read" && access !== "write") {
+    throw new AgentConfigurationError("inline role", "access", 'must be "read" or "write"');
+  }
+  if (!Array.isArray(role.tools) || role.tools.length === 0) {
+    throw new AgentConfigurationError("inline role", "tools", "must contain at least one tool");
+  }
+  const tools = [...new Set(role.tools.map((tool) => {
+    if (typeof tool !== "string" || !tool.trim()) {
+      throw new AgentConfigurationError("inline role", "tools", "must contain non-empty tool names");
+    }
+    return tool.trim();
+  }))];
+  for (const tool of tools) {
+    if (!KNOWN_TOOLS.has(tool)) throw new AgentConfigurationError("inline role", "tools", `unknown child tool ${JSON.stringify(tool)}`);
+    if (access === "read" && WRITE_TOOLS.has(tool)) {
+      throw new AgentConfigurationError("inline role", "tools", `read-only roles cannot use ${tool}`);
+    }
+  }
+  return { name, description, access, tools };
+}
+
+function inlineAgentRole(role: InlineAgentRole): AgentRole {
+  return {
+    ...role,
+    prompt: role.description,
+    source: "inline",
+    filePath: `inline:${role.name}`,
+  };
+}
+
 function parseTaskInputs(value: unknown, field: "tasks" | "chain", limits: Pick<SubagentLimits, "maxTasks" | "taskCharacters">): TaskInput[] {
   if (!Array.isArray(value) || value.length === 0) {
     throw new Error(`Invalid subagent request: ${field} must be a non-empty array.`);
   }
   if (value.length > limits.maxTasks) throw new Error(`At most ${limits.maxTasks} subagent tasks are allowed`);
-  return value.map((entry, index) => {
-    const task = requireRecord(entry, `${field}[${index}]`);
-    requireOnlyFields(task, ["agent", "task", "name"], `spawn ${field}`);
-    const name = optionalThreadName(task);
-    return {
-      agent: requireTextField(task, "agent", 64),
-      task: requireTextField(task, "task", limits.taskCharacters),
-      ...(name === undefined ? {} : { name }),
-    };
-  });
+  return value.map((entry, index) => {
+    const task = requireRecord(entry, `${field}[${index}]`);
+    requireOnlyFields(task, ["agent", "task", "name"], `spawn ${field}`);
+    const name = optionalThreadName(task);
+    return {
+      agent: parseAgentSpec(task.agent),
+      task: requireTextField(task, "task", limits.taskCharacters),
+      ...(name === undefined ? {} : { name }),
+    };
+  });
 }
 
 function parseSpawnOptions(record: Record<string, unknown>): SpawnOptions {
@@ -929,12 +990,12 @@ export function normalizeSubagentRequest(
   const record = requireRecord(value, "subagent request");
   const action = record.action === undefined ? SUBAGENT_ACTION.spawn : requireAction(record.action);
 
-  if (action !== "steer" && Object.hasOwn(record, "message")) {
+  if (action !== "steer" && action !== "spawn" && Object.hasOwn(record, "message")) {
     throw new Error('Invalid subagent request: message is only valid with action "steer". Use {"action":"steer","threadId":"...","message":"..."}.');
   }
 
   if (action === "spawn") {
-    const hasSingle = Object.hasOwn(record, "agent") || Object.hasOwn(record, "task");
+    const hasSingle = Object.hasOwn(record, "agent") || Object.hasOwn(record, "task") || Object.hasOwn(record, "message");
     const hasParallel = Object.hasOwn(record, "tasks");
     const hasChain = Object.hasOwn(record, "chain");
     if (Number(hasSingle) + Number(hasParallel) + Number(hasChain) !== 1) {
@@ -945,18 +1006,21 @@ export function normalizeSubagentRequest(
     }
     const actionField = Object.hasOwn(record, "action") ? { action: "spawn" as const } : {};
     const options = parseSpawnOptions(record);
-    if (hasSingle) {
-      requireOnlyFields(record, ["action", "agent", "task", "name", ...SPAWN_OPTION_FIELDS], "spawn single");
-      const name = optionalThreadName(record);
-      return {
-        kind: "spawn-single",
-        input: {
-          ...actionField,
-          agent: requireTextField(record, "agent", 64),
-          task: requireTextField(record, "task", limits.taskCharacters),
-          ...(name === undefined ? {} : { name }),
-          ...options,
-        },
+    if (hasSingle) {
+      requireOnlyFields(record, ["action", "agent", "task", "message", "name", ...SPAWN_OPTION_FIELDS], "spawn single");
+      if (Object.hasOwn(record, "task") && Object.hasOwn(record, "message")) {
+        throw new Error("Invalid subagent request: spawn single cannot combine task with its message alias.");
+      }
+      const name = optionalThreadName(record);
+      return {
+        kind: "spawn-single",
+        input: {
+          ...actionField,
+          agent: parseAgentSpec(record.agent),
+          task: requireTextField(record, Object.hasOwn(record, "message") ? "message" : "task", limits.taskCharacters),
+          ...(name === undefined ? {} : { name }),
+          ...options,
+        },
       };
     }
     if (hasParallel) {
@@ -994,7 +1058,7 @@ export function normalizeSubagentRequest(
     const input = { action, threadId: requireTextField(record, "threadId", 128) };
     return { kind: action, input } as NormalizedSubagentRequest;
   }
-  if (action === "steer") {
+  if (action === "steer") {
     requireOnlyFields(record, ["action", "threadId", "message"], action);
     return {
       kind: "steer",
@@ -1004,43 +1068,43 @@ export function normalizeSubagentRequest(
         message: requireTextField(record, "message", 4_000),
       },
     };
-  }
-
-  if (action === "wait") {
-    requireOnlyFields(record, ["action", "threadId", "all", "timeoutMs"], action);
-    const hasThreadId = Object.hasOwn(record, "threadId");
-    const hasAll = Object.hasOwn(record, "all");
-    if (hasThreadId && hasAll || hasAll && record.all !== true) {
-      throw new Error('Invalid subagent request: action "wait" cannot combine threadId with all: true.');
-    }
-    const timeoutValue = record.timeoutMs === undefined ? DEFAULT_WAIT_TIMEOUT_MS : record.timeoutMs;
-    if (typeof timeoutValue !== "number" || !Number.isSafeInteger(timeoutValue) || timeoutValue <= 0 || timeoutValue > MAX_WAIT_TIMEOUT_MS) {
-      throw new Error(`Invalid subagent request: timeoutMs must be a positive integer no greater than ${MAX_WAIT_TIMEOUT_MS}.`);
-    }
-    return {
-      kind: "wait",
-      input: {
-        action,
-        ...(hasThreadId ? { threadId: requireTextField(record, "threadId", 128) } : {}),
-        ...(hasAll || !hasThreadId ? { all: true as const } : {}),
-        timeoutMs: timeoutValue,
-      },
-    };
-  }
-
-  if (action === "resume") {
-    requireOnlyFields(record, ["action", "threadId", "task"], action);
-    return {
-      kind: "resume",
-      input: {
-        action,
-        threadId: requireTextField(record, "threadId", 128),
-        ...(Object.hasOwn(record, "task") ? { task: requireTextField(record, "task", limits.taskCharacters) } : {}),
-      },
-    };
-  }
-
-  requireOnlyFields(record, ["action", "threadId", "all"], action);
+  }
+
+  if (action === "wait") {
+    requireOnlyFields(record, ["action", "threadId", "all", "timeoutMs"], action);
+    const hasThreadId = Object.hasOwn(record, "threadId");
+    const hasAll = Object.hasOwn(record, "all");
+    if (hasThreadId && hasAll || hasAll && record.all !== true) {
+      throw new Error('Invalid subagent request: action "wait" cannot combine threadId with all: true.');
+    }
+    const timeoutValue = record.timeoutMs === undefined ? DEFAULT_WAIT_TIMEOUT_MS : record.timeoutMs;
+    if (typeof timeoutValue !== "number" || !Number.isSafeInteger(timeoutValue) || timeoutValue <= 0 || timeoutValue > MAX_WAIT_TIMEOUT_MS) {
+      throw new Error(`Invalid subagent request: timeoutMs must be a positive integer no greater than ${MAX_WAIT_TIMEOUT_MS}.`);
+    }
+    return {
+      kind: "wait",
+      input: {
+        action,
+        ...(hasThreadId ? { threadId: requireTextField(record, "threadId", 128) } : {}),
+        ...(hasAll || !hasThreadId ? { all: true as const } : {}),
+        timeoutMs: timeoutValue,
+      },
+    };
+  }
+
+  if (action === "resume") {
+    requireOnlyFields(record, ["action", "threadId", "task"], action);
+    return {
+      kind: "resume",
+      input: {
+        action,
+        threadId: requireTextField(record, "threadId", 128),
+        ...(Object.hasOwn(record, "task") ? { task: requireTextField(record, "task", limits.taskCharacters) } : {}),
+      },
+    };
+  }
+
+  requireOnlyFields(record, ["action", "threadId", "all"], action);
   const hasThreadId = Object.hasOwn(record, "threadId");
   const hasAll = Object.hasOwn(record, "all");
   if (Number(hasThreadId) + Number(hasAll) !== 1 || hasAll && record.all !== true) {
@@ -1077,25 +1141,35 @@ function prepareSubagentRequest(
 }
 
 function createSubagentParams(limits: Pick<SubagentLimits, "maxTasks" | "maxReadConcurrency" | "taskCharacters">) {
-  const taskSchema = Type.Object({
-    agent: Type.String({ minLength: 1, maxLength: 64, description: "Agent role name" }),
-    task: Type.String({ minLength: 1, maxLength: limits.taskCharacters, description: "Bounded task for the role" }),
-    name: Type.Optional(Type.String({ minLength: 1, maxLength: 48, pattern: THREAD_NAME_PATTERN, description: "Parent-scoped child display name" })),
-  }, { additionalProperties: false });
-  const chainTaskSchema = Type.Object({
-    agent: Type.String({ minLength: 1, maxLength: 64, description: "Agent role name" }),
-    task: Type.String({ minLength: 1, maxLength: limits.taskCharacters, description: "Task with optional {previous} handoff placeholder" }),
-    name: Type.Optional(Type.String({ minLength: 1, maxLength: 48, pattern: THREAD_NAME_PATTERN, description: "Parent-scoped child display name" })),
-  }, { additionalProperties: false });
+  const inlineAgentSchema = Type.Object({
+    name: Type.String({ minLength: 1, maxLength: 64, pattern: "^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$" }),
+    description: Type.String({ minLength: 1, maxLength: 500 }),
+    access: StringEnum(["read", "write"] as const),
+    tools: Type.Array(Type.String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),
+  }, { additionalProperties: false, description: "Ephemeral role for this spawn only; tools must be active for the parent" });
+  const agentSchema = Type.Union([
+    Type.String({ minLength: 1, maxLength: 64, description: "Agent role name" }),
+    inlineAgentSchema,
+  ]);
+  const taskSchema = Type.Object({
+    agent: agentSchema,
+    task: Type.String({ minLength: 1, maxLength: limits.taskCharacters, description: "Bounded task for the role" }),
+    name: Type.Optional(Type.String({ minLength: 1, maxLength: 48, pattern: THREAD_NAME_PATTERN, description: "Parent-scoped child display name" })),
+  }, { additionalProperties: false });
+  const chainTaskSchema = Type.Object({
+    agent: agentSchema,
+    task: Type.String({ minLength: 1, maxLength: limits.taskCharacters, description: "Task with optional {previous} handoff placeholder" }),
+    name: Type.Optional(Type.String({ minLength: 1, maxLength: 48, pattern: THREAD_NAME_PATTERN, description: "Parent-scoped child display name" })),
+  }, { additionalProperties: false });
   const threadId = Type.String({ minLength: 1, maxLength: 128, description: "Existing child thread ID; omit when spawning because KillerOS creates it" });
   return Type.Object({
-    action: Type.Optional(StringEnum(SUBAGENT_ACTIONS, { default: SUBAGENT_ACTION.spawn, description: "Spawn, list, inspect, steer, interrupt, collect, wait, resume, or close. Omit threadId when spawning" })),
-    threadId: Type.Optional(threadId),
-    name: Type.Optional(Type.String({ minLength: 1, maxLength: 48, pattern: THREAD_NAME_PATTERN, description: "Parent-scoped child display name" })),
-    message: Type.Optional(Type.String({ minLength: 1, maxLength: 4_000, description: "Steering message; valid only with action steer" })),
-    all: Type.Optional(Type.Literal(true, { description: "Target every active or queued child thread for interrupt or wait" })),
-    timeoutMs: Type.Optional(Type.Integer({ minimum: 1, maximum: MAX_WAIT_TIMEOUT_MS, description: "Wait timeout in milliseconds; defaults to 30 seconds" })),
-    agent: Type.Optional(Type.String({ minLength: 1, maxLength: 64, description: "Agent role for single mode" })),
+    action: Type.Optional(StringEnum(SUBAGENT_ACTIONS, { default: SUBAGENT_ACTION.spawn, description: "Spawn, list, inspect, steer, interrupt, collect, wait, resume, or close. Omit threadId when spawning" })),
+    threadId: Type.Optional(threadId),
+    name: Type.Optional(Type.String({ minLength: 1, maxLength: 48, pattern: THREAD_NAME_PATTERN, description: "Parent-scoped child display name" })),
+    message: Type.Optional(Type.String({ minLength: 1, maxLength: Math.max(4_000, limits.taskCharacters), description: `Spawn task alias up to ${limits.taskCharacters.toLocaleString("en-US")} characters; steer message up to 4,000 characters` })),
+    all: Type.Optional(Type.Literal(true, { description: "Target every active or queued child thread for interrupt or wait" })),
+    timeoutMs: Type.Optional(Type.Integer({ minimum: 1, maximum: MAX_WAIT_TIMEOUT_MS, description: "Wait timeout in milliseconds; defaults to 30 seconds" })),
+    agent: Type.Optional(agentSchema),
     task: Type.Optional(Type.String({ minLength: 1, maxLength: limits.taskCharacters, description: "Task for single mode" })),
     tasks: Type.Optional(Type.Array(taskSchema, { minItems: 1, maxItems: limits.maxTasks, description: `Parallel role tasks: read-only batches run concurrently up to ${limits.maxReadConcurrency}; batches with writers use one shared slot by default. Set writerConcurrency to opt into a larger shared pool; concurrent writers share the parent worktree, so callers must prove path ownership` })),
     writerConcurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: limits.maxTasks, description: `Optional shared-pool cap for parallel tasks that include writers. Defaults to 1 when writers are selected; values above 1 opt into concurrent shared-worktree writes. Concurrent writers must prove path ownership` })),
@@ -1111,11 +1185,6 @@ function createSubagentParams(limits: Pick<SubagentLimits, "maxTasks" | "maxRead
 
 type ToolUpdate = (partial: { content: Array<{ type: "text"; text: string }>; details: SubagentDetails }) => void;
 
-function requestedAgents(params: { agent?: string; tasks?: TaskInput[]; chain?: TaskInput[] }): string[] {
-  if (params.agent) return [params.agent];
-  return (params.tasks ?? params.chain ?? []).map((task) => task.agent);
-}
-
 function clipCharacters(text: string, maxCharacters: number, fromEnd = false): string {
   const characters = [...text];
   if (characters.length <= maxCharacters) return text;
@@ -1157,22 +1226,22 @@ function expandChainTask(template: string, previous: string, maxCharacters: numb
   return pieces.join("");
 }
 
-function buildSteeredTask(task: string, steering: readonly string[], maxCharacters: number): string {
-  const steeringLabel = "\n\nParent steering:\n";
-  const steeringText = clipCharacters(steering.join("\n"), Math.max(0, maxCharacters - [...steeringLabel].length), true);
-  const required = [...steeringLabel, ...steeringText].length;
-  const taskText = clipCharacters(task, Math.max(0, maxCharacters - required));
-  return `${taskText}${steeringLabel}${steeringText}`;
-}
-
-export type TaskInput = { agent: string; task: string; name?: string };
-
-function steeredTaskWouldExceedLimit(task: string, steering: readonly string[], maxCharacters: number): boolean {
-  if (!steering.length) return false;
-  return codePointLength(task)
-    + codePointLength("\n\nParent steering:\n")
-    + codePointLength(steering.join("\n")) > maxCharacters;
-}
+function buildSteeredTask(task: string, steering: readonly string[], maxCharacters: number): string {
+  const steeringLabel = "\n\nParent steering:\n";
+  const steeringText = clipCharacters(steering.join("\n"), Math.max(0, maxCharacters - [...steeringLabel].length), true);
+  const required = [...steeringLabel, ...steeringText].length;
+  const taskText = clipCharacters(task, Math.max(0, maxCharacters - required));
+  return `${taskText}${steeringLabel}${steeringText}`;
+}
+
+export type TaskInput = { agent: AgentSpec; task: string; name?: string };
+
+function steeredTaskWouldExceedLimit(task: string, steering: readonly string[], maxCharacters: number): boolean {
+  if (!steering.length) return false;
+  return codePointLength(task)
+    + codePointLength("\n\nParent steering:\n")
+    + codePointLength(steering.join("\n")) > maxCharacters;
+}
 
 function formatUsage(usage: SubagentUsage): string {
   const parts = [`${usage.turns} turn${usage.turns === 1 ? "" : "s"}`, `${usage.totalTokens} tokens`];
@@ -1210,39 +1279,39 @@ function statusIcon(status: SubagentStatus): string {
   return "!";
 }
 
-interface ActiveThreadRuntime {
-  controller: AbortController;
-  handle?: SubagentProcessHandle;
-  handles: Set<SubagentProcessHandle>;
-  task: string;
-  steering: string[];
-  restarting: boolean;
-  traceCount: number;
-  startedAt: number;
-  sessionGeneration: number;
-  aggregate?: SubagentTaskResult;
-  requestedReason?: string;
-}
-
-interface ChildSession {
-  id: string;
-  directory: string;
-}
-
-interface ThreadMetadata {
-  displayName: string;
-  attempt: number;
-  session: ChildSession;
-  persistentSession: boolean;
-}
-
-type ThreadSnapshot = SubagentThread & {
-  displayName?: string;
-  attempt?: number;
-  session?: ChildSession;
-};
-
-function parentThreadId(ctx: ExtensionContext): string {
+interface ActiveThreadRuntime {
+  controller: AbortController;
+  handle?: SubagentProcessHandle;
+  handles: Set<SubagentProcessHandle>;
+  task: string;
+  steering: string[];
+  restarting: boolean;
+  traceCount: number;
+  startedAt: number;
+  sessionGeneration: number;
+  aggregate?: SubagentTaskResult;
+  requestedReason?: string;
+}
+
+interface ChildSession {
+  id: string;
+  directory: string;
+}
+
+interface ThreadMetadata {
+  displayName: string;
+  attempt: number;
+  session: ChildSession;
+  persistentSession: boolean;
+}
+
+type ThreadSnapshot = SubagentThread & {
+  displayName?: string;
+  attempt?: number;
+  session?: ChildSession;
+};
+
+function parentThreadId(ctx: ExtensionContext): string {
   try {
     const id = ctx.sessionManager?.getSessionId?.();
     if (id) return `main:${id}`;
@@ -1250,61 +1319,61 @@ function parentThreadId(ctx: ExtensionContext): string {
     // Test and RPC contexts may not expose a session manager.
   }
   return "main";
-}
-
-function defaultThreadName(role: string, existing: readonly ThreadSnapshot[]): string {
-  const names = new Set(existing.map((thread) => thread.displayName?.toLocaleLowerCase() ?? thread.role.toLocaleLowerCase()));
-  const base = role.length <= 48 ? role : role.slice(0, 48);
-  if (!names.has(base.toLocaleLowerCase()) && THREAD_NAME_RE.test(base)) return base;
-  for (let suffix = 2; suffix < 10_000; suffix += 1) {
-    const suffixText = `-${suffix}`;
-    const candidate = `${base.slice(0, 48 - suffixText.length)}${suffixText}`;
-    if (THREAD_NAME_RE.test(candidate) && !names.has(candidate.toLocaleLowerCase())) return candidate;
-  }
-  throw new Error(`Could not allocate a unique display name for role ${JSON.stringify(role)}`);
-}
-
-function safeSessionId(value: string): string {
-  return value.replace(/[^A-Za-z0-9_.-]/gu, "_");
-}
-
-function childSessionPath(ctx: ExtensionContext, threadId: string): ChildSession | undefined {
-  try {
-    const directoryRoot = ctx.sessionManager?.getSessionDir?.();
-    if (typeof directoryRoot !== "string" || !directoryRoot) return undefined;
-    const rawParentId = ctx.sessionManager?.getSessionId?.() ?? parentThreadId(ctx);
-    const id = `killeros-${safeSessionId(threadId)}`;
-    return {
-      id,
-      directory: path.join(directoryRoot, "killeros-subagents", safeSessionId(rawParentId), safeSessionId(threadId)),
-    };
-  } catch {
-    return undefined;
-  }
-}
-
-function threadDisplayName(thread: ThreadSnapshot, metadata: Map<string, ThreadMetadata>): string {
-  return thread.displayName ?? metadata.get(thread.id)?.displayName ?? thread.role;
-}
-
-function threadAttempt(thread: ThreadSnapshot, metadata: Map<string, ThreadMetadata>): number {
-  return thread.attempt ?? metadata.get(thread.id)?.attempt ?? 1;
-}
-
-function threadSession(thread: ThreadSnapshot, metadata: Map<string, ThreadMetadata>): ChildSession | undefined {
-  return thread.session ?? metadata.get(thread.id)?.session;
-}
-
-function threadView(thread: SubagentThread, metadata: Map<string, ThreadMetadata>): ThreadSnapshot {
-  const view = { ...thread } as ThreadSnapshot;
-  const known = metadata.get(thread.id);
-  if (view.displayName === undefined && known) view.displayName = known.displayName;
-  if (view.attempt === undefined && known) view.attempt = known.attempt;
-  const isPendingSession = view.session?.id === "killeros-pending"
-    || view.session?.directory === path.join(os.tmpdir(), "killeros-subagent-pending");
-  if ((view.session === undefined || isPendingSession) && known) view.session = { ...known.session };
-  return view;
-}
+}
+
+function defaultThreadName(role: string, existing: readonly ThreadSnapshot[]): string {
+  const names = new Set(existing.map((thread) => thread.displayName?.toLocaleLowerCase() ?? thread.role.toLocaleLowerCase()));
+  const base = role.length <= 48 ? role : role.slice(0, 48);
+  if (!names.has(base.toLocaleLowerCase()) && THREAD_NAME_RE.test(base)) return base;
+  for (let suffix = 2; suffix < 10_000; suffix += 1) {
+    const suffixText = `-${suffix}`;
+    const candidate = `${base.slice(0, 48 - suffixText.length)}${suffixText}`;
+    if (THREAD_NAME_RE.test(candidate) && !names.has(candidate.toLocaleLowerCase())) return candidate;
+  }
+  throw new Error(`Could not allocate a unique display name for role ${JSON.stringify(role)}`);
+}
+
+function safeSessionId(value: string): string {
+  return value.replace(/[^A-Za-z0-9_.-]/gu, "_");
+}
+
+function childSessionPath(ctx: ExtensionContext, threadId: string): ChildSession | undefined {
+  try {
+    const directoryRoot = ctx.sessionManager?.getSessionDir?.();
+    if (typeof directoryRoot !== "string" || !directoryRoot) return undefined;
+    const rawParentId = ctx.sessionManager?.getSessionId?.() ?? parentThreadId(ctx);
+    const id = `killeros-${safeSessionId(threadId)}`;
+    return {
+      id,
+      directory: path.join(directoryRoot, "killeros-subagents", safeSessionId(rawParentId), safeSessionId(threadId)),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function threadDisplayName(thread: ThreadSnapshot, metadata: Map<string, ThreadMetadata>): string {
+  return thread.displayName ?? metadata.get(thread.id)?.displayName ?? thread.role;
+}
+
+function threadAttempt(thread: ThreadSnapshot, metadata: Map<string, ThreadMetadata>): number {
+  return thread.attempt ?? metadata.get(thread.id)?.attempt ?? 1;
+}
+
+function threadSession(thread: ThreadSnapshot, metadata: Map<string, ThreadMetadata>): ChildSession | undefined {
+  return thread.session ?? metadata.get(thread.id)?.session;
+}
+
+function threadView(thread: SubagentThread, metadata: Map<string, ThreadMetadata>): ThreadSnapshot {
+  const view = { ...thread } as ThreadSnapshot;
+  const known = metadata.get(thread.id);
+  if (view.displayName === undefined && known) view.displayName = known.displayName;
+  if (view.attempt === undefined && known) view.attempt = known.attempt;
+  const isPendingSession = view.session?.id === "killeros-pending"
+    || view.session?.directory === path.join(os.tmpdir(), "killeros-subagent-pending");
+  if ((view.session === undefined || isPendingSession) && known) view.session = { ...known.session };
+  return view;
+}
 
 function threadCapabilityBoundary(agent: AgentRole): {
   filesystem: "read" | "write";
@@ -1332,24 +1401,24 @@ function threadUsage(usage: SubagentUsage): SubagentThread["usage"] {
   };
 }
 
-function legacyStatus(state: SubagentThreadState): SubagentStatus {
+function legacyStatus(state: SubagentThreadState): SubagentStatus {
   if (state === "active") return "running";
   if (state === "done" || state === "closed") return "complete";
   if (state === "failed") return "failed";
-  if (state === "stopped") return "cancelled";
-  if (state === "orphaned") return "orphaned";
-  return "queued";
-}
-
-function threadResult(thread: SubagentThread, source?: SubagentTaskResult): SubagentTaskResult {
-  if (source) {
-    const result = cloneResult(source);
-    if (thread.state === "queued") result.status = "queued";
-    else if (thread.state === "active") result.status = "running";
-    else if (thread.state === "orphaned") result.status = "orphaned";
-    return result;
-  }
-  return {
+  if (state === "stopped") return "cancelled";
+  if (state === "orphaned") return "orphaned";
+  return "queued";
+}
+
+function threadResult(thread: SubagentThread, source?: SubagentTaskResult): SubagentTaskResult {
+  if (source) {
+    const result = cloneResult(source);
+    if (thread.state === "queued") result.status = "queued";
+    else if (thread.state === "active") result.status = "running";
+    else if (thread.state === "orphaned") result.status = "orphaned";
+    return result;
+  }
+  return {
     ...makeQueuedResult(thread.id, thread.role, thread.prompt),
     status: legacyStatus(thread.state),
     agentSource: "unknown",
@@ -1365,81 +1434,84 @@ function threadResult(thread: SubagentThread, source?: SubagentTaskResult): Suba
       cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: thread.usage.costUsd },
       turns: thread.usage.turns,
     },
-    output: thread.result ?? "",
-    toolCallCount: 0,
-    exitConfirmed: false,
-    terminationReason: thread.stopReason,
-  };
-}
-
-function restorePersistedResult(value: unknown, thread: ThreadSnapshot): SubagentTaskResult | undefined {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+    output: thread.result ?? "",
+    toolCallCount: 0,
+    exitConfirmed: false,
+    terminationReason: thread.stopReason,
+  };
+}
+
+function restorePersistedResult(value: unknown, thread: ThreadSnapshot): SubagentTaskResult | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
   const source = value as Record<string, any>;
   const statuses = new Set<SubagentStatus>(["queued", "running", "complete", "failed", "cancelled", "limited"]);
+  const agentSources = new Set<SubagentTaskResult["agentSource"]>(["bundled", "personal", "project", "inline", "unknown"]);
   if (typeof source.id !== "string" || source.id !== thread.id) return undefined;
-  const status = source.status ?? (thread.state === "done" ? "complete" : thread.state === "failed" ? "failed" : "cancelled");
-  if (typeof status !== "string" || !statuses.has(status as SubagentStatus)) return undefined;
-  if (thread.state === "done" && status !== "complete") return undefined;
-  if (thread.state === "failed" && status !== "failed") return undefined;
-  if (thread.state === "stopped" && !["cancelled", "limited"].includes(status)) return undefined;
-  if (thread.state === "closed") return undefined;
-  const rawOutput = source.output === undefined ? thread.result ?? "" : source.output;
-  if (typeof rawOutput !== "string") return undefined;
-  const output = truncateUtf8(rawOutput, 256 * 1024).text;
-  const usage = source.usage;
-  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return undefined;
-  const usageFields = ["input", "output", "cacheRead", "cacheWrite", "totalTokens", "turns"];
-  if (usageFields.some((field) => typeof usage[field] !== "number" || !Number.isFinite(usage[field]) || usage[field] < 0)) return undefined;
-  if (!usage.cost || typeof usage.cost !== "object" || Array.isArray(usage.cost)) return undefined;
-  const costFields = ["input", "output", "cacheRead", "cacheWrite", "total"];
-  if (costFields.some((field) => typeof usage.cost[field] !== "number" || !Number.isFinite(usage.cost[field]) || usage.cost[field] < 0)) return undefined;
-  const outputBytes = source.outputBytes === undefined ? Buffer.byteLength(output, "utf8") : source.outputBytes;
-  const outputTruncatedBytes = source.outputTruncatedBytes === undefined ? 0 : source.outputTruncatedBytes;
-  const durationMs = source.durationMs === undefined ? 0 : source.durationMs;
-  if (![outputBytes, outputTruncatedBytes, durationMs].every((item) => typeof item === "number" && Number.isFinite(item) && item >= 0)) return undefined;
-  const exitCode = source.exitCode === undefined || source.exitCode === null ? null : source.exitCode;
-  if (exitCode !== null && (!Number.isSafeInteger(exitCode) || exitCode < 0)) return undefined;
-  if (source.terminationReason !== undefined && typeof source.terminationReason !== "string") return undefined;
+  const status = source.status ?? (thread.state === "done" ? "complete" : thread.state === "failed" ? "failed" : "cancelled");
+  if (typeof status !== "string" || !statuses.has(status as SubagentStatus)) return undefined;
+  if (thread.state === "done" && status !== "complete") return undefined;
+  if (thread.state === "failed" && status !== "failed") return undefined;
+  if (thread.state === "stopped" && !["cancelled", "limited"].includes(status)) return undefined;
+  if (thread.state === "closed") return undefined;
+  const rawOutput = source.output === undefined ? thread.result ?? "" : source.output;
+  if (typeof rawOutput !== "string") return undefined;
+  const output = truncateUtf8(rawOutput, 256 * 1024).text;
+  const usage = source.usage;
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return undefined;
+  const usageFields = ["input", "output", "cacheRead", "cacheWrite", "totalTokens", "turns"];
+  if (usageFields.some((field) => typeof usage[field] !== "number" || !Number.isFinite(usage[field]) || usage[field] < 0)) return undefined;
+  if (!usage.cost || typeof usage.cost !== "object" || Array.isArray(usage.cost)) return undefined;
+  const costFields = ["input", "output", "cacheRead", "cacheWrite", "total"];
+  if (costFields.some((field) => typeof usage.cost[field] !== "number" || !Number.isFinite(usage.cost[field]) || usage.cost[field] < 0)) return undefined;
+  const outputBytes = source.outputBytes === undefined ? Buffer.byteLength(output, "utf8") : source.outputBytes;
+  const outputTruncatedBytes = source.outputTruncatedBytes === undefined ? 0 : source.outputTruncatedBytes;
+  const durationMs = source.durationMs === undefined ? 0 : source.durationMs;
+  if (![outputBytes, outputTruncatedBytes, durationMs].every((item) => typeof item === "number" && Number.isFinite(item) && item >= 0)) return undefined;
+  const exitCode = source.exitCode === undefined || source.exitCode === null ? null : source.exitCode;
+  if (exitCode !== null && (!Number.isSafeInteger(exitCode) || exitCode < 0)) return undefined;
+  if (source.terminationReason !== undefined && typeof source.terminationReason !== "string") return undefined;
   if (source.errorMessage !== undefined && typeof source.errorMessage !== "string") return undefined;
   if (source.exitConfirmed !== undefined && typeof source.exitConfirmed !== "boolean") return undefined;
-  const attempt = Number.isSafeInteger(source.attempt) && source.attempt > 0 ? source.attempt : thread.attempt;
-  const result = makeQueuedResult(
-    thread.id,
-    typeof source.agent === "string" && source.agent ? clipCharacters(source.agent, 64) : thread.role,
-    typeof source.task === "string" && source.task ? clipCharacters(source.task, 20_000) : thread.prompt,
-    undefined,
-    typeof source.name === "string" && source.name ? clipCharacters(source.name, 48) : thread.displayName,
-    attempt,
-  );
+  if (source.agentSource !== undefined && (typeof source.agentSource !== "string" || !agentSources.has(source.agentSource as SubagentTaskResult["agentSource"]))) return undefined;
+  const attempt = Number.isSafeInteger(source.attempt) && source.attempt > 0 ? source.attempt : thread.attempt;
+  const result = makeQueuedResult(
+    thread.id,
+    typeof source.agent === "string" && source.agent ? clipCharacters(source.agent, 64) : thread.role,
+    typeof source.task === "string" && source.task ? clipCharacters(source.task, 20_000) : thread.prompt,
+    undefined,
+    typeof source.name === "string" && source.name ? clipCharacters(source.name, 48) : thread.displayName,
+    attempt,
+  );
   result.status = status as SubagentStatus;
-  result.output = output;
-  result.outputBytes = outputBytes;
-  result.outputTruncatedBytes = outputTruncatedBytes;
-  result.usage = {
-    input: usage.input,
-    output: usage.output,
-    cacheRead: usage.cacheRead,
-    cacheWrite: usage.cacheWrite,
-    totalTokens: usage.totalTokens,
-    cost: { input: usage.cost.input, output: usage.cost.output, cacheRead: usage.cost.cacheRead, cacheWrite: usage.cost.cacheWrite, total: usage.cost.total },
-    turns: usage.turns,
-  };
-  result.terminationReason = source.terminationReason;
-  result.errorMessage = source.errorMessage;
-  result.durationMs = durationMs;
-  result.exitCode = exitCode;
-  result.exitConfirmed = source.exitConfirmed === true;
-  return result;
-}
-
-function threadBoardRecord(result: SubagentTaskResult): ThreadBoardRecord {
-  return {
-    id: result.id,
-    displayName: result.name,
-    attempt: result.attempt,
-    agent: result.agent,
+  result.agentSource = source.agentSource ?? "unknown";
+  result.output = output;
+  result.outputBytes = outputBytes;
+  result.outputTruncatedBytes = outputTruncatedBytes;
+  result.usage = {
+    input: usage.input,
+    output: usage.output,
+    cacheRead: usage.cacheRead,
+    cacheWrite: usage.cacheWrite,
+    totalTokens: usage.totalTokens,
+    cost: { input: usage.cost.input, output: usage.cost.output, cacheRead: usage.cost.cacheRead, cacheWrite: usage.cost.cacheWrite, total: usage.cost.total },
+    turns: usage.turns,
+  };
+  result.terminationReason = source.terminationReason;
+  result.errorMessage = source.errorMessage;
+  result.durationMs = durationMs;
+  result.exitCode = exitCode;
+  result.exitConfirmed = source.exitConfirmed === true;
+  return result;
+}
+
+function threadBoardRecord(result: SubagentTaskResult): ThreadBoardRecord {
+  return {
+    id: result.id,
+    displayName: result.name,
+    attempt: result.attempt,
+    agent: result.agent,
     task: result.task,
-    status: result.status as ThreadBoardRecord["status"],
+    status: result.status as ThreadBoardRecord["status"],
     usage: {
       input: result.usage.input,
       output: result.usage.output,
@@ -1460,244 +1532,245 @@ function threadBoardRecord(result: SubagentTaskResult): ThreadBoardRecord {
   };
 }
 
-export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeOptions = {}): SubagentControlApi {
-  const limits = { ...SUBAGENT_LIMITS, ...options.limits };
-  const spawnProcess = options.spawnProcess ?? defaultSpawnProcess;
-  let threads = new SubagentThreadRegistry();
-  const activeRuntimes = new Map<string, ActiveThreadRuntime>();
-  const threadMetadata = new Map<string, ThreadMetadata>();
-  const threadResources = new Map<string, { directory: string; persistent: boolean; handles: Set<SubagentProcessHandle> }>();
-  const backgroundBatches = new Set<Promise<unknown>>();
-  const savedResults = new Map<string, SubagentTaskResult>();
-  const evictedThreadParents = new Map<string, string | undefined>();
-  let sessionGeneration = 0;
-  let persistenceWarning: string | undefined;
-
-  const persistText = (value: string | undefined, maxBytes: number): string | undefined => {
-    if (value === undefined) return undefined;
-    return truncateUtf8(value, maxBytes).text;
-  };
-  const persistenceAppend = (record: Record<string, unknown>): void => {
-    const appendEntry = (pi as unknown as { appendEntry?: (type: string, data: unknown) => void }).appendEntry;
-    if (!appendEntry) return;
-    try {
-      appendEntry.call(pi, SUBAGENT_PERSISTENCE_TYPE, record);
-    } catch (error) {
-      persistenceWarning ??= `Subagent persistence is unavailable: ${error instanceof Error ? error.message : String(error)}`;
-    }
-  };
-  const persistedThread = (thread: ThreadSnapshot): Record<string, unknown> => {
-    const session = threadSession(thread, threadMetadata) ?? { id: `killeros-${safeSessionId(thread.id)}`, directory: "" };
-    return {
-      id: thread.id,
-      parentId: thread.parentId,
-      displayName: threadDisplayName(thread, threadMetadata),
-      attempt: threadAttempt(thread, threadMetadata),
-      role: thread.role,
-      prompt: clipCharacters(thread.prompt, limits.taskCharacters),
-      model: thread.model,
-      tools: thread.tools.slice(0, 32).map((tool) => clipCharacters(tool, 64)),
-      capabilityBoundary: { ...thread.capabilityBoundary },
-      session: { ...session },
-      state: thread.state,
-      usage: { ...thread.usage },
-      handoff: thread.handoff
-        ? { ...thread.handoff, summary: persistText(thread.handoff.summary, 256 * 1024) }
-        : undefined,
-      result: persistText(thread.result, 256 * 1024),
-      failure: thread.failure ? { ...thread.failure, message: clipCharacters(thread.failure.message, 512) } : undefined,
-      stopReason: thread.stopReason,
-      evicted: thread.evicted,
-      timestamps: { ...thread.timestamps },
-      version: thread.version,
-      trace: thread.trace.slice(-64).map((entry) => ({
-        ...entry,
-        message: persistText(entry.message, 64 * 1024),
-      })),
-      steering: thread.steering.slice(-20).map((entry) => ({ ...entry, message: clipCharacters(entry.message, 4_000) })),
-    };
-  };
-  const recordSpawn = (thread: SubagentThread): void => {
-    const view = threadView(thread, threadMetadata);
-    persistenceAppend({ version: 1, event: "spawn", parentId: view.parentId, thread: persistedThread(view) });
-  };
-  const recordSnapshot = (thread: SubagentThread, result?: SubagentTaskResult): void => {
-    const view = threadView(thread, threadMetadata);
-    persistenceAppend({
-      version: 1,
-      event: "snapshot",
-      parentId: view.parentId,
-      id: view.id,
-      thread: persistedThread(view),
-      ...(result ? {
-        result: {
-          id: result.id,
-          name: result.name,
+export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeOptions = {}): SubagentControlApi {
+  const limits = { ...SUBAGENT_LIMITS, ...options.limits };
+  const spawnProcess = options.spawnProcess ?? defaultSpawnProcess;
+  let threads = new SubagentThreadRegistry();
+  const activeRuntimes = new Map<string, ActiveThreadRuntime>();
+  const threadMetadata = new Map<string, ThreadMetadata>();
+  const threadResources = new Map<string, { directory: string; persistent: boolean; handles: Set<SubagentProcessHandle> }>();
+  const backgroundBatches = new Set<Promise<unknown>>();
+  const savedResults = new Map<string, SubagentTaskResult>();
+  const evictedThreadParents = new Map<string, string | undefined>();
+  let sessionGeneration = 0;
+  let persistenceWarning: string | undefined;
+
+  const persistText = (value: string | undefined, maxBytes: number): string | undefined => {
+    if (value === undefined) return undefined;
+    return truncateUtf8(value, maxBytes).text;
+  };
+  const persistenceAppend = (record: Record<string, unknown>): void => {
+    const appendEntry = (pi as unknown as { appendEntry?: (type: string, data: unknown) => void }).appendEntry;
+    if (!appendEntry) return;
+    try {
+      appendEntry.call(pi, SUBAGENT_PERSISTENCE_TYPE, record);
+    } catch (error) {
+      persistenceWarning ??= `Subagent persistence is unavailable: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  };
+  const persistedThread = (thread: ThreadSnapshot): Record<string, unknown> => {
+    const session = threadSession(thread, threadMetadata) ?? { id: `killeros-${safeSessionId(thread.id)}`, directory: "" };
+    return {
+      id: thread.id,
+      parentId: thread.parentId,
+      displayName: threadDisplayName(thread, threadMetadata),
+      attempt: threadAttempt(thread, threadMetadata),
+      role: thread.role,
+      prompt: clipCharacters(thread.prompt, limits.taskCharacters),
+      model: thread.model,
+      tools: thread.tools.slice(0, 32).map((tool) => clipCharacters(tool, 64)),
+      capabilityBoundary: { ...thread.capabilityBoundary },
+      session: { ...session },
+      state: thread.state,
+      usage: { ...thread.usage },
+      handoff: thread.handoff
+        ? { ...thread.handoff, summary: persistText(thread.handoff.summary, 256 * 1024) }
+        : undefined,
+      result: persistText(thread.result, 256 * 1024),
+      failure: thread.failure ? { ...thread.failure, message: clipCharacters(thread.failure.message, 512) } : undefined,
+      stopReason: thread.stopReason,
+      evicted: thread.evicted,
+      timestamps: { ...thread.timestamps },
+      version: thread.version,
+      trace: thread.trace.slice(-64).map((entry) => ({
+        ...entry,
+        message: persistText(entry.message, 64 * 1024),
+      })),
+      steering: thread.steering.slice(-20).map((entry) => ({ ...entry, message: clipCharacters(entry.message, 4_000) })),
+    };
+  };
+  const recordSpawn = (thread: SubagentThread): void => {
+    const view = threadView(thread, threadMetadata);
+    persistenceAppend({ version: 1, event: "spawn", parentId: view.parentId, thread: persistedThread(view) });
+  };
+  const recordSnapshot = (thread: SubagentThread, result?: SubagentTaskResult): void => {
+    const view = threadView(thread, threadMetadata);
+    persistenceAppend({
+      version: 1,
+      event: "snapshot",
+      parentId: view.parentId,
+      id: view.id,
+      thread: persistedThread(view),
+      ...(result ? {
+        result: {
+          id: result.id,
+          name: result.name,
           agent: result.agent,
+          agentSource: result.agentSource,
           task: clipCharacters(result.task, limits.taskCharacters),
-          status: result.status,
-          output: persistText(result.output, 256 * 1024),
-          outputBytes: result.outputBytes,
-          outputTruncatedBytes: result.outputTruncatedBytes,
-          usage: result.usage,
-          terminationReason: result.terminationReason,
-          errorMessage: persistText(result.errorMessage, 8 * 1024),
-          durationMs: result.durationMs,
-          exitCode: result.exitCode,
-          exitConfirmed: result.exitConfirmed,
-          attempt: result.attempt,
-        },
-      } : {}),
-    });
-  };
-  const recordClose = (thread: SubagentThread): void => {
-    const view = threadView(thread, threadMetadata);
-    persistenceAppend({ version: 1, event: "close", parentId: view.parentId, id: view.id, closedAt: view.timestamps.closedAt ?? Date.now() });
-  };
-  let unsubscribePersistence = (): void => {};
-  const attachPersistence = (): void => {
-    unsubscribePersistence = threads.subscribe((change) => {
-      if (["complete", "fail", "stop", "interrupt", "resume"].includes(change.type)) {
-        recordSnapshot(change.thread, savedResults.get(change.thread.id));
-      } else if (change.type === "close") {
-        recordClose(change.thread);
-      }
-    });
-  };
-
-  const restoreRecords = (
-    entries: readonly unknown[],
-    parentId: string,
-    expectedSession?: (threadId: string) => ChildSession | undefined,
-  ): Array<{ thread: ThreadSnapshot; result?: SubagentTaskResult }> => {
-    const records = new Map<string, { thread: ThreadSnapshot; result?: SubagentTaskResult }>();
-    for (const entry of entries) {
-      try {
-        if (!entry || typeof entry !== "object") continue;
-        const candidate = entry as Record<string, unknown>;
-        if (candidate.type !== "custom" || candidate.customType !== SUBAGENT_PERSISTENCE_TYPE) continue;
-        const data = candidate.data;
-        if (!data || typeof data !== "object") continue;
-        const record = data as Record<string, any>;
-        if (record.version !== 1 || typeof record.parentId !== "string" || record.parentId !== parentId) continue;
-        if (record.event === "spawn" || record.event === "snapshot") {
-          const rawThread = record.thread;
-          if (!rawThread || typeof rawThread !== "object" || typeof rawThread.id !== "string" || rawThread.parentId !== parentId) continue;
-          if (typeof rawThread.role !== "string" || typeof rawThread.prompt !== "string" || typeof rawThread.model !== "string") continue;
-          const thread = { ...rawThread } as ThreadSnapshot;
-          thread.prompt = clipCharacters(thread.prompt, limits.taskCharacters);
-          thread.result = typeof rawThread.result === "string" ? persistText(rawThread.result, 256 * 1024) : rawThread.result;
-          thread.tools = Array.isArray(rawThread.tools) ? rawThread.tools.slice(0, 32) : [];
-          thread.trace = Array.isArray(rawThread.trace) ? rawThread.trace.slice(-64) : [];
-          thread.steering = Array.isArray(rawThread.steering) ? rawThread.steering.slice(-20) : [];
-          thread.displayName = typeof rawThread.displayName === "string" ? rawThread.displayName : rawThread.role;
-          thread.attempt = Number.isSafeInteger(rawThread.attempt) && rawThread.attempt > 0 ? rawThread.attempt : 1;
-          const trustedSession = expectedSession?.(thread.id);
-          const rawSession = rawThread.session && typeof rawThread.session === "object" ? rawThread.session : undefined;
-          if (trustedSession && rawSession
-            && (String(rawSession.id ?? trustedSession.id) !== trustedSession.id
-              || String(rawSession.directory ?? trustedSession.directory) !== trustedSession.directory)) continue;
-          thread.session = trustedSession ?? {
-            id: `killeros-${safeSessionId(thread.id)}`,
-            directory: "",
-          };
-          if (thread.state === "queued" || thread.state === "active") {
-            thread.state = "orphaned" as SubagentThreadState;
-            thread.stopReason = "parent_restarted";
-          }
-          const result = record.result === undefined ? undefined : restorePersistedResult(record.result, thread);
-          if (record.result !== undefined && !result) continue;
-          records.set(thread.id, { thread, result });
-        } else if (record.event === "close" && typeof record.id === "string") {
-          const previous = records.get(record.id);
-          if (!previous) continue;
-          if (typeof record.closedAt !== "number" || !Number.isFinite(record.closedAt) || record.closedAt < 0) continue;
-          previous.thread.state = "closed";
-          previous.thread.evicted = true;
-          previous.thread.prompt = "[closed thread prompt evicted]";
-          previous.thread.result = undefined;
-          previous.thread.trace = [];
-          previous.thread.steering = [];
-          previous.thread.handoff = undefined;
-          previous.thread.timestamps = { ...previous.thread.timestamps, closedAt: record.closedAt };
-          previous.result = undefined;
-        }
-      } catch {
-        // A malformed custom entry must not prevent the parent session from starting.
-        continue;
-      }
-    }
-    return [...records.values()];
-  };
-
-  const installRestoredThreads = (restored: Array<{ thread: ThreadSnapshot; result?: SubagentTaskResult }>): void => {
-    if (!restored.length) return;
-    const ids = [...restored.map(({ thread }) => thread.id)];
-    let idIndex = 0;
-    const oldThreads = threads;
-    unsubscribePersistence();
-    threads = new SubagentThreadRegistry({ createId: () => ids[idIndex++] ?? `subagent-${Date.now()}` });
-    attachPersistence();
-    for (const entry of restored) {
-      try {
-        const thread = entry.thread;
-        const created = (threads as any).hydrate
-          ? (threads as any).hydrate(thread)
-          : threads.spawn({
-            parentId: thread.parentId as SubagentThreadId,
-            role: thread.role,
-            prompt: thread.prompt,
-            model: thread.model,
-            tools: thread.tools,
-            capabilityBoundary: thread.capabilityBoundary,
-            displayName: thread.displayName,
-            attempt: thread.attempt,
-            session: thread.session,
-          } as any);
-        threadMetadata.set(created.id, {
-          displayName: thread.displayName ?? thread.role,
-          attempt: thread.attempt ?? 1,
-          session: thread.session ?? { id: `killeros-${safeSessionId(thread.id)}`, directory: "" },
-          persistentSession: Boolean(thread.session?.directory),
-        });
-        if (entry.result) saveResult(created.id, entry.result);
-        if (!(threads as any).hydrate) {
-          if (thread.state === "done") {
-            threads.begin(created.id);
-            threads.complete(created.id, { result: thread.result ?? entry.result?.output });
-          } else if (thread.state === "failed") {
-            threads.begin(created.id);
-            threads.fail(created.id, { message: thread.failure?.message ?? entry.result?.errorMessage ?? "restored failure" });
-          } else if (thread.state === "stopped" || thread.state === "orphaned") {
-            threads.stop(created.id, { reason: thread.stopReason ?? "parent_restarted" });
-          }
-          if (thread.state === "closed") {
-            if (threads.inspect(created.id)?.state === "queued") threads.begin(created.id);
-            if (threads.inspect(created.id)?.state === "active") threads.stop(created.id, { reason: thread.stopReason ?? "closed" });
-            threads.close(created.id);
-          }
-        }
-      } catch {
-        // Skip malformed or conflicting records and keep the rest of the board usable.
-        continue;
-      }
-    }
-    if (oldThreads !== threads && !oldThreads.isDisposed) oldThreads.dispose();
-  };
-
-  attachPersistence();
-  const maxClosedThreads = Number.isSafeInteger(limits.threadRetentionRecords) && limits.threadRetentionRecords > 0
-    ? limits.threadRetentionRecords
-    : SUBAGENT_LIMITS.threadRetentionRecords;
-
-  const stopActiveRuntimes = (reason: string): void => {
-    for (const runtime of activeRuntimes.values()) {
-      runtime.restarting = false;
-      runtime.requestedReason = reason;
-      runtime.handle?.stop(reason);
-      runtime.controller.abort();
-    }
-  };
+          status: result.status,
+          output: persistText(result.output, 256 * 1024),
+          outputBytes: result.outputBytes,
+          outputTruncatedBytes: result.outputTruncatedBytes,
+          usage: result.usage,
+          terminationReason: result.terminationReason,
+          errorMessage: persistText(result.errorMessage, 8 * 1024),
+          durationMs: result.durationMs,
+          exitCode: result.exitCode,
+          exitConfirmed: result.exitConfirmed,
+          attempt: result.attempt,
+        },
+      } : {}),
+    });
+  };
+  const recordClose = (thread: SubagentThread): void => {
+    const view = threadView(thread, threadMetadata);
+    persistenceAppend({ version: 1, event: "close", parentId: view.parentId, id: view.id, closedAt: view.timestamps.closedAt ?? Date.now() });
+  };
+  let unsubscribePersistence = (): void => {};
+  const attachPersistence = (): void => {
+    unsubscribePersistence = threads.subscribe((change) => {
+      if (["complete", "fail", "stop", "interrupt", "resume"].includes(change.type)) {
+        recordSnapshot(change.thread, savedResults.get(change.thread.id));
+      } else if (change.type === "close") {
+        recordClose(change.thread);
+      }
+    });
+  };
+
+  const restoreRecords = (
+    entries: readonly unknown[],
+    parentId: string,
+    expectedSession?: (threadId: string) => ChildSession | undefined,
+  ): Array<{ thread: ThreadSnapshot; result?: SubagentTaskResult }> => {
+    const records = new Map<string, { thread: ThreadSnapshot; result?: SubagentTaskResult }>();
+    for (const entry of entries) {
+      try {
+        if (!entry || typeof entry !== "object") continue;
+        const candidate = entry as Record<string, unknown>;
+        if (candidate.type !== "custom" || candidate.customType !== SUBAGENT_PERSISTENCE_TYPE) continue;
+        const data = candidate.data;
+        if (!data || typeof data !== "object") continue;
+        const record = data as Record<string, any>;
+        if (record.version !== 1 || typeof record.parentId !== "string" || record.parentId !== parentId) continue;
+        if (record.event === "spawn" || record.event === "snapshot") {
+          const rawThread = record.thread;
+          if (!rawThread || typeof rawThread !== "object" || typeof rawThread.id !== "string" || rawThread.parentId !== parentId) continue;
+          if (typeof rawThread.role !== "string" || typeof rawThread.prompt !== "string" || typeof rawThread.model !== "string") continue;
+          const thread = { ...rawThread } as ThreadSnapshot;
+          thread.prompt = clipCharacters(thread.prompt, limits.taskCharacters);
+          thread.result = typeof rawThread.result === "string" ? persistText(rawThread.result, 256 * 1024) : rawThread.result;
+          thread.tools = Array.isArray(rawThread.tools) ? rawThread.tools.slice(0, 32) : [];
+          thread.trace = Array.isArray(rawThread.trace) ? rawThread.trace.slice(-64) : [];
+          thread.steering = Array.isArray(rawThread.steering) ? rawThread.steering.slice(-20) : [];
+          thread.displayName = typeof rawThread.displayName === "string" ? rawThread.displayName : rawThread.role;
+          thread.attempt = Number.isSafeInteger(rawThread.attempt) && rawThread.attempt > 0 ? rawThread.attempt : 1;
+          const trustedSession = expectedSession?.(thread.id);
+          const rawSession = rawThread.session && typeof rawThread.session === "object" ? rawThread.session : undefined;
+          if (trustedSession && rawSession
+            && (String(rawSession.id ?? trustedSession.id) !== trustedSession.id
+              || String(rawSession.directory ?? trustedSession.directory) !== trustedSession.directory)) continue;
+          thread.session = trustedSession ?? {
+            id: `killeros-${safeSessionId(thread.id)}`,
+            directory: "",
+          };
+          if (thread.state === "queued" || thread.state === "active") {
+            thread.state = "orphaned" as SubagentThreadState;
+            thread.stopReason = "parent_restarted";
+          }
+          const result = record.result === undefined ? undefined : restorePersistedResult(record.result, thread);
+          if (record.result !== undefined && !result) continue;
+          records.set(thread.id, { thread, result });
+        } else if (record.event === "close" && typeof record.id === "string") {
+          const previous = records.get(record.id);
+          if (!previous) continue;
+          if (typeof record.closedAt !== "number" || !Number.isFinite(record.closedAt) || record.closedAt < 0) continue;
+          previous.thread.state = "closed";
+          previous.thread.evicted = true;
+          previous.thread.prompt = "[closed thread prompt evicted]";
+          previous.thread.result = undefined;
+          previous.thread.trace = [];
+          previous.thread.steering = [];
+          previous.thread.handoff = undefined;
+          previous.thread.timestamps = { ...previous.thread.timestamps, closedAt: record.closedAt };
+          previous.result = undefined;
+        }
+      } catch {
+        // A malformed custom entry must not prevent the parent session from starting.
+        continue;
+      }
+    }
+    return [...records.values()];
+  };
+
+  const installRestoredThreads = (restored: Array<{ thread: ThreadSnapshot; result?: SubagentTaskResult }>): void => {
+    if (!restored.length) return;
+    const ids = [...restored.map(({ thread }) => thread.id)];
+    let idIndex = 0;
+    const oldThreads = threads;
+    unsubscribePersistence();
+    threads = new SubagentThreadRegistry({ createId: () => ids[idIndex++] ?? `subagent-${Date.now()}` });
+    attachPersistence();
+    for (const entry of restored) {
+      try {
+        const thread = entry.thread;
+        const created = (threads as any).hydrate
+          ? (threads as any).hydrate(thread)
+          : threads.spawn({
+            parentId: thread.parentId as SubagentThreadId,
+            role: thread.role,
+            prompt: thread.prompt,
+            model: thread.model,
+            tools: thread.tools,
+            capabilityBoundary: thread.capabilityBoundary,
+            displayName: thread.displayName,
+            attempt: thread.attempt,
+            session: thread.session,
+          } as any);
+        threadMetadata.set(created.id, {
+          displayName: thread.displayName ?? thread.role,
+          attempt: thread.attempt ?? 1,
+          session: thread.session ?? { id: `killeros-${safeSessionId(thread.id)}`, directory: "" },
+          persistentSession: Boolean(thread.session?.directory),
+        });
+        if (entry.result) saveResult(created.id, entry.result);
+        if (!(threads as any).hydrate) {
+          if (thread.state === "done") {
+            threads.begin(created.id);
+            threads.complete(created.id, { result: thread.result ?? entry.result?.output });
+          } else if (thread.state === "failed") {
+            threads.begin(created.id);
+            threads.fail(created.id, { message: thread.failure?.message ?? entry.result?.errorMessage ?? "restored failure" });
+          } else if (thread.state === "stopped" || thread.state === "orphaned") {
+            threads.stop(created.id, { reason: thread.stopReason ?? "parent_restarted" });
+          }
+          if (thread.state === "closed") {
+            if (threads.inspect(created.id)?.state === "queued") threads.begin(created.id);
+            if (threads.inspect(created.id)?.state === "active") threads.stop(created.id, { reason: thread.stopReason ?? "closed" });
+            threads.close(created.id);
+          }
+        }
+      } catch {
+        // Skip malformed or conflicting records and keep the rest of the board usable.
+        continue;
+      }
+    }
+    if (oldThreads !== threads && !oldThreads.isDisposed) oldThreads.dispose();
+  };
+
+  attachPersistence();
+  const maxClosedThreads = Number.isSafeInteger(limits.threadRetentionRecords) && limits.threadRetentionRecords > 0
+    ? limits.threadRetentionRecords
+    : SUBAGENT_LIMITS.threadRetentionRecords;
+
+  const stopActiveRuntimes = (reason: string): void => {
+    for (const runtime of activeRuntimes.values()) {
+      runtime.restarting = false;
+      runtime.requestedReason = reason;
+      runtime.handle?.stop(reason);
+      runtime.controller.abort();
+    }
+  };
 
   const rememberEvictedThreads = (threadsToRemember: readonly SubagentThread[]): void => {
     for (const thread of threadsToRemember) evictedThreadParents.set(thread.id, thread.parentId);
@@ -1738,55 +1811,55 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
     trimSavedResults();
   };
 
-  const detailsFor = (
+  const detailsFor = (
     parentId: string,
     mode: SubagentDetails["mode"] = "single",
     scope: AgentScope = "user",
     projectAgentsDir: string | null = null,
     selectedThreadId?: string,
-  ): SubagentDetails => {
-    const all = threads.listAll().filter((thread) => thread.parentId === parentId);
-    const visible = all.filter((thread) => thread.state !== "closed").map((thread) => threadView(thread, threadMetadata));
-    const selectedClosed = selectedThreadId
-      ? all.find((thread) => thread.id === selectedThreadId && thread.state === "closed")
-      : undefined;
-    const listed = selectedClosed ? [...visible, threadView(selectedClosed, threadMetadata)] : visible;
-    const results = visible.map((thread) => {
-      const result = threadResult(thread, savedResults.get(thread.id));
-      result.name = threadDisplayName(thread, threadMetadata);
-      result.attempt = threadAttempt(thread, threadMetadata);
-      return result;
-    });
-    return {
-      ...cloneDetails(mode, scope, projectAgentsDir, results),
-      parentId,
-      executionNote: persistenceWarning,
-      threads: listed,
-      activeThreads: visible.filter((thread) => thread.state === "active"),
-      doneThreads: visible.filter((thread) => ["done", "failed", "stopped", "orphaned"].includes(thread.state)),
-      selectedThreadId,
-    };
-  };
+  ): SubagentDetails => {
+    const all = threads.listAll().filter((thread) => thread.parentId === parentId);
+    const visible = all.filter((thread) => thread.state !== "closed").map((thread) => threadView(thread, threadMetadata));
+    const selectedClosed = selectedThreadId
+      ? all.find((thread) => thread.id === selectedThreadId && thread.state === "closed")
+      : undefined;
+    const listed = selectedClosed ? [...visible, threadView(selectedClosed, threadMetadata)] : visible;
+    const results = visible.map((thread) => {
+      const result = threadResult(thread, savedResults.get(thread.id));
+      result.name = threadDisplayName(thread, threadMetadata);
+      result.attempt = threadAttempt(thread, threadMetadata);
+      return result;
+    });
+    return {
+      ...cloneDetails(mode, scope, projectAgentsDir, results),
+      parentId,
+      executionNote: persistenceWarning,
+      threads: listed,
+      activeThreads: visible.filter((thread) => thread.state === "active"),
+      doneThreads: visible.filter((thread) => ["done", "failed", "stopped", "orphaned"].includes(thread.state)),
+      selectedThreadId,
+    };
+  };
 
   const threadBoardText = (parentId: string, selectedThreadId?: string): string => {
     const details = detailsFor(parentId, "single", "user", null, selectedThreadId);
     const active = details.activeThreads ?? [];
     const done = details.doneThreads ?? [];
-    const row = (thread: ThreadSnapshot): string => `- ${threadDisplayName(thread, threadMetadata)} · ${thread.role} · ${thread.id} · ${thread.state} · ${thread.prompt}`;
+    const row = (thread: ThreadSnapshot): string => `- ${threadDisplayName(thread, threadMetadata)} · ${thread.role} · ${thread.id} · ${thread.state} · ${thread.prompt}`;
     const lines = [
       `parent ${parentId}`,
       `Active (${active.length})`,
       ...(active.length ? active.map(row) : ["- none"]),
       `Done (${done.length})`,
       ...(done.length ? done.map(row) : ["- none"]),
-      "Controls: inspect · wait · steer · interrupt · collect · resume · close",
+      "Controls: inspect · wait · steer · interrupt · collect · resume · close",
     ];
     if (selectedThreadId) {
       const selected = details.threads?.find((thread) => thread.id === selectedThreadId);
       if (selected) {
-        lines.push(`Inspect ${selected.id}: ${selected.state}`);
-        lines.push(`Name: ${threadDisplayName(selected, threadMetadata)}`);
-        lines.push(`Attempt: ${threadAttempt(selected, threadMetadata)}`);
+        lines.push(`Inspect ${selected.id}: ${selected.state}`);
+        lines.push(`Name: ${threadDisplayName(selected, threadMetadata)}`);
+        lines.push(`Attempt: ${threadAttempt(selected, threadMetadata)}`);
         lines.push(`Role: ${selected.role}`);
         lines.push(`Model: ${selected.model}`);
         lines.push(`Tools: ${selected.tools.join(", ")}`);
@@ -1799,11 +1872,11 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
     return boundedText(lines.join("\n"), limits.toolOutputBytes, "\n\n[Thread board truncated; inspect a child thread for its bounded detail.]");
   };
 
-  const syncThread = (threadId: SubagentThreadId, next: SubagentTaskResult, runtime?: ActiveThreadRuntime): SubagentTaskResult => {
-    const effective = mergeTaskResults(runtime?.aggregate, next, limits.traceRetentionBytes, limits.stderrRetentionBytes);
-    if (runtime?.requestedReason && next.status === "cancelled") effective.terminationReason = runtime.requestedReason;
-    if (runtime && runtime.sessionGeneration !== sessionGeneration) return effective;
-    saveResult(threadId, effective);
+  const syncThread = (threadId: SubagentThreadId, next: SubagentTaskResult, runtime?: ActiveThreadRuntime): SubagentTaskResult => {
+    const effective = mergeTaskResults(runtime?.aggregate, next, limits.traceRetentionBytes, limits.stderrRetentionBytes);
+    if (runtime?.requestedReason && next.status === "cancelled") effective.terminationReason = runtime.requestedReason;
+    if (runtime && runtime.sessionGeneration !== sessionGeneration) return effective;
+    saveResult(threadId, effective);
     let thread = threads.inspect(threadId);
     if (!thread || threads.isDisposed) return effective;
     if (thread.state === "queued" && next.status === "running") {
@@ -1845,193 +1918,193 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         reason: effective.terminationReason ?? (effective.status === "limited" ? "resource_limit" : "interrupted"),
       });
     }
-    return effective;
-  };
-
-  const resolveOwnedThread = (reference: string, parentId: string): ThreadSnapshot | undefined => {
-    const registry = threads as any;
-    const resolved = typeof registry.resolve === "function" ? registry.resolve(reference, parentId as SubagentThreadId) : undefined;
-    if (resolved && resolved.parentId === parentId) return threadView(resolved, threadMetadata);
-    const exact = threads.inspect(reference as SubagentThreadId);
-    if (exact && exact.parentId === parentId) return threadView(exact, threadMetadata);
-    const folded = reference.toLocaleLowerCase();
-    return threads.listAll()
-      .filter((thread) => thread.parentId === parentId)
-      .map((thread) => threadView(thread, threadMetadata))
-      .find((thread) => threadDisplayName(thread, threadMetadata).toLocaleLowerCase() === folded);
-  };
-
-  const terminalThread = (thread: ThreadSnapshot): boolean => ["done", "failed", "stopped", "orphaned", "closed"].includes(thread.state as string);
-
-  const waitForThreads = async (ids: readonly string[], timeoutMs: number): Promise<SubagentWaitSummary> => {
-    const startedAt = Date.now();
-    const targetIds = [...ids];
-    const status = (): { completed: string[]; pending: string[] } => {
-      const completed: string[] = [];
-      const pending: string[] = [];
-      for (const id of targetIds) {
-        const thread = threads.inspect(id as SubagentThreadId);
-        if (thread && terminalThread(threadView(thread, threadMetadata))) completed.push(id);
-        else pending.push(id);
-      }
-      return { completed, pending };
-    };
-    const initial = status();
-    if (!initial.pending.length) {
-      return { targetThreadIds: targetIds, completedThreadIds: initial.completed, pendingThreadIds: [], timedOut: false, waitedMs: 0 };
-    }
-    const registry = threads as any;
-    if (typeof registry.waitForTerminal === "function") {
-      const result = await registry.waitForTerminal(targetIds as SubagentThreadId[], timeoutMs);
-      return {
-        targetThreadIds: targetIds,
-        completedThreadIds: [...(result.completedThreadIds ?? [])],
-        pendingThreadIds: [...(result.pendingThreadIds ?? [])],
-        timedOut: result.timedOut === true,
-        waitedMs: result.waitedMs ?? Date.now() - startedAt,
-      };
-    }
-    return new Promise((resolve) => {
-      let timer: NodeJS.Timeout | undefined;
-      let unsubscribe = (): void => {};
-      const finish = (timedOut: boolean): void => {
-        if (timer) clearTimeout(timer);
-        unsubscribe();
-        const current = status();
-        resolve({
-          targetThreadIds: targetIds,
-          completedThreadIds: current.completed,
-          pendingThreadIds: current.pending,
-          timedOut,
-          waitedMs: Date.now() - startedAt,
-        });
-      };
-      unsubscribe = threads.subscribe(() => {
-        if (!status().pending.length) finish(false);
-      });
-      timer = setTimeout(() => finish(true), timeoutMs);
-      if (!status().pending.length) finish(false);
-    });
-  };
-
-  const resumeThread = (target: ThreadSnapshot, prompt: string | undefined): ThreadSnapshot => {
-    const registry = threads as any;
-    const previousResult = savedResults.get(target.id);
-    savedResults.delete(target.id);
-    if (typeof registry.resume === "function") {
-      try {
-        const resumed = registry.resume(target.id as SubagentThreadId, prompt);
-        const metadata = threadMetadata.get(target.id);
-        if (metadata) metadata.attempt += 1;
-        return threadView(resumed, threadMetadata);
-      } catch (error) {
-        if (previousResult) saveResult(target.id, previousResult);
-        throw error;
-      }
-    }
-    try {
-      const snapshots = threads.listAll().filter((thread) => thread.state !== "closed");
-      const ids = snapshots.map((thread) => thread.id);
-      let idIndex = 0;
-      unsubscribePersistence();
-      const previous = threads;
-      threads = new SubagentThreadRegistry({ createId: () => ids[idIndex++]! });
-      attachPersistence();
-      let resumed: ThreadSnapshot | undefined;
-      for (const snapshot of snapshots) {
-        const metadata = threadMetadata.get(snapshot.id) ?? {
-          displayName: threadDisplayName(snapshot, threadMetadata),
-          attempt: threadAttempt(snapshot, threadMetadata),
-          session: threadSession(snapshot, threadMetadata) ?? { id: `killeros-${safeSessionId(snapshot.id)}`, directory: "" },
-          persistentSession: Boolean(threadSession(snapshot, threadMetadata)?.directory),
-        };
-        const nextPrompt = snapshot.id === target.id && prompt ? prompt : snapshot.prompt;
-        const created = threads.spawn({
-          parentId: snapshot.parentId,
-          role: snapshot.role,
-          prompt: nextPrompt,
-          model: snapshot.model,
-          tools: snapshot.tools,
-          capabilityBoundary: snapshot.capabilityBoundary,
-          displayName: metadata.displayName,
-          attempt: snapshot.id === target.id ? metadata.attempt + 1 : metadata.attempt,
-          session: metadata.session,
-        } as any);
-        metadata.attempt = snapshot.id === target.id ? metadata.attempt + 1 : metadata.attempt;
-        threadMetadata.set(snapshot.id, metadata);
-        if (snapshot.id === target.id) {
-          resumed = threadView(created, threadMetadata);
-          continue;
-        }
-        if (snapshot.state === "done") {
-          threads.begin(created.id);
-          threads.complete(created.id, { result: snapshot.result });
-        } else if (snapshot.state === "failed") {
-          threads.begin(created.id);
-          threads.fail(created.id, { message: snapshot.failure?.message ?? "restored failure" });
-        } else if (snapshot.state === "stopped" || snapshot.state === "orphaned") {
-          threads.stop(created.id, { reason: snapshot.stopReason ?? "stopped" });
-        }
-      }
-      if (!resumed) throw new Error(`Unknown child thread ${JSON.stringify(target.id)}`);
-      if (!previous.isDisposed) previous.dispose();
-      return resumed;
-    } catch (error) {
-      if (previousResult) saveResult(target.id, previousResult);
-      throw error;
-    }
-  };
-
-  if (typeof pi.on === "function") {
-    pi.on("session_start", (_event, ctx) => {
-      sessionGeneration += 1;
-      stopActiveRuntimes("session_start");
-      threadResources.clear();
-      persistenceWarning = undefined;
-      unsubscribePersistence();
-      threads.dispose();
-      threads = new SubagentThreadRegistry();
-      threadMetadata.clear();
-      savedResults.clear();
-      evictedThreadParents.clear();
-      activeRuntimes.clear();
-      attachPersistence();
-      const entries = (ctx as ExtensionContext | undefined)?.sessionManager?.getEntries?.();
-      if (Array.isArray(entries)) {
-        const extensionContext = ctx as ExtensionContext;
-        installRestoredThreads(restoreRecords(
-          entries,
-          parentThreadId(extensionContext),
-          (threadId) => childSessionPath(extensionContext, threadId),
-        ));
-      }
-    });
-    pi.on("session_shutdown", async () => {
-      sessionGeneration += 1;
-      stopActiveRuntimes("session_shutdown");
-      await Promise.allSettled([...backgroundBatches]);
-      unsubscribePersistence();
-      for (const thread of threads.listAll()) {
-        if (["done", "failed", "stopped", "orphaned"].includes(thread.state as string)) {
-          recordSnapshot(thread, savedResults.get(thread.id));
-        }
-      }
-      threadResources.clear();
-      threads.dispose();
-      threadMetadata.clear();
-      savedResults.clear();
-      evictedThreadParents.clear();
-    });
-  }
-
-  const toolDefinition: Parameters<ExtensionAPI["registerTool"]>[0] = {
+    return effective;
+  };
+
+  const resolveOwnedThread = (reference: string, parentId: string): ThreadSnapshot | undefined => {
+    const registry = threads as any;
+    const resolved = typeof registry.resolve === "function" ? registry.resolve(reference, parentId as SubagentThreadId) : undefined;
+    if (resolved && resolved.parentId === parentId) return threadView(resolved, threadMetadata);
+    const exact = threads.inspect(reference as SubagentThreadId);
+    if (exact && exact.parentId === parentId) return threadView(exact, threadMetadata);
+    const folded = reference.toLocaleLowerCase();
+    return threads.listAll()
+      .filter((thread) => thread.parentId === parentId)
+      .map((thread) => threadView(thread, threadMetadata))
+      .find((thread) => threadDisplayName(thread, threadMetadata).toLocaleLowerCase() === folded);
+  };
+
+  const terminalThread = (thread: ThreadSnapshot): boolean => ["done", "failed", "stopped", "orphaned", "closed"].includes(thread.state as string);
+
+  const waitForThreads = async (ids: readonly string[], timeoutMs: number): Promise<SubagentWaitSummary> => {
+    const startedAt = Date.now();
+    const targetIds = [...ids];
+    const status = (): { completed: string[]; pending: string[] } => {
+      const completed: string[] = [];
+      const pending: string[] = [];
+      for (const id of targetIds) {
+        const thread = threads.inspect(id as SubagentThreadId);
+        if (thread && terminalThread(threadView(thread, threadMetadata))) completed.push(id);
+        else pending.push(id);
+      }
+      return { completed, pending };
+    };
+    const initial = status();
+    if (!initial.pending.length) {
+      return { targetThreadIds: targetIds, completedThreadIds: initial.completed, pendingThreadIds: [], timedOut: false, waitedMs: 0 };
+    }
+    const registry = threads as any;
+    if (typeof registry.waitForTerminal === "function") {
+      const result = await registry.waitForTerminal(targetIds as SubagentThreadId[], timeoutMs);
+      return {
+        targetThreadIds: targetIds,
+        completedThreadIds: [...(result.completedThreadIds ?? [])],
+        pendingThreadIds: [...(result.pendingThreadIds ?? [])],
+        timedOut: result.timedOut === true,
+        waitedMs: result.waitedMs ?? Date.now() - startedAt,
+      };
+    }
+    return new Promise((resolve) => {
+      let timer: NodeJS.Timeout | undefined;
+      let unsubscribe = (): void => {};
+      const finish = (timedOut: boolean): void => {
+        if (timer) clearTimeout(timer);
+        unsubscribe();
+        const current = status();
+        resolve({
+          targetThreadIds: targetIds,
+          completedThreadIds: current.completed,
+          pendingThreadIds: current.pending,
+          timedOut,
+          waitedMs: Date.now() - startedAt,
+        });
+      };
+      unsubscribe = threads.subscribe(() => {
+        if (!status().pending.length) finish(false);
+      });
+      timer = setTimeout(() => finish(true), timeoutMs);
+      if (!status().pending.length) finish(false);
+    });
+  };
+
+  const resumeThread = (target: ThreadSnapshot, prompt: string | undefined): ThreadSnapshot => {
+    const registry = threads as any;
+    const previousResult = savedResults.get(target.id);
+    savedResults.delete(target.id);
+    if (typeof registry.resume === "function") {
+      try {
+        const resumed = registry.resume(target.id as SubagentThreadId, prompt);
+        const metadata = threadMetadata.get(target.id);
+        if (metadata) metadata.attempt += 1;
+        return threadView(resumed, threadMetadata);
+      } catch (error) {
+        if (previousResult) saveResult(target.id, previousResult);
+        throw error;
+      }
+    }
+    try {
+      const snapshots = threads.listAll().filter((thread) => thread.state !== "closed");
+      const ids = snapshots.map((thread) => thread.id);
+      let idIndex = 0;
+      unsubscribePersistence();
+      const previous = threads;
+      threads = new SubagentThreadRegistry({ createId: () => ids[idIndex++]! });
+      attachPersistence();
+      let resumed: ThreadSnapshot | undefined;
+      for (const snapshot of snapshots) {
+        const metadata = threadMetadata.get(snapshot.id) ?? {
+          displayName: threadDisplayName(snapshot, threadMetadata),
+          attempt: threadAttempt(snapshot, threadMetadata),
+          session: threadSession(snapshot, threadMetadata) ?? { id: `killeros-${safeSessionId(snapshot.id)}`, directory: "" },
+          persistentSession: Boolean(threadSession(snapshot, threadMetadata)?.directory),
+        };
+        const nextPrompt = snapshot.id === target.id && prompt ? prompt : snapshot.prompt;
+        const created = threads.spawn({
+          parentId: snapshot.parentId,
+          role: snapshot.role,
+          prompt: nextPrompt,
+          model: snapshot.model,
+          tools: snapshot.tools,
+          capabilityBoundary: snapshot.capabilityBoundary,
+          displayName: metadata.displayName,
+          attempt: snapshot.id === target.id ? metadata.attempt + 1 : metadata.attempt,
+          session: metadata.session,
+        } as any);
+        metadata.attempt = snapshot.id === target.id ? metadata.attempt + 1 : metadata.attempt;
+        threadMetadata.set(snapshot.id, metadata);
+        if (snapshot.id === target.id) {
+          resumed = threadView(created, threadMetadata);
+          continue;
+        }
+        if (snapshot.state === "done") {
+          threads.begin(created.id);
+          threads.complete(created.id, { result: snapshot.result });
+        } else if (snapshot.state === "failed") {
+          threads.begin(created.id);
+          threads.fail(created.id, { message: snapshot.failure?.message ?? "restored failure" });
+        } else if (snapshot.state === "stopped" || snapshot.state === "orphaned") {
+          threads.stop(created.id, { reason: snapshot.stopReason ?? "stopped" });
+        }
+      }
+      if (!resumed) throw new Error(`Unknown child thread ${JSON.stringify(target.id)}`);
+      if (!previous.isDisposed) previous.dispose();
+      return resumed;
+    } catch (error) {
+      if (previousResult) saveResult(target.id, previousResult);
+      throw error;
+    }
+  };
+
+  if (typeof pi.on === "function") {
+    pi.on("session_start", (_event, ctx) => {
+      sessionGeneration += 1;
+      stopActiveRuntimes("session_start");
+      threadResources.clear();
+      persistenceWarning = undefined;
+      unsubscribePersistence();
+      threads.dispose();
+      threads = new SubagentThreadRegistry();
+      threadMetadata.clear();
+      savedResults.clear();
+      evictedThreadParents.clear();
+      activeRuntimes.clear();
+      attachPersistence();
+      const entries = (ctx as ExtensionContext | undefined)?.sessionManager?.getEntries?.();
+      if (Array.isArray(entries)) {
+        const extensionContext = ctx as ExtensionContext;
+        installRestoredThreads(restoreRecords(
+          entries,
+          parentThreadId(extensionContext),
+          (threadId) => childSessionPath(extensionContext, threadId),
+        ));
+      }
+    });
+    pi.on("session_shutdown", async () => {
+      sessionGeneration += 1;
+      stopActiveRuntimes("session_shutdown");
+      await Promise.allSettled([...backgroundBatches]);
+      unsubscribePersistence();
+      for (const thread of threads.listAll()) {
+        if (["done", "failed", "stopped", "orphaned"].includes(thread.state as string)) {
+          recordSnapshot(thread, savedResults.get(thread.id));
+        }
+      }
+      threadResources.clear();
+      threads.dispose();
+      threadMetadata.clear();
+      savedResults.clear();
+      evictedThreadParents.clear();
+    });
+  }
+
+  const toolDefinition: Parameters<ExtensionAPI["registerTool"]>[0] = {
     name: "subagent",
     label: "Subagents",
-    description: `Spawn and manage named child threads. Children finish naturally. Parallel tasks with write-capable roles use one shared slot; read-only batches run concurrently up to ${limits.maxReadConcurrency}. Write-capable tasks are serialized in the shared parent worktree. The message parameter is only valid with action steer. Use action list, inspect, wait, steer, interrupt, collect, resume, and close to manage child handoffs.`,
+    description: `Spawn and manage named child threads. Bundled roles: debugger, documenter, planner, reviewer, scout, security, tester, worker. Agent accepts a role name or an inline { name, description, access, tools } role. On spawn, message aliases task. Parallel tasks with write-capable roles use one shared slot; read-only batches run concurrently up to ${limits.maxReadConcurrency}. Write-capable tasks are serialized in the shared parent worktree. Use action list, inspect, wait, steer, interrupt, collect, resume, and close to manage child handoffs.`,
     promptSnippet: "Delegate bounded specialist work to isolated KillerOS subagents",
     promptGuidelines: [
       "Use subagent for clearly separable specialist work; prefer read-only scout, planner, reviewer, or security roles before a writer.",
-      "Parallel tasks with write-capable roles use one shared slot because all children share the parent worktree.",
+      "Parallel tasks with write-capable roles use one shared slot because all children share the parent worktree.",
       "Every child can load relevant skills with read and can use web_search, source_check, fetch_content, and get_search_content for external research.",
       "When the user names a model or thinking effort, pass model and thinking separately; use inherit when the active parent or role setting should decide.",
       "Keep completed and stopped threads inspectable until the parent explicitly closes them.",
@@ -2053,57 +2126,57 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
           details,
           usage: details.aggregateUsage,
         };
-      };
-
-      if (request.kind === "list") return actionResult(threadBoardText(parentId));
-      if (request.kind === "inspect") {
-        const { threadId } = request.input;
-        const thread = resolveOwnedThread(threadId, parentId);
-        if (!thread) {
+      };
+
+      if (request.kind === "list") return actionResult(threadBoardText(parentId));
+      if (request.kind === "inspect") {
+        const { threadId } = request.input;
+        const thread = resolveOwnedThread(threadId, parentId);
+        if (!thread) {
           if (evictedThreadParents.get(threadId) === parentId) {
             return actionResult(`Thread ${threadId} was evicted from bounded retention; its heavy data is no longer available.`, threadId);
           }
           throw new Error(`Unknown child thread ${JSON.stringify(threadId)}`);
         }
-        return actionResult(threadBoardText(parentId, thread.id), thread.id);
-      }
-      if (request.kind === "steer") {
-        const { threadId, message } = request.input;
-        const thread = resolveOwnedThread(threadId, parentId);
-        if (!thread) throw new Error(`Unknown child thread ${JSON.stringify(threadId)}`);
-        const brandedThreadId = thread.id as SubagentThreadId;
-        const runtime = activeRuntimes.get(thread.id);
-        const pendingCount = runtime ? runtime.steering.length : thread.steering.length;
-        if (pendingCount >= MAX_RUNTIME_STEERING_MESSAGES) {
-          throw new Error(`Steering queue is full (${MAX_RUNTIME_STEERING_MESSAGES} pending messages); wait for the child restart or interrupt the thread first`);
-        }
-        const pendingSteering = runtime
-          ? [...runtime.steering, message]
-          : [...thread.steering.map((entry) => entry.message), message];
-        const baseTask = runtime?.task ?? thread.prompt;
-        if (steeredTaskWouldExceedLimit(baseTask, pendingSteering, limits.taskCharacters)) {
-          throw new Error(`Steering would exceed the ${limits.taskCharacters}-character task limit; shorten the message or wait for the child restart`);
-        }
-        threads.steer(brandedThreadId, message);
+        return actionResult(threadBoardText(parentId, thread.id), thread.id);
+      }
+      if (request.kind === "steer") {
+        const { threadId, message } = request.input;
+        const thread = resolveOwnedThread(threadId, parentId);
+        if (!thread) throw new Error(`Unknown child thread ${JSON.stringify(threadId)}`);
+        const brandedThreadId = thread.id as SubagentThreadId;
+        const runtime = activeRuntimes.get(thread.id);
+        const pendingCount = runtime ? runtime.steering.length : thread.steering.length;
+        if (pendingCount >= MAX_RUNTIME_STEERING_MESSAGES) {
+          throw new Error(`Steering queue is full (${MAX_RUNTIME_STEERING_MESSAGES} pending messages); wait for the child restart or interrupt the thread first`);
+        }
+        const pendingSteering = runtime
+          ? [...runtime.steering, message]
+          : [...thread.steering.map((entry) => entry.message), message];
+        const baseTask = runtime?.task ?? thread.prompt;
+        if (steeredTaskWouldExceedLimit(baseTask, pendingSteering, limits.taskCharacters)) {
+          throw new Error(`Steering would exceed the ${limits.taskCharacters}-character task limit; shorten the message or wait for the child restart`);
+        }
+        threads.steer(brandedThreadId, message);
         if (runtime) {
           runtime.steering.push(message);
           runtime.restarting = true;
           runtime.requestedReason = "steer";
           runtime.handle?.stop("steer");
         }
-        return actionResult(`Steering queued for ${threadDisplayName(thread, threadMetadata)} (${thread.id}). The child keeps the same thread and handoff record.`, thread.id);
-      }
-      if (request.kind === "interrupt-one" || request.kind === "interrupt-all") {
-        let targets: SubagentThread[];
+        return actionResult(`Steering queued for ${threadDisplayName(thread, threadMetadata)} (${thread.id}). The child keeps the same thread and handoff record.`, thread.id);
+      }
+      if (request.kind === "interrupt-one" || request.kind === "interrupt-all") {
+        let targets: SubagentThread[];
         if (request.kind === "interrupt-all") {
           targets = threads.listAll().filter((thread) => thread.parentId === parentId && (thread.state === "active" || thread.state === "queued"));
-        } else {
-          const { threadId } = request.input;
-          const target = resolveOwnedThread(threadId, parentId);
-          if (!target) throw new Error(`Unknown child thread ${JSON.stringify(threadId)}`);
-          if (target.state !== "active" && target.state !== "queued") {
-            throw new Error(`Cannot interrupt thread ${threadId} from ${target.state}`);
-          }
+        } else {
+          const { threadId } = request.input;
+          const target = resolveOwnedThread(threadId, parentId);
+          if (!target) throw new Error(`Unknown child thread ${JSON.stringify(threadId)}`);
+          if (target.state !== "active" && target.state !== "queued") {
+            throw new Error(`Cannot interrupt thread ${threadId} from ${target.state}`);
+          }
           targets = [target];
         }
         for (const thread of targets) {
@@ -2117,95 +2190,98 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
           } else if (thread.state === "active" || thread.state === "queued") {
             threads.stop(thread.id, { reason: "interrupt" });
           }
-        }
-        return actionResult(request.kind === "interrupt-all"
-          ? "Interrupt requested for all active and queued child threads."
-          : `Interrupt requested for ${targets[0]?.id} (${threadDisplayName(targets[0] as ThreadSnapshot, threadMetadata)}).`);
-      }
-      if (request.kind === "collect") {
-        const { threadId } = request.input;
-        const thread = resolveOwnedThread(threadId, parentId);
-        if (!thread) throw new Error(`Unknown child thread ${JSON.stringify(threadId)}`);
-        const collected = threads.collect(thread.id as SubagentThreadId);
-        return actionResult(`Collected ${threadDisplayName(thread, threadMetadata)} (${thread.id}): ${collected.result ?? collected.failure?.message ?? collected.stopReason ?? "no handoff"}`, thread.id);
-      }
-      if (request.kind === "wait") {
-        const target = request.input.threadId ? resolveOwnedThread(request.input.threadId, parentId) : undefined;
-        if (request.input.threadId && !target) throw new Error(`Unknown child thread ${JSON.stringify(request.input.threadId)}`);
-        const targets = target
-          ? [target]
-          : threads.listAll().filter((thread) => thread.parentId === parentId && (thread.state === "queued" || thread.state === "active"));
-        const wait = await waitForThreads(targets.map((thread) => thread.id), request.input.timeoutMs);
-        const details = actionDetails(target?.id);
-        details.wait = wait;
-        return {
-          content: [{ type: "text" as const, text: boundedText(
-            wait.timedOut
-              ? `Wait timed out after ${wait.waitedMs}ms. Pending: ${wait.pendingThreadIds.join(", ") || "none"}.`
-              : `Wait complete after ${wait.waitedMs}ms. Completed: ${wait.completedThreadIds.join(", ") || "none"}.`,
-            limits.toolOutputBytes,
-            "\n\n[Thread action output truncated.]",
-          ) }],
-          details,
-          usage: details.aggregateUsage,
-        };
-      }
-      if (request.kind === "close") {
-        const { threadId } = request.input;
-        const thread = resolveOwnedThread(threadId, parentId);
-        if (!thread) throw new Error(`Unknown child thread ${JSON.stringify(threadId)}`);
-        if (thread.state === "queued" || thread.state === "active") {
-          throw new Error(`Cannot close thread ${thread.id} from ${thread.state}`);
-        }
-        const resource = threadResources.get(thread.id);
-        const exits = resource ? await Promise.all([...resource.handles].map((handle) => waitForConfirmedProcessExit(handle, limits.processExitWaitMs))) : [];
-        const exitConfirmed = exits.every(Boolean);
-        if (!exitConfirmed) {
-          const current = savedResults.get(thread.id);
-          if (current) {
-            const failed = cloneResult(current);
-            failed.status = "failed";
-            failed.terminationReason = "process_exit_unconfirmed";
-            failed.exitConfirmed = false;
-            failed.errorMessage = "Child process exit was not confirmed before close";
-            saveResult(thread.id, failed);
-            recordSnapshot(thread, failed);
-          }
-        } else {
-          const session = threadSession(thread, threadMetadata);
-          const directory = resource?.directory ?? session?.directory;
-          const expectedDirectory = childSessionPath(ctx, thread.id)?.directory;
-          const trustedRestoredDirectory = !resource && directory && expectedDirectory
-            && path.resolve(directory) === path.resolve(expectedDirectory);
-          if ((resource?.persistent || trustedRestoredDirectory) && directory) {
-            await rm(directory, { recursive: true, force: true });
-          }
-        }
-        threads.close(thread.id as SubagentThreadId);
-        if (exitConfirmed) threadResources.delete(thread.id);
-        savedResults.delete(thread.id);
-        pruneClosedThreads();
-        return actionResult(exitConfirmed
-          ? `Closed ${threadDisplayName(thread, threadMetadata)} (${thread.id}). Heavy trace and handoff data were evicted; a tombstone remains inspectable.`
-          : `Closed ${threadDisplayName(thread, threadMetadata)} (${thread.id}); process exit was not confirmed, so its session directory was retained.`, thread.id);
-      }
-
-      let resumeTarget: ThreadSnapshot | undefined;
-      let resumePrompt: string | undefined;
-      const isResume = request.kind === "resume";
+        }
+        return actionResult(request.kind === "interrupt-all"
+          ? "Interrupt requested for all active and queued child threads."
+          : `Interrupt requested for ${targets[0]?.id} (${threadDisplayName(targets[0] as ThreadSnapshot, threadMetadata)}).`);
+      }
+      if (request.kind === "collect") {
+        const { threadId } = request.input;
+        const thread = resolveOwnedThread(threadId, parentId);
+        if (!thread) throw new Error(`Unknown child thread ${JSON.stringify(threadId)}`);
+        const collected = threads.collect(thread.id as SubagentThreadId);
+        return actionResult(`Collected ${threadDisplayName(thread, threadMetadata)} (${thread.id}): ${collected.result ?? collected.failure?.message ?? collected.stopReason ?? "no handoff"}`, thread.id);
+      }
+      if (request.kind === "wait") {
+        const target = request.input.threadId ? resolveOwnedThread(request.input.threadId, parentId) : undefined;
+        if (request.input.threadId && !target) throw new Error(`Unknown child thread ${JSON.stringify(request.input.threadId)}`);
+        const targets = target
+          ? [target]
+          : threads.listAll().filter((thread) => thread.parentId === parentId && (thread.state === "queued" || thread.state === "active"));
+        const wait = await waitForThreads(targets.map((thread) => thread.id), request.input.timeoutMs);
+        const details = actionDetails(target?.id);
+        details.wait = wait;
+        return {
+          content: [{ type: "text" as const, text: boundedText(
+            wait.timedOut
+              ? `Wait timed out after ${wait.waitedMs}ms. Pending: ${wait.pendingThreadIds.join(", ") || "none"}.`
+              : `Wait complete after ${wait.waitedMs}ms. Completed: ${wait.completedThreadIds.join(", ") || "none"}.`,
+            limits.toolOutputBytes,
+            "\n\n[Thread action output truncated.]",
+          ) }],
+          details,
+          usage: details.aggregateUsage,
+        };
+      }
+      if (request.kind === "close") {
+        const { threadId } = request.input;
+        const thread = resolveOwnedThread(threadId, parentId);
+        if (!thread) throw new Error(`Unknown child thread ${JSON.stringify(threadId)}`);
+        if (thread.state === "queued" || thread.state === "active") {
+          throw new Error(`Cannot close thread ${thread.id} from ${thread.state}`);
+        }
+        const resource = threadResources.get(thread.id);
+        const exits = resource ? await Promise.all([...resource.handles].map((handle) => waitForConfirmedProcessExit(handle, limits.processExitWaitMs))) : [];
+        const exitConfirmed = exits.every(Boolean);
+        if (!exitConfirmed) {
+          const current = savedResults.get(thread.id);
+          if (current) {
+            const failed = cloneResult(current);
+            failed.status = "failed";
+            failed.terminationReason = "process_exit_unconfirmed";
+            failed.exitConfirmed = false;
+            failed.errorMessage = "Child process exit was not confirmed before close";
+            saveResult(thread.id, failed);
+            recordSnapshot(thread, failed);
+          }
+        } else {
+          const session = threadSession(thread, threadMetadata);
+          const directory = resource?.directory ?? session?.directory;
+          const expectedDirectory = childSessionPath(ctx, thread.id)?.directory;
+          const trustedRestoredDirectory = !resource && directory && expectedDirectory
+            && path.resolve(directory) === path.resolve(expectedDirectory);
+          if ((resource?.persistent || trustedRestoredDirectory) && directory) {
+            await rm(directory, { recursive: true, force: true });
+          }
+        }
+        threads.close(thread.id as SubagentThreadId);
+        if (exitConfirmed) threadResources.delete(thread.id);
+        savedResults.delete(thread.id);
+        pruneClosedThreads();
+        return actionResult(exitConfirmed
+          ? `Closed ${threadDisplayName(thread, threadMetadata)} (${thread.id}). Heavy trace and handoff data were evicted; a tombstone remains inspectable.`
+          : `Closed ${threadDisplayName(thread, threadMetadata)} (${thread.id}); process exit was not confirmed, so its session directory was retained.`, thread.id);
+      }
+
+      let resumeTarget: ThreadSnapshot | undefined;
+      let resumePrompt: string | undefined;
+      const isResume = request.kind === "resume";
       if (isResume) {
         const target = resolveOwnedThread(request.input.threadId, parentId);
         if (!target) throw new Error(`Unknown child thread ${JSON.stringify(request.input.threadId)}`);
         if (!terminalThread(target) || target.state === "closed") {
           throw new Error(`Cannot resume thread ${target.id} from ${target.state}`);
         }
+        if (savedResults.get(target.id)?.agentSource === "inline") {
+          throw new Error(`Cannot resume inline role ${JSON.stringify(target.role)}; inline roles are scoped to one spawn`);
+        }
         resumePrompt = request.input.task;
-        resumeTarget = target;
-      }
-      const spawnRequest = (isResume
-        ? { kind: "spawn-single", input: { agent: resumeTarget!.role, task: resumePrompt ?? resumeTarget!.prompt } }
-        : request) as Extract<NormalizedSubagentRequest, { kind: "spawn-single" | "spawn-parallel" | "spawn-chain" }>;
-      const params = spawnRequest.input;
+        resumeTarget = target;
+      }
+      const spawnRequest = (isResume
+        ? { kind: "spawn-single", input: { agent: resumeTarget!.role, task: resumePrompt ?? resumeTarget!.prompt } }
+        : request) as Extract<NormalizedSubagentRequest, { kind: "spawn-single" | "spawn-parallel" | "spawn-chain" }>;
+      const params = spawnRequest.input;
       const scope: AgentScope = params.agentScope ?? "user";
       const hasParallel = spawnRequest.kind === "spawn-parallel";
       const hasChain = spawnRequest.kind === "spawn-chain";
@@ -2213,15 +2289,28 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
 
       const discovery = discoverAgentRoles(ctx.cwd, scope, ctx.isProjectTrusted(), options);
       const roles = new Map(discovery.agents.map((agent) => [agent.name, agent]));
-      const requested = requestedAgents(params);
-      for (const name of requested) {
-        if (!roles.has(name)) {
-          const available = discovery.agents.map((agent) => `${agent.name} (${agent.source})`).join(", ") || "none";
-          throw new Error(`Unknown subagent ${JSON.stringify(name)}. Available: ${available}`);
-        }
-      }
+      const rawInputs: TaskInput[] = spawnRequest.kind === "spawn-single"
+        ? [{ agent: spawnRequest.input.agent, task: spawnRequest.input.task, ...(spawnRequest.input.name ? { name: spawnRequest.input.name } : {}) }]
+        : spawnRequest.kind === "spawn-parallel" ? spawnRequest.input.tasks : spawnRequest.input.chain;
+      const rolesForInputs = rawInputs.map((input) => {
+        if (typeof input.agent !== "string") {
+          const parentTools = new Set(pi.getActiveTools());
+          for (const tool of input.agent.tools) {
+            if (!parentTools.has(tool)) throw new Error(`Inline role ${JSON.stringify(input.agent.name)} tool ${JSON.stringify(tool)} is not active for the parent`);
+          }
+          return inlineAgentRole(input.agent);
+        }
+        const selected = roles.get(input.agent);
+        if (selected) return selected;
+        const available = discovery.agents.map((agent) => `${agent.name} (${agent.source})`).join(", ") || "none";
+        throw new Error(`Unknown subagent ${JSON.stringify(input.agent)}. Available: ${available}`);
+      });
+      const inputs: Array<Omit<TaskInput, "agent"> & { agent: string }> = rawInputs.map((input, index) => ({
+        ...input,
+        agent: rolesForInputs[index]!.name,
+      }));
 
-      const projectRoles = [...new Set(requested.map((name) => roles.get(name)!).filter((role) => role.source === "project"))];
+      const projectRoles = [...new Set(rolesForInputs.filter((role) => role.source === "project"))];
       if (projectRoles.length) {
         if (!ctx.hasUI) throw new Error("Project-local subagents require interactive confirmation");
         const approved = await ctx.ui.confirm(
@@ -2231,80 +2320,107 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         if (!approved) throw new Error("Project-local subagents were not approved");
       }
 
-      const resolvedModels = new Map<string, ResolvedModel>();
-      for (const name of new Set(requested)) {
-        resolvedModels.set(name, resolveAgentModel(roles.get(name)!, ctx, params.model, params.thinking));
-      }
+      const resolvedModels = rolesForInputs.map((role) => resolveAgentModel(role, ctx, params.model, params.thinking));
 
-      const mode: SubagentDetails["mode"] = hasParallel ? "parallel" : hasChain ? "chain" : "single";
-      const inputs: TaskInput[] = spawnRequest.kind === "spawn-single"
-        ? [{ agent: spawnRequest.input.agent, task: spawnRequest.input.task, ...(spawnRequest.input.name ? { name: spawnRequest.input.name } : {}) }]
-        : spawnRequest.kind === "spawn-parallel" ? spawnRequest.input.tasks : spawnRequest.input.chain;
+      const mode: SubagentDetails["mode"] = hasParallel ? "parallel" : hasChain ? "chain" : "single";
       if (inputs.length > limits.maxTasks) throw new Error(`At most ${limits.maxTasks} subagent tasks are allowed`);
       const readIndexes = hasParallel
-        ? inputs.map((input, index) => ({ input, index })).filter(({ input }) => roles.get(input.agent)!.access === "read")
+        ? inputs.map((input, index) => ({ input, index })).filter(({ index }) => rolesForInputs[index]!.access === "read")
         : [];
       const writerIndexes = hasParallel
-        ? inputs.map((input, index) => ({ input, index })).filter(({ input }) => roles.get(input.agent)!.access === "write").map(({ index }) => index)
+        ? inputs.map((input, index) => ({ input, index })).filter(({ index }) => rolesForInputs[index]!.access === "write").map(({ index }) => index)
         : [];
-      if (writerConcurrencyOverride !== undefined && writerIndexes.length === 0) {
-        throw new Error("writerConcurrency requires at least one write-capable role");
-      }
-      if (writerIndexes.length > 0 && writerConcurrencyOverride !== undefined && writerConcurrencyOverride > 1) {
-        throw new Error("writerConcurrency above 1 is not allowed for write-capable tasks because child threads share the parent worktree; use 1");
-      }
-      const writerConcurrency = writerConcurrencyOverride ?? (writerIndexes.length > 0 ? 1 : limits.maxReadConcurrency);
+      if (writerConcurrencyOverride !== undefined && writerIndexes.length === 0) {
+        throw new Error("writerConcurrency requires at least one write-capable role");
+      }
+      if (writerIndexes.length > 0 && writerConcurrencyOverride !== undefined && writerConcurrencyOverride > 1) {
+        throw new Error("writerConcurrency above 1 is not allowed for write-capable tasks because child threads share the parent worktree; use 1");
+      }
+      const writerConcurrency = writerConcurrencyOverride ?? (writerIndexes.length > 0 ? 1 : limits.maxReadConcurrency);
       const useSharedParallelPool = hasParallel && writerIndexes.length > 0;
-      const executionNote = hasParallel
+      const scheduleNote = hasParallel
         ? writerIndexes.length
-          ? `Parallel schedule: all tasks run through a shared pool of up to ${writerConcurrency}${writerConcurrencyOverride === undefined ? " (safe default)" : " (explicit)"}. Write-capable tasks are serialized in the shared parent worktree.`
+          ? `Parallel schedule: all tasks run through a shared pool of up to ${writerConcurrency}${writerConcurrencyOverride === undefined ? " (safe default)" : " (explicit)"}. Write-capable tasks are serialized in the shared parent worktree.`
           : `Parallel schedule: read-only tasks run concurrently up to ${limits.maxReadConcurrency}.`
         : undefined;
+      const executionNote = scheduleNote;
 
       const inFlight = threads.listAll().filter((thread) => ["queued", "active"].includes(thread.state)).length;
       if (inFlight + inputs.length > limits.maxTasks) {
         throw new Error(`At most ${limits.maxTasks} child threads may be active at once`);
       }
 
-      const existingThreads = threads.listAll().filter((thread) => thread.parentId === parentId).map((thread) => threadView(thread, threadMetadata));
-      const allocatedNames = new Set<string>();
-      if (isResume) resumeTarget = resumeThread(resumeTarget!, resumePrompt);
-      const threadRecords = isResume
-        ? [resumeTarget!]
-        : inputs.map((input) => {
-        const allocated = [...allocatedNames].map((name) => ({ role: name, displayName: name } as ThreadSnapshot));
-        const displayName = input.name ?? defaultThreadName(input.agent, [...existingThreads, ...allocated]);
-        validateThreadName(displayName);
-        const duplicate = [...existingThreads, ...allocated]
-          .some((thread) => threadDisplayName(thread, threadMetadata).toLocaleLowerCase() === displayName.toLocaleLowerCase());
-        if (duplicate) throw new Error(`Child display name ${JSON.stringify(displayName)} already exists for this parent`);
-        allocatedNames.add(displayName.toLocaleLowerCase());
-        const thread = threads.spawn({
-          parentId: parentId as SubagentThreadId,
-          role: input.agent,
-          prompt: input.task,
-          model: resolvedModels.get(input.agent)!.model,
-          tools: roles.get(input.agent)!.tools,
-          capabilityBoundary: threadCapabilityBoundary(roles.get(input.agent)!),
-          displayName,
-          attempt: 1,
-          session: { id: "killeros-pending", directory: path.join(os.tmpdir(), "killeros-subagent-pending") },
-        } as any);
-        const session = childSessionPath(ctx, thread.id) ?? { id: `killeros-${safeSessionId(thread.id)}`, directory: "" };
-        threadMetadata.set(thread.id, { displayName, attempt: 1, session, persistentSession: Boolean(session.directory) });
-        recordSpawn(thread);
-        return thread;
-      });
-      const results = threadRecords.map((thread, index) => {
-        const metadata = threadMetadata.get(thread.id)!;
-        return makeQueuedResult(thread.id, inputs[index]!.agent, inputs[index]!.task, hasChain ? index + 1 : undefined, metadata.displayName, metadata.attempt);
-      });
-      const batchSessionGeneration = sessionGeneration;
-      let updatesOpen = true;
-      const emit = (message = `${mode}: ${results.filter((result) => !["queued", "running"].includes(result.status)).length}/${results.length} settled`): void => {
-        if (!updatesOpen || batchSessionGeneration !== sessionGeneration) return;
-        const board = detailsFor(parentId, mode, scope, discovery.projectAgentsDir, isResume ? resumeTarget?.id : undefined);
+      const existingThreads = threads.listAll().filter((thread) => thread.parentId === parentId).map((thread) => threadView(thread, threadMetadata));
+      const allocatedNames = new Set<string>();
+      if (isResume) resumeTarget = resumeThread(resumeTarget!, resumePrompt);
+      const threadRecords = isResume
+        ? [resumeTarget!]
+        : inputs.map((input, index) => {
+        const allocated = [...allocatedNames].map((name) => ({ role: name, displayName: name } as ThreadSnapshot));
+        const displayName = input.name ?? defaultThreadName(input.agent, [...existingThreads, ...allocated]);
+        validateThreadName(displayName);
+        const duplicate = [...existingThreads, ...allocated]
+          .some((thread) => threadDisplayName(thread, threadMetadata).toLocaleLowerCase() === displayName.toLocaleLowerCase());
+        if (duplicate) throw new Error(`Child display name ${JSON.stringify(displayName)} already exists for this parent`);
+        allocatedNames.add(displayName.toLocaleLowerCase());
+        const thread = threads.spawn({
+          parentId: parentId as SubagentThreadId,
+          role: input.agent,
+          prompt: input.task,
+          model: resolvedModels[index]!.model,
+          tools: rolesForInputs[index]!.tools,
+          capabilityBoundary: threadCapabilityBoundary(rolesForInputs[index]!),
+          displayName,
+          attempt: 1,
+          session: { id: "killeros-pending", directory: path.join(os.tmpdir(), "killeros-subagent-pending") },
+        } as any);
+        const session = childSessionPath(ctx, thread.id) ?? { id: `killeros-${safeSessionId(thread.id)}`, directory: "" };
+        threadMetadata.set(thread.id, { displayName, attempt: 1, session, persistentSession: Boolean(session.directory) });
+        recordSpawn(thread);
+        return thread;
+      });
+      const results = threadRecords.map((thread, index) => {
+        const metadata = threadMetadata.get(thread.id)!;
+        return makeQueuedResult(thread.id, inputs[index]!.agent, inputs[index]!.task, hasChain ? index + 1 : undefined, metadata.displayName, metadata.attempt);
+      });
+      const batchSessionGeneration = sessionGeneration;
+      const liveWidgetKey = `killeros-subagents:${results[0]!.id}`;
+      const showLiveWidget = options.awaitSpawnCompletion !== true && ctx.hasUI;
+      const updateLiveWidget = (currentResults: SubagentTaskResult[]): void => {
+        if (!showLiveWidget) return;
+        const board = formatThreadBoard({
+          title: `Subagents · ${mode} · live`,
+          threads: currentResults.map(threadBoardRecord),
+        });
+        const row = (task: (typeof board.active)[number]): string => `${task.state.label} · ${task.displayName ?? task.agent} · ${task.usage.text}`;
+        try {
+          ctx.ui.setWidget(liveWidgetKey, [
+            board.title,
+            `Active (${board.active.length})`,
+            ...(board.active.length ? board.active.map(row) : ["None"]),
+            `Done (${board.done.length})`,
+            ...(board.done.length ? board.done.map(row) : ["None"]),
+            `Total · ${formatUsage(aggregateUsage(currentResults))}`,
+          ]);
+        } catch {
+          // Live UI updates must not fail the child batch.
+        }
+      };
+      const clearLiveWidget = (): void => {
+        if (!showLiveWidget) return;
+        try {
+          ctx.ui.setWidget(liveWidgetKey, undefined);
+        } catch {
+          // The session may close before the child batch settles.
+        }
+      };
+      let updatesOpen = true;
+      const emit = (message = `${mode}: ${results.filter((result) => !["queued", "running"].includes(result.status)).length}/${results.length} settled`): void => {
+        if (batchSessionGeneration !== sessionGeneration) return;
+        const board = detailsFor(parentId, mode, scope, discovery.projectAgentsDir, isResume ? resumeTarget?.id : undefined);
         const currentResults = results.map(cloneResult);
+        updateLiveWidget(currentResults);
+        if (!updatesOpen) return;
         try {
           (onUpdate as ToolUpdate | undefined)?.({
             content: [{ type: "text", text: message }],
@@ -2313,10 +2429,10 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         } catch {
           // Host update callbacks are telemetry; failures must not fail the batch.
         }
-      };
-      const failQueuedTask = (index: number, reason: string, message: string): void => {
-        if (batchSessionGeneration !== sessionGeneration) return;
-        const threadId = threadRecords[index]!.id;
+      };
+      const failQueuedTask = (index: number, reason: string, message: string): void => {
+        if (batchSessionGeneration !== sessionGeneration) return;
+        const threadId = threadRecords[index]!.id;
         const thread = threads.inspect(threadId);
         if (thread?.state === "queued") threads.begin(threadId);
         results[index] = {
@@ -2328,13 +2444,13 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         if (threads.inspect(threadId)?.state === "active") threads.fail(threadId, { message, code: reason });
         saveResult(threadId, results[index]!);
         emit();
-      };
-      const runAt = async (index: number, task: string): Promise<void> => {
-        if (batchSessionGeneration !== sessionGeneration) {
-          results[index] = { ...results[index]!, status: "cancelled", terminationReason: "session_start" };
-          return;
-        }
-        const threadId = threadRecords[index]!.id;
+      };
+      const runAt = async (index: number, task: string): Promise<void> => {
+        if (batchSessionGeneration !== sessionGeneration) {
+          results[index] = { ...results[index]!, status: "cancelled", terminationReason: "session_start" };
+          return;
+        }
+        const threadId = threadRecords[index]!.id;
         const initialThread = threads.inspect(threadId);
         if (signal?.aborted) {
           results[index] = { ...results[index]!, status: "cancelled", terminationReason: "abort" };
@@ -2357,29 +2473,29 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
           return;
         }
         if (initialThread.state !== "queued") return;
-        const input = inputs[index]!;
-        threads.begin(threadId);
-        const queuedSteering = initialThread.steering.map((entry) => entry.message);
-        if (codePointLength(task) > limits.taskCharacters) {
-          failQueuedTask(index, "task_limit", `Expanded task exceeds ${limits.taskCharacters} characters`);
-          return;
-        }
-        if (steeredTaskWouldExceedLimit(task, queuedSteering, limits.taskCharacters)) {
-          failQueuedTask(index, "steering_task_limit", `Expanded task plus steering exceeds ${limits.taskCharacters} characters`);
-          return;
-        }
-        const controller = new AbortController();
-        const runtime: ActiveThreadRuntime = {
-          controller,
-          handles: new Set(),
-          task,
-          steering: [],
-          restarting: false,
-          traceCount: 0,
-          startedAt: Date.now(),
-          sessionGeneration: batchSessionGeneration,
-          aggregate: isResume ? savedResults.get(threadId) && cloneResult(savedResults.get(threadId)!) : undefined,
-        };
+        const input = inputs[index]!;
+        threads.begin(threadId);
+        const queuedSteering = initialThread.steering.map((entry) => entry.message);
+        if (codePointLength(task) > limits.taskCharacters) {
+          failQueuedTask(index, "task_limit", `Expanded task exceeds ${limits.taskCharacters} characters`);
+          return;
+        }
+        if (steeredTaskWouldExceedLimit(task, queuedSteering, limits.taskCharacters)) {
+          failQueuedTask(index, "steering_task_limit", `Expanded task plus steering exceeds ${limits.taskCharacters} characters`);
+          return;
+        }
+        const controller = new AbortController();
+        const runtime: ActiveThreadRuntime = {
+          controller,
+          handles: new Set(),
+          task,
+          steering: [],
+          restarting: false,
+          traceCount: 0,
+          startedAt: Date.now(),
+          sessionGeneration: batchSessionGeneration,
+          aggregate: isResume ? savedResults.get(threadId) && cloneResult(savedResults.get(threadId)!) : undefined,
+        };
         const abortFromParent = (): void => {
           runtime.restarting = false;
           runtime.requestedReason = "abort";
@@ -2389,30 +2505,30 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         signal?.addEventListener("abort", abortFromParent, { once: true });
         if (signal?.aborted) abortFromParent();
         activeRuntimes.set(threadId, runtime);
-        let sessionDirectory: string;
-        let persistentSession = false;
-        try {
-          const metadata = threadMetadata.get(threadId)!;
-          if (metadata.persistentSession && metadata.session.directory) {
-            sessionDirectory = metadata.session.directory;
-            await mkdir(sessionDirectory, { recursive: true, mode: 0o700 });
-            persistentSession = true;
-          } else {
-            sessionDirectory = await mkdtemp(path.join(os.tmpdir(), "killeros-subagent-session-"));
-          }
-          const existingResource = threadResources.get(threadId);
-          threadResources.set(threadId, existingResource ?? { directory: sessionDirectory, persistent: persistentSession, handles: new Set() });
-          const resource = threadResources.get(threadId)!;
-          resource.directory = sessionDirectory;
-          resource.persistent = persistentSession || resource.persistent;
-        } catch (error) {
-          signal?.removeEventListener("abort", abortFromParent);
-          if (activeRuntimes.get(threadId) === runtime) activeRuntimes.delete(threadId);
-          if (runtime.sessionGeneration !== sessionGeneration) {
-            results[index] = { ...results[index]!, status: "cancelled", terminationReason: runtime.requestedReason ?? "session_start" };
-            return;
-          }
-          const message = error instanceof Error ? error.message : String(error);
+        let sessionDirectory: string;
+        let persistentSession = false;
+        try {
+          const metadata = threadMetadata.get(threadId)!;
+          if (metadata.persistentSession && metadata.session.directory) {
+            sessionDirectory = metadata.session.directory;
+            await mkdir(sessionDirectory, { recursive: true, mode: 0o700 });
+            persistentSession = true;
+          } else {
+            sessionDirectory = await mkdtemp(path.join(os.tmpdir(), "killeros-subagent-session-"));
+          }
+          const existingResource = threadResources.get(threadId);
+          threadResources.set(threadId, existingResource ?? { directory: sessionDirectory, persistent: persistentSession, handles: new Set() });
+          const resource = threadResources.get(threadId)!;
+          resource.directory = sessionDirectory;
+          resource.persistent = persistentSession || resource.persistent;
+        } catch (error) {
+          signal?.removeEventListener("abort", abortFromParent);
+          if (activeRuntimes.get(threadId) === runtime) activeRuntimes.delete(threadId);
+          if (runtime.sessionGeneration !== sessionGeneration) {
+            results[index] = { ...results[index]!, status: "cancelled", terminationReason: runtime.requestedReason ?? "session_start" };
+            return;
+          }
+          const message = error instanceof Error ? error.message : String(error);
           results[index] = {
             ...results[index]!,
             status: "failed",
@@ -2424,35 +2540,35 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
           emit();
           return;
         }
-        const currentThread = threads.inspect(threadId);
-        if (controller.signal.aborted || threads.isDisposed || currentThread?.state !== "active") {
-          signal?.removeEventListener("abort", abortFromParent);
-          if (activeRuntimes.get(threadId) === runtime) activeRuntimes.delete(threadId);
-          if (!persistentSession) {
-            try {
-              await rm(sessionDirectory, { recursive: true, force: true });
-            } catch {
-              // Temporary child session cleanup is best effort before process startup.
-            }
-          }
-          if (runtime.sessionGeneration !== sessionGeneration) {
-            results[index] = { ...results[index]!, status: "cancelled", terminationReason: runtime.requestedReason ?? "session_start" };
-            return;
-          }
-          const reason = runtime.requestedReason ?? currentThread?.stopReason ?? (threads.isDisposed ? "session_shutdown" : "interrupted");
+        const currentThread = threads.inspect(threadId);
+        if (controller.signal.aborted || threads.isDisposed || currentThread?.state !== "active") {
+          signal?.removeEventListener("abort", abortFromParent);
+          if (activeRuntimes.get(threadId) === runtime) activeRuntimes.delete(threadId);
+          if (!persistentSession) {
+            try {
+              await rm(sessionDirectory, { recursive: true, force: true });
+            } catch {
+              // Temporary child session cleanup is best effort before process startup.
+            }
+          }
+          if (runtime.sessionGeneration !== sessionGeneration) {
+            results[index] = { ...results[index]!, status: "cancelled", terminationReason: runtime.requestedReason ?? "session_start" };
+            return;
+          }
+          const reason = runtime.requestedReason ?? currentThread?.stopReason ?? (threads.isDisposed ? "session_shutdown" : "interrupted");
           results[index] = { ...results[index]!, status: "cancelled", terminationReason: reason };
           if (!threads.isDisposed && currentThread?.state === "active") threads.stop(threadId, { reason });
           saveResult(threadId, results[index]!);
           emit();
           return;
         }
-        const metadata = threadMetadata.get(threadId)!;
-        const sessionId = metadata.session.id;
-        const agent = roles.get(input.agent)!;
-        let currentTask = queuedSteering.length ? buildSteeredTask(task, queuedSteering, limits.taskCharacters) : task;
-        const stopForBudget = (reason: string, message: string): void => {
-          if (runtime.sessionGeneration !== sessionGeneration) return;
-          const limited = cloneResult(runtime.aggregate ?? results[index]!);
+        const metadata = threadMetadata.get(threadId)!;
+        const sessionId = metadata.session.id;
+        const agent = rolesForInputs[index]!;
+        let currentTask = queuedSteering.length ? buildSteeredTask(task, queuedSteering, limits.taskCharacters) : task;
+        const stopForBudget = (reason: string, message: string): void => {
+          if (runtime.sessionGeneration !== sessionGeneration) return;
+          const limited = cloneResult(runtime.aggregate ?? results[index]!);
           limited.status = "limited";
           limited.terminationReason = reason;
           limited.errorMessage = message;
@@ -2472,7 +2588,7 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         try {
           while (true) {
             const aggregate = runtime.aggregate;
-            const wallTimeMs = limits.wallTimeMs ?? agent.timeoutMs ?? limits.defaultWallTimeMs;
+            const wallTimeMs = limits.wallTimeMs ?? agent.timeoutMs ?? limits.defaultWallTimeMs;
             const remainingWallTimeMs = wallTimeMs === undefined ? undefined : wallTimeMs - (Date.now() - runtime.startedAt);
             const usedTraceBytes = (aggregate?.traceBytes ?? 0) + (aggregate?.traceTruncatedBytes ?? 0);
             const usedStderrBytes = aggregate?.stderrBytes ?? 0;
@@ -2504,15 +2620,15 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
               break;
             }
             runtime.traceCount = 0;
-            const next = await runTask({
+            const next = await runTask({
               cwd: ctx.cwd,
-              agent: roles.get(input.agent)!,
+              agent,
               task: currentTask,
-              id: results[index]!.id,
-              displayName: metadata.displayName,
-              attempt: metadata.attempt,
+              id: results[index]!.id,
+              displayName: metadata.displayName,
+              attempt: metadata.attempt,
               step: results[index]!.step,
-              model: resolvedModels.get(input.agent)!,
+              model: resolvedModels[index]!,
               signal: controller.signal,
               webExtension: options.webExtension,
               projectTrusted: ctx.isProjectTrusted(),
@@ -2528,60 +2644,60 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
                 ...(limits.quotaUsd === undefined ? {} : { quotaUsd: limits.quotaUsd - usedCost }),
               },
               timeoutMs: remainingWallTimeMs,
-              onHandle: (handle) => {
-                runtime.handle = handle;
-                runtime.handles.add(handle);
-                threadResources.get(threadId)?.handles.add(handle);
-              },
+              onHandle: (handle) => {
+                runtime.handle = handle;
+                runtime.handles.add(handle);
+                threadResources.get(threadId)?.handles.add(handle);
+              },
               onChange: (changed) => {
                 results[index] = syncThread(threadId, changed, runtime);
                 emit();
               },
-            });
-            next.task = task;
-            runtime.aggregate = mergeTaskResults(runtime.aggregate, next, limits.traceRetentionBytes, limits.stderrRetentionBytes);
-            runtime.aggregate.task = task;
-            if (next.status === "cancelled" && runtime.requestedReason !== undefined) {
-              runtime.aggregate.terminationReason = runtime.requestedReason;
-            }
-            results[index] = cloneResult(runtime.aggregate);
-            if (runtime.sessionGeneration === sessionGeneration) saveResult(threadId, runtime.aggregate);
-            const shouldRestart = runtime.sessionGeneration === sessionGeneration
-              && runtime.steering.length > 0
-              && !controller.signal.aborted
-              && (runtime.restarting || next.status === "complete" || next.status === "cancelled");
-            if (!shouldRestart) break;
-            const previousHandle = runtime.handle;
-            if (previousHandle && !(await waitForConfirmedProcessExit(previousHandle))) {
-              if (runtime.sessionGeneration !== sessionGeneration || controller.signal.aborted || threads.isDisposed) {
-                const cancelled = cloneResult(runtime.aggregate ?? results[index]!);
-                cancelled.status = "cancelled";
-                cancelled.terminationReason = runtime.requestedReason ?? (threads.isDisposed ? "session_shutdown" : "abort");
-                runtime.aggregate = cancelled;
-                results[index] = cloneResult(cancelled);
-                if (runtime.sessionGeneration === sessionGeneration) {
-                  saveResult(threadId, cancelled);
-                  if (!threads.isDisposed && threads.inspect(threadId)?.state === "active") {
-                    threads.stop(threadId, {
-                      usage: threadUsage(cancelled.usage),
-                      result: cancelled.output || undefined,
-                      handoff: cancelled.output ? { summary: cancelled.output } : undefined,
-                      reason: cancelled.terminationReason,
-                    });
-                  }
-                  emit();
-                }
-                break;
-              }
-              const message = "Child process exit was not confirmed before the steering restart";
+            });
+            next.task = task;
+            runtime.aggregate = mergeTaskResults(runtime.aggregate, next, limits.traceRetentionBytes, limits.stderrRetentionBytes);
+            runtime.aggregate.task = task;
+            if (next.status === "cancelled" && runtime.requestedReason !== undefined) {
+              runtime.aggregate.terminationReason = runtime.requestedReason;
+            }
+            results[index] = cloneResult(runtime.aggregate);
+            if (runtime.sessionGeneration === sessionGeneration) saveResult(threadId, runtime.aggregate);
+            const shouldRestart = runtime.sessionGeneration === sessionGeneration
+              && runtime.steering.length > 0
+              && !controller.signal.aborted
+              && (runtime.restarting || next.status === "complete" || next.status === "cancelled");
+            if (!shouldRestart) break;
+            const previousHandle = runtime.handle;
+            if (previousHandle && !(await waitForConfirmedProcessExit(previousHandle))) {
+              if (runtime.sessionGeneration !== sessionGeneration || controller.signal.aborted || threads.isDisposed) {
+                const cancelled = cloneResult(runtime.aggregate ?? results[index]!);
+                cancelled.status = "cancelled";
+                cancelled.terminationReason = runtime.requestedReason ?? (threads.isDisposed ? "session_shutdown" : "abort");
+                runtime.aggregate = cancelled;
+                results[index] = cloneResult(cancelled);
+                if (runtime.sessionGeneration === sessionGeneration) {
+                  saveResult(threadId, cancelled);
+                  if (!threads.isDisposed && threads.inspect(threadId)?.state === "active") {
+                    threads.stop(threadId, {
+                      usage: threadUsage(cancelled.usage),
+                      result: cancelled.output || undefined,
+                      handoff: cancelled.output ? { summary: cancelled.output } : undefined,
+                      reason: cancelled.terminationReason,
+                    });
+                  }
+                  emit();
+                }
+                break;
+              }
+              const message = "Child process exit was not confirmed before the steering restart";
               const unconfirmed = cloneResult(runtime.aggregate ?? results[index]!);
               unconfirmed.status = "failed";
               unconfirmed.terminationReason = "process_exit_unconfirmed";
               unconfirmed.errorMessage = message;
               runtime.aggregate = unconfirmed;
               results[index] = cloneResult(unconfirmed);
-              if (runtime.sessionGeneration === sessionGeneration) saveResult(threadId, unconfirmed);
-              if (runtime.sessionGeneration === sessionGeneration && !threads.isDisposed && threads.inspect(threadId)?.state === "active") {
+              if (runtime.sessionGeneration === sessionGeneration) saveResult(threadId, unconfirmed);
+              if (runtime.sessionGeneration === sessionGeneration && !threads.isDisposed && threads.inspect(threadId)?.state === "active") {
                 threads.fail(threadId, {
                   usage: threadUsage(unconfirmed.usage),
                   result: unconfirmed.output || undefined,
@@ -2592,9 +2708,9 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
               }
               emit();
               break;
-            }
-            if (runtime.sessionGeneration !== sessionGeneration || controller.signal.aborted || threads.isDisposed) break;
-            const steering = runtime.steering.splice(0);
+            }
+            if (runtime.sessionGeneration !== sessionGeneration || controller.signal.aborted || threads.isDisposed) break;
+            const steering = runtime.steering.splice(0);
             runtime.restarting = false;
             runtime.requestedReason = undefined;
             if (!threads.isDisposed && threads.inspect(threadId)?.state === "active") {
@@ -2604,88 +2720,88 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
                 handoff: runtime.aggregate.output ? { summary: runtime.aggregate.output } : undefined,
               });
             }
-            if (steeredTaskWouldExceedLimit(task, steering, limits.taskCharacters)) {
-              const failed = cloneResult(runtime.aggregate ?? results[index]!);
-              failed.status = "failed";
-              failed.terminationReason = "steering_task_limit";
-              failed.errorMessage = `Expanded task plus steering exceeds ${limits.taskCharacters} characters`;
-              runtime.aggregate = failed;
-              results[index] = cloneResult(failed);
-              if (runtime.sessionGeneration === sessionGeneration) {
-                saveResult(threadId, failed);
-                if (!threads.isDisposed && threads.inspect(threadId)?.state === "active") {
-                  threads.fail(threadId, {
-                    usage: threadUsage(failed.usage),
-                    result: failed.output || undefined,
-                    handoff: failed.output ? { summary: failed.output } : undefined,
-                    message: failed.errorMessage,
-                    code: failed.terminationReason,
-                  });
-                }
-                emit();
-              }
-              break;
-            }
-            currentTask = buildSteeredTask(task, steering, limits.taskCharacters);
-          }
-        } finally {
-          signal?.removeEventListener("abort", abortFromParent);
-          if (activeRuntimes.get(threadId) === runtime) activeRuntimes.delete(threadId);
-          const handles = [...runtime.handles];
-          const exitStates = await Promise.all(handles.map((handle) => waitForConfirmedProcessExit(handle, limits.processExitWaitMs)));
-          const allExited = exitStates.every(Boolean);
-          if (!allExited) {
-            const unconfirmed = cloneResult(runtime.aggregate ?? results[index]!);
-            const requestedReason = runtime.requestedReason;
-            const strongReasons = new Set(["abort", "interrupt", "session_start", "session_shutdown", "malformed_jsonl", "invalid_usage", "spawn_error"]);
-            if (!requestedReason || !strongReasons.has(requestedReason)) {
-              unconfirmed.status = "failed";
-              unconfirmed.terminationReason = "process_exit_unconfirmed";
-              unconfirmed.errorMessage = "Child process exit was not confirmed before cleanup";
-            }
-            unconfirmed.exitConfirmed = false;
-            runtime.aggregate = unconfirmed;
-            results[index] = cloneResult(unconfirmed);
-            if (runtime.sessionGeneration === sessionGeneration) {
-              saveResult(threadId, unconfirmed);
-              const current = threads.inspect(threadId);
-              if (current?.state === "active") {
-                if (unconfirmed.status === "failed") {
-                  threads.fail(threadId, {
-                    usage: threadUsage(unconfirmed.usage),
-                    result: unconfirmed.output || undefined,
-                    handoff: unconfirmed.output ? { summary: unconfirmed.output } : undefined,
-                    message: unconfirmed.errorMessage ?? "Child process exit was not confirmed before cleanup",
-                    code: unconfirmed.terminationReason,
-                  });
-                } else {
-                  threads.stop(threadId, { reason: unconfirmed.terminationReason ?? "process_exit_unconfirmed" });
-                }
-              }
-              emit();
-            }
-          } else if (!persistentSession) {
-            try {
-              await rm(sessionDirectory, { recursive: true, force: true });
-            } catch {
-              // Temporary child session cleanup is best effort after process termination.
-            }
-          }
-        }
+            if (steeredTaskWouldExceedLimit(task, steering, limits.taskCharacters)) {
+              const failed = cloneResult(runtime.aggregate ?? results[index]!);
+              failed.status = "failed";
+              failed.terminationReason = "steering_task_limit";
+              failed.errorMessage = `Expanded task plus steering exceeds ${limits.taskCharacters} characters`;
+              runtime.aggregate = failed;
+              results[index] = cloneResult(failed);
+              if (runtime.sessionGeneration === sessionGeneration) {
+                saveResult(threadId, failed);
+                if (!threads.isDisposed && threads.inspect(threadId)?.state === "active") {
+                  threads.fail(threadId, {
+                    usage: threadUsage(failed.usage),
+                    result: failed.output || undefined,
+                    handoff: failed.output ? { summary: failed.output } : undefined,
+                    message: failed.errorMessage,
+                    code: failed.terminationReason,
+                  });
+                }
+                emit();
+              }
+              break;
+            }
+            currentTask = buildSteeredTask(task, steering, limits.taskCharacters);
+          }
+        } finally {
+          signal?.removeEventListener("abort", abortFromParent);
+          if (activeRuntimes.get(threadId) === runtime) activeRuntimes.delete(threadId);
+          const handles = [...runtime.handles];
+          const exitStates = await Promise.all(handles.map((handle) => waitForConfirmedProcessExit(handle, limits.processExitWaitMs)));
+          const allExited = exitStates.every(Boolean);
+          if (!allExited) {
+            const unconfirmed = cloneResult(runtime.aggregate ?? results[index]!);
+            const requestedReason = runtime.requestedReason;
+            const strongReasons = new Set(["abort", "interrupt", "session_start", "session_shutdown", "malformed_jsonl", "invalid_usage", "spawn_error"]);
+            if (!requestedReason || !strongReasons.has(requestedReason)) {
+              unconfirmed.status = "failed";
+              unconfirmed.terminationReason = "process_exit_unconfirmed";
+              unconfirmed.errorMessage = "Child process exit was not confirmed before cleanup";
+            }
+            unconfirmed.exitConfirmed = false;
+            runtime.aggregate = unconfirmed;
+            results[index] = cloneResult(unconfirmed);
+            if (runtime.sessionGeneration === sessionGeneration) {
+              saveResult(threadId, unconfirmed);
+              const current = threads.inspect(threadId);
+              if (current?.state === "active") {
+                if (unconfirmed.status === "failed") {
+                  threads.fail(threadId, {
+                    usage: threadUsage(unconfirmed.usage),
+                    result: unconfirmed.output || undefined,
+                    handoff: unconfirmed.output ? { summary: unconfirmed.output } : undefined,
+                    message: unconfirmed.errorMessage ?? "Child process exit was not confirmed before cleanup",
+                    code: unconfirmed.terminationReason,
+                  });
+                } else {
+                  threads.stop(threadId, { reason: unconfirmed.terminationReason ?? "process_exit_unconfirmed" });
+                }
+              }
+              emit();
+            }
+          } else if (!persistentSession) {
+            try {
+              await rm(sessionDirectory, { recursive: true, force: true });
+            } catch {
+              // Temporary child session cleanup is best effort after process termination.
+            }
+          }
+        }
         emit();
       };
 
-      const settleQueued = (reason: string): void => {
-        if (batchSessionGeneration !== sessionGeneration) {
-          for (const result of results) {
-            if (result.status === "queued") {
-              result.status = "cancelled";
-              result.terminationReason = "session_start";
-            }
-          }
-          return;
-        }
-        for (let index = 0; index < results.length; index += 1) {
+      const settleQueued = (reason: string): void => {
+        if (batchSessionGeneration !== sessionGeneration) {
+          for (const result of results) {
+            if (result.status === "queued") {
+              result.status = "cancelled";
+              result.terminationReason = "session_start";
+            }
+          }
+          return;
+        }
+        for (let index = 0; index < results.length; index += 1) {
           const result = results[index]!;
           if (result.status !== "queued") continue;
           const thread = threads.inspect(threadRecords[index]!.id);
@@ -2731,11 +2847,17 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
           await runAt(0, inputs[0]!.task);
         }
 
-        const board = detailsFor(parentId, mode, scope, discovery.projectAgentsDir, isResume ? resumeTarget?.id : undefined);
+        const board = detailsFor(parentId, mode, scope, discovery.projectAgentsDir, isResume ? resumeTarget?.id : undefined);
         const currentResults = results.map(cloneResult);
         const details: SubagentDetails = { ...board, executionNote, results: currentResults, aggregateUsage: aggregateUsage(currentResults) };
+        const toolContent = buildToolContent(mode, details.results, limits.toolOutputBytes);
         return {
-          content: [{ type: "text" as const, text: buildToolContent(mode, details.results, limits.toolOutputBytes) }],
+          content: [{
+            type: "text" as const,
+            text: executionNote
+              ? boundedText(`${executionNote}\n\n${toolContent}`, limits.toolOutputBytes, "\n\n[Spawn output truncated.]")
+              : toolContent,
+          }],
           details,
           usage: details.aggregateUsage,
         };
@@ -2752,7 +2874,7 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         }
       }
 
-      const queuedBoard = detailsFor(parentId, mode, scope, discovery.projectAgentsDir, isResume ? resumeTarget?.id : undefined);
+      const queuedBoard = detailsFor(parentId, mode, scope, discovery.projectAgentsDir, isResume ? resumeTarget?.id : undefined);
       const queuedResults = results.map(cloneResult);
       const queuedDetails: SubagentDetails = {
         ...queuedBoard,
@@ -2760,13 +2882,21 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         results: queuedResults,
         aggregateUsage: aggregateUsage(queuedResults),
       };
-      const threadList = threadRecords.map((thread) => `${threadDisplayName(threadView(thread, threadMetadata), threadMetadata)} (${thread.id})`).join(", ");
+      const threadList = threadRecords.map((thread) => `${threadDisplayName(threadView(thread, threadMetadata), threadMetadata)} (${thread.id})`).join(", ");
+      const reportUndeliveredFollowUp = (outcome: "settled" | "failed"): void => {
+        if (!ctx.hasUI) return;
+        try {
+          ctx.ui.notify(`Subagent batch ${outcome}, but its follow-up could not be delivered. Use list or collect for the saved result.`, "warning");
+        } catch {
+          // The thread registry still retains the result when the UI is closing.
+        }
+      };
       updatesOpen = false;
-      const backgroundBatch = finishBatch().then((completed) => {
-        if (batchSessionGeneration !== sessionGeneration
-          || threads.isDisposed
-          || signal?.aborted
-          || completed.details.results.some((result) => result.terminationReason === "abort")) return;
+      const backgroundBatch = finishBatch().then((completed) => {
+        if (batchSessionGeneration !== sessionGeneration
+          || threads.isDisposed
+          || signal?.aborted
+          || completed.details.results.some((result) => result.terminationReason === "abort")) return;
         try {
           pi.sendMessage({
             customType: "killeros-subagent-settled",
@@ -2774,10 +2904,10 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
             display: true,
           }, { triggerTurn: true, deliverAs: "followUp" });
         } catch {
-          // The completed handoff remains available through list, inspect, and collect.
+          reportUndeliveredFollowUp("settled");
         }
-      }).catch((error) => {
-        if (batchSessionGeneration !== sessionGeneration || threads.isDisposed || signal?.aborted) return;
+      }).catch((error) => {
+        if (batchSessionGeneration !== sessionGeneration || threads.isDisposed || signal?.aborted) return;
         const message = error instanceof Error ? error.message : String(error);
         try {
           pi.sendMessage({
@@ -2786,15 +2916,15 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
             display: true,
           }, { triggerTurn: true, deliverAs: "followUp" });
         } catch {
-          // The thread registry retains any partial state for inspection.
+          reportUndeliveredFollowUp("failed");
         }
-      });
+      }).finally(clearLiveWidget);
       backgroundBatches.add(backgroundBatch);
       void backgroundBatch.finally(() => backgroundBatches.delete(backgroundBatch));
       return {
         content: [{
           type: "text",
-          text: boundedText(`${isResume ? "Resumed" : "Started"} child threads: ${threadList}. They continue in the background; use list, inspect, wait, steer, interrupt, collect, resume, or close while they run.`, limits.toolOutputBytes, "\n\n[Spawn output truncated.]"),
+          text: boundedText(`${executionNote ? `${executionNote}\n\n` : ""}${isResume ? "Resumed" : "Started"} child threads: ${threadList}. They continue in the background. Live progress appears above the editor while they run; use list, inspect, wait, steer, interrupt, collect, resume, or close for current details.`, limits.toolOutputBytes, "\n\n[Spawn output truncated.]"),
         }],
         details: queuedDetails,
         usage: queuedDetails.aggregateUsage,
@@ -2824,7 +2954,8 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         return new Text(`${theme.fg("toolTitle", theme.bold("subagents "))}${theme.fg("accent", `parallel ${spawnRequest.input.tasks.length} · ${schedule}`)}${theme.fg("dim", ` · ${scope}`)}`, 0, 0);
       }
       if (spawnRequest.kind === "spawn-chain") return new Text(`${theme.fg("toolTitle", theme.bold("subagents "))}${theme.fg("accent", `chain ${spawnRequest.input.chain.length}`)}${theme.fg("dim", ` · ${scope}`)}`, 0, 0);
-      return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("accent", spawnRequest.input.agent)}${theme.fg("dim", ` · ${scope}`)}`, 0, 0);
+      const agentName = typeof spawnRequest.input.agent === "string" ? spawnRequest.input.agent : spawnRequest.input.agent.name;
+      return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("accent", agentName)}${theme.fg("dim", ` · ${scope}`)}`, 0, 0);
     },
 
     renderResult(result, { expanded }, theme) {
@@ -2838,32 +2969,32 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         threads: details.results.map(threadBoardRecord),
         selectedThreadId: details.selectedThreadId,
       });
-      if (!expanded) {
-        const lines = [
-          theme.fg("toolTitle", theme.bold(`Active (${board.active.length})`)),
-          ...board.active.map((task) => `${theme.fg("accent", "✻")} ${theme.fg("toolTitle", theme.bold(task.displayName ?? task.agent))}${theme.fg("dim", ` · role ${task.agent} · ${task.id} · attempt ${task.attempt ?? 1} · ${task.state.label} · ${task.usage.text}`)}`),
-          theme.fg("toolTitle", theme.bold(`Done (${board.done.length})`)),
-          ...board.done.map((task) => `${theme.fg(task.state.status === "complete" ? "success" : "warning", `${task.state.label}`)} ${theme.fg("toolTitle", theme.bold(task.displayName ?? task.agent))}${theme.fg("dim", ` · role ${task.agent} · ${task.id} · attempt ${task.attempt ?? 1} · ${task.usage.text}`)}`),
-        ];
+      if (!expanded) {
+        const lines = [
+          theme.fg("toolTitle", theme.bold(`Active (${board.active.length})`)),
+          ...board.active.map((task) => `${theme.fg("accent", "✻")} ${theme.fg("toolTitle", theme.bold(task.displayName ?? task.agent))}${theme.fg("dim", ` · role ${task.agent} · ${task.id} · attempt ${task.attempt ?? 1} · ${task.state.label} · ${task.usage.text}`)}`),
+          theme.fg("toolTitle", theme.bold(`Done (${board.done.length})`)),
+          ...board.done.map((task) => `${theme.fg(task.state.status === "complete" ? "success" : "warning", `${task.state.label}`)} ${theme.fg("toolTitle", theme.bold(task.displayName ?? task.agent))}${theme.fg("dim", ` · role ${task.agent} · ${task.id} · attempt ${task.attempt ?? 1} · ${task.usage.text}`)}`),
+        ];
         if (details.executionNote) lines.push(theme.fg("dim", details.executionNote));
         lines.push(theme.fg("dim", `Total · ${formatUsage(details.aggregateUsage)} · Ctrl+O to expand`));
         return new Text(lines.join("\n"), 0, 0);
       }
 
-      const container = new Container();
-      container.addChild(new Text(theme.fg("toolTitle", theme.bold(`Subagents · ${details.mode}`)), 0, 0));
-      container.addChild(new Text(theme.fg("dim", `Active ${board.active.length} · Done ${board.done.length} · Controls: Inspect · Steer · Interrupt · Wait · Collect · Resume · Close`), 0, 0));
+      const container = new Container();
+      container.addChild(new Text(theme.fg("toolTitle", theme.bold(`Subagents · ${details.mode}`)), 0, 0));
+      container.addChild(new Text(theme.fg("dim", `Active ${board.active.length} · Done ${board.done.length} · Controls: Inspect · Steer · Interrupt · Wait · Collect · Resume · Close`), 0, 0));
       if (details.executionNote) container.addChild(new Text(theme.fg("dim", details.executionNote), 0, 0));
       if (board.selected) {
         const inspection = formatThreadInspection(threadBoardRecord(details.results.find((task) => task.id === board.selected!.id)!));
         container.addChild(new Spacer(1));
-        container.addChild(new Text(theme.fg("accent", `Inspect ${inspection.displayName ?? inspection.agent} · ${inspection.state.label} · ${inspection.id} · ${inspection.usage.text}`), 0, 0));
+        container.addChild(new Text(theme.fg("accent", `Inspect ${inspection.displayName ?? inspection.agent} · ${inspection.state.label} · ${inspection.id} · ${inspection.usage.text}`), 0, 0));
         for (const entry of inspection.trace.entries) container.addChild(new Text(`${theme.fg("muted", "→ ")}${theme.fg("toolOutput", entry)}`, 0, 0));
       }
       for (const task of details.results) {
         container.addChild(new Spacer(1));
         const status = theme.fg(statusColor(task.status), `${statusIcon(task.status)} ${task.status}`);
-        container.addChild(new Text(`${status} ${theme.fg("accent", task.name ?? task.agent)}${theme.fg("dim", ` · role ${task.agent} · ${task.id} · attempt ${task.attempt} · ${task.agentSource}`)}`, 0, 0));
+        container.addChild(new Text(`${status} ${theme.fg("accent", task.name ?? task.agent)}${theme.fg("dim", ` · role ${task.agent} · ${task.id} · attempt ${task.attempt} · ${task.agentSource}`)}`, 0, 0));
         container.addChild(new Text(theme.fg("dim", `${task.model ?? "no model"} · ${task.thinking ?? "off"} · ${task.tools.join(", ")} · ${formatUsage(task.usage)} · ${task.durationMs}ms`), 0, 0));
         container.addChild(new Text(theme.fg("muted", `Task: ${task.task}`), 0, 0));
         for (const entry of task.trace) container.addChild(new Text(`${theme.fg("muted", "→ ")}${theme.fg("toolOutput", entry)}`, 0, 0));
@@ -2877,18 +3008,18 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
       container.addChild(new Text(theme.fg("dim", `Total · ${formatUsage(details.aggregateUsage)}`), 0, 0));
       return container;
     },
-  };
-  pi.registerTool(toolDefinition);
-  return {
-    async execute(controlRequest: SubagentControlRequest, ctx: ExtensionContext): Promise<SubagentControlResult> {
-      const result = await toolDefinition.execute("subagent-control", controlRequest, undefined, undefined, ctx);
-      const first = result.content[0];
-      const details = result.details as SubagentDetails;
-      return {
-        text: first?.type === "text" ? first.text : "",
-        details,
-        usage: (result.usage as SubagentUsage | undefined) ?? details.aggregateUsage,
-      };
-    },
-  };
-}
+  };
+  pi.registerTool(toolDefinition);
+  return {
+    async execute(controlRequest: SubagentControlRequest, ctx: ExtensionContext): Promise<SubagentControlResult> {
+      const result = await toolDefinition.execute("subagent-control", controlRequest, undefined, undefined, ctx);
+      const first = result.content[0];
+      const details = result.details as SubagentDetails;
+      return {
+        text: first?.type === "text" ? first.text : "",
+        details,
+        usage: (result.usage as SubagentUsage | undefined) ?? details.aggregateUsage,
+      };
+    },
+  };
+}