killeros 1.4.3 → 1.4.6

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to KillerOS are documented here.
 
+## [1.4.6] - 2026-08-01
+
+### Fixed
+
+- Made the registered task schema use the same ten-task limit as runtime validation.
+- Kept one isolated Pi session ID and session directory across steering restarts so a child retains its conversation.
+- Bound retained trace, stderr, and returned text, and spooled large JSONL lines to temporary storage without stopping the child or reporting a retention cutoff as `limited`.
+- Kept explicit embedding resource guards and user stops visible as terminal states.
+
+## [1.4.5] - 2026-08-01
+
+### Fixed
+
+- Removed the child-budget extension, its read-tool budget, and the default 250,000-token/$5 quota.
+- Removed default child wall-time, JSONL-line, trace, stderr, returned-output, and model-output-length stops; role `timeoutMs` and other child guards are now opt-in.
+- Removed forced early-report prompt text so roles can finish their assigned work naturally.
+- Treat model stop reason `length` as a completed child process instead of inventing a KillerOS `limited` result.
+- Documented the child lifecycle contract: children complete naturally; explicit user interruptions, configured guards, and real child-process failures remain visible.
+
 ## [1.4.3] - 2026-08-01
 
 ### Fixed

package/README.md

@@ -33,7 +33,7 @@ pi install git:github.com/KyrosHendrix/pi-KillerOS
 Pin an install to a release:
 
 ```bash
-  pi install git:github.com/KyrosHendrix/pi-KillerOS@v1.4.3
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v1.4.6
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -47,7 +47,7 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 - Responsive footer with polished model/provider identity, plain-language context, and active goal state remaining; reasoning, Git branch, elapsed time, cost, and path cut down by available width
 - `/variants` selector and direct reasoning-level arguments
 - Codex-style `/goal` for durable long-running objectives with pause, resume, edit, clear, automatic continuation, and explicit completion
-- Pi-native `subagent` tool with named, inspectable child threads, Markdown roles, explicit read/write boundaries, parent controls, bounded resources, and cancellation propagation
+- Pi-native `subagent` tool with named, inspectable child threads, Markdown roles, explicit read/write boundaries, parent controls, natural completion, and cancellation propagation
 - Claude Code-style `/init` that scans the repository and generates a concise root `AGENTS.md` without setup questions
 - `question` tool with filtering, proposal previews, keyboard selection, custom answers, history, cancellation, and resize-safe rendering
 - Mid-prompt slash completion with current Pi `0.82.1` commands, extensions, prompts, and skills
@@ -89,7 +89,7 @@ KillerOS ships `planner`, `reviewer`, `scout`, and `security` as read-only roles
 | `scout` | read | Map unfamiliar code and return an evidence trail |
 | `security` | read | Audit trust boundaries and report concrete security findings |
 | `tester` | write | Add focused coverage and run deterministic verification |
-| `worker` | write | Execute a bounded repository change |
+| `worker` | write | Execute the assigned repository change |
 
 1. Bundled: `<killeros>/agents/*.md`
 2. Personal: `~/.pi/agent/agents/*.md`
@@ -103,7 +103,7 @@ The tool supports a single `agent` + `task`, parallel `tasks`, or a sequential `
 {"agent":"reviewer","task":"Review the change","model":"provider/model","thinking":"high"}
 ```
 
-Use the separate `model` and `thinking` fields for new configuration. The older `provider/model:thinking` model form remains accepted. Children run as ephemeral `pi --mode json -p --no-session` processes with explicit local tools plus `web_search`, `source_check`, `fetch_content`, and `get_search_content`. Each child explicitly loads `npm:pi-web-access` and the KillerOS child-budget hook, discovers available skills, and keeps arbitrary extensions and prompt templates disabled; project-local skills load only when the parent project is trusted. Every bundled role is instructed to load the most relevant `SKILL.md`, work in bounded passes, and report after its first useful evidence. KillerOS allows at most eight tasks, four parallel readers, ten minutes, a 32 MiB JSONL line, 2 MiB retained trace, 64 KiB stderr, 50 KiB returned output, 250,000 tokens, and $5 per child. Read-only children receive a 24-call soft and 32-call hard tool budget that blocks read and web tools after the hard limit; final reports remain allowed. Esc cancellation terminates active children and escalates after five seconds.
+Use the separate `model` and `thinking` fields for new configuration. The older `provider/model:thinking` model form remains accepted. Children run as isolated `pi --mode json -p` processes with a private `--session-dir` and `--session-id`, plus explicit local tools and `web_search`, `source_check`, `fetch_content`, and `get_search_content`. Steering restarts the same child session, so the child keeps its prior conversation. Each child explicitly loads `npm:pi-web-access`, discovers available skills, and keeps arbitrary extensions and prompt templates disabled; project-local skills load only when the parent project is trusted. Every bundled role is instructed to load the most relevant `SKILL.md` and report useful evidence. Children have no default token, dollar, turn, tool-call, research, wall-time, JSONL-line, trace, stderr, or returned-output execution quota. KillerOS bounds retained trace, stderr, and returned text and spills a large JSONL line to temporary storage; retention never stops a child or marks it `limited`. The parent limits each request to ten tasks and four parallel readers and bounds role files, task input, and combined parent output. An embedding caller may opt into named child resource guards. Esc cancellation terminates active children and escalates after five seconds.
 
 ### Thread lifecycle
 
@@ -113,7 +113,7 @@ Threads move through `queued`, `active`, `done`, `failed`, `stopped`, and `close
 
 The parent can inspect a thread’s prompt, role, model, tools, trace, usage, and handoff; steer an active thread with one bounded follow-up; interrupt one child or all active children; collect a concise handoff into parent context; and close a finished or stopped thread. An interrupt preserves the partial trace, states the reason, and reports the handoff as partial rather than successful.
 
-A child completes naturally when it returns a final answer. Routine turn caps do not end useful work. Named resource guards still stop unsafe growth: wall time, output bytes, retained trace, stderr, quota, read-tool calls, task count, and concurrency. Read-tool budgets are enforced inside the child process, so the model receives a finalization nudge and a blocked-tool result instead of being killed while it is still researching. A guard reports its cause and returns any partial work clearly. Esc cancellation terminates active children and escalates after five seconds.
+A child completes naturally when it returns a final answer. The default path has no per-child execution quota. Explicit embedding options can add wall-time, output, trace, stderr, JSONL, token, or cost guards; those guards report their cause and return partial work clearly. The parent still bounds task count, reader concurrency, role files, task input, and combined parent output. Explicit user interruptions and real child-process failures remain visible. Esc cancellation terminates active children and escalates after five seconds.
 
 The replacement lifecycle has nine phases:
 
@@ -123,7 +123,7 @@ The replacement lifecycle has nine phases:
 4. **Steer:** append a bounded parent follow-up to an active thread.
 5. **Interrupt:** stop one or all active children while preserving partial work.
 6. **Collect:** return a concise handoff while retaining the expanded trace.
-7. **Bound:** apply named resource guards instead of a routine turn stop.
+7. **Guard:** honor only explicitly configured child resource guards; do not impose a routine turn stop.
 8. **Close:** remove a finished or stopped thread from the workspace without deleting its result record.
 9. **Prove:** test identity, visibility, controls, natural completion, guards, partial handoffs, and closure.
 
@@ -163,7 +163,7 @@ The package manifest lists Pi’s built-in modules as peer dependencies, so npm
 
 The [`pi-package`](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md) keyword makes a published npm release visible in Pi’s package catalog.
 
-For the current unreleased `1.4.3`, publish after the validation checks pass:
+For release `1.4.6`, publish after the validation checks pass:
 
 ```bash
 npm login

package/agents/debugger.md

@@ -6,7 +6,6 @@ tools: read, grep, find, ls, edit, write, bash, web_search, source_check, fetch_
 # Replace inherit with provider/model to pin this role; set thinking separately when needed.
 model: inherit
 thinking: inherit
-timeoutMs: 300000
 ---
 
 # Role

package/agents/documenter.md

@@ -6,7 +6,6 @@ tools: read, grep, find, ls, edit, write, bash, web_search, source_check, fetch_
 # Replace inherit with provider/model to pin this role; set thinking separately when needed.
 model: inherit
 thinking: inherit
-timeoutMs: 300000
 ---
 
 # Role

package/agents/planner.md

@@ -6,7 +6,6 @@ tools: read, grep, find, ls, web_search, source_check, fetch_content, get_search
 # Replace inherit with provider/model to pin this role; set thinking separately when needed.
 model: inherit
 thinking: inherit
-timeoutMs: 300000
 ---
 
 # Role

package/agents/reviewer.md

@@ -6,7 +6,6 @@ tools: read, grep, find, ls, web_search, source_check, fetch_content, get_search
 # Replace inherit with provider/model to pin this role; set thinking separately when needed.
 model: inherit
 thinking: inherit
-timeoutMs: 300000
 ---
 
 # Role
@@ -39,7 +38,7 @@ If no concrete issue is found, report the reviewed scope, protections checked, a
 
 ## Boundaries
 
-Do not edit files or fix findings yourself. Do not report stylistic preferences as defects. Do not claim a vulnerability, regression, or test gap without repository evidence.
+Do not edit files or fix findings yourself. Do not report stylistic preferences as defects. Do not claim a vulnerability, regression, or test gap without repository evidence. Finish the assigned review when the evidence resolves its scope, report the findings or clean result, and do not chase unrelated work.
 
 ## Skills and web research
 

package/agents/scout.md

@@ -6,12 +6,11 @@ tools: read, grep, find, ls, web_search, source_check, fetch_content, get_search
 # Replace inherit with provider/model to pin this role; set thinking separately when needed.
 model: inherit
 thinking: inherit
-timeoutMs: 300000
 ---
 
 # Role
 
-You are the `scout` role, a fast and bounded repository investigator. Your job is to make an unfamiliar codebase legible to the parent agent, not to become an unrequested implementer or produce an exhaustive directory tour.
+You are the `scout` role, a focused repository investigator. Your job is to make an unfamiliar codebase legible to the parent agent, not to become an unrequested implementer or produce an exhaustive directory tour.
 
 ## Mission
 
@@ -23,7 +22,7 @@ Begin with the user’s actual question and define what evidence would answer it
 2. **Trace.** Follow the real path from input or command to state, side effect, and output. Follow callers and callees only when the current evidence requires it.
 3. **Compare.** Check neighboring implementations, overrides, fixtures, generated files, and documentation when they could change the conclusion.
 4. **Verify.** Record exact paths, symbols, commands, and conventions. Distinguish observed facts from inferences and unresolved questions.
-5. **Stop.** Once the parent’s question is closed by evidence, stop. Do not pad the report with unrelated files, generic architecture advice, or speculative fixes.
+5. **Finish.** Once evidence closes the parent’s question, report the findings and stop. Do not chase unrelated files, generic architecture advice, or speculative fixes.
 
 ## Report
 

package/agents/security.md

@@ -6,7 +6,6 @@ tools: read, grep, find, ls, web_search, source_check, fetch_content, get_search
 # Replace inherit with provider/model to pin this role; set thinking separately when needed.
 model: inherit
 thinking: inherit
-timeoutMs: 300000
 ---
 
 # Role
@@ -35,7 +34,7 @@ Relevant lenses may include:
 
 ## Finding standard
 
-Every confirmed finding must name the severity, precondition or trigger, affected path or symbol, evidence, security impact, and smallest safe correction. Separate questions and blind spots from findings. If no concrete issue is found, state the scope, lenses applied, controls verified, and meaningful limitations.
+Every confirmed finding must name the severity, precondition or trigger, affected path or symbol, evidence, security impact, and smallest safe correction. Separate questions and blind spots from findings. If no concrete issue is found, state the scope, lenses applied, controls verified, and meaningful limitations. Finish the assigned review when the evidence resolves its scope, report the findings or clean result, and do not chase unrelated work.
 
 ## Skills and web research
 

package/agents/tester.md

@@ -6,7 +6,6 @@ tools: read, grep, find, ls, edit, write, bash, web_search, source_check, fetch_
 # Replace inherit with provider/model to pin this role; set thinking separately when needed.
 model: inherit
 thinking: inherit
-timeoutMs: 300000
 ---
 
 # Role

package/agents/worker.md

@@ -6,7 +6,6 @@ tools: read, grep, find, ls, edit, write, bash, web_search, source_check, fetch_
 # Replace inherit with provider/model to pin this role; set thinking separately when needed.
 model: inherit
 thinking: inherit
-timeoutMs: 300000
 ---
 
 # Role

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "1.4.3",
+  "version": "1.4.6",
   "description": "A production-hardened TUI and workflow extension for the Pi coding agent.",
   "type": "module",
   "keywords": [
@@ -24,7 +24,6 @@
     "subagents.ts",
     "subagent-lifecycle.ts",
     "subagent-process.ts",
-    "subagent-budget.ts",
     "subagent-ui.ts",
     "agents/*.md",
     "themes/killeros.json",

package/subagent-process.ts

@@ -1,16 +1,17 @@
 import { spawn } from "node:child_process";
-import { statSync } from "node:fs";
+import { closeSync, mkdtempSync, openSync, readFileSync, rmSync, statSync, writeSync } from "node:fs";
+import os from "node:os";
 import path from "node:path";
 
 export const SUBAGENT_PROCESS_LIMITS = {
-  wallTimeMs: 600_000,
-  jsonlLineBytes: 32 * 1024 * 1024,
+  killGraceMs: 5_000,
+} as const;
+
+export const SUBAGENT_PROCESS_RETENTION = {
+  jsonlMemoryBytes: 1 * 1024 * 1024,
   traceBytes: 2 * 1024 * 1024,
   stderrBytes: 64 * 1024,
-  outputBytes: 50 * 1024,
-  quotaTokens: 250_000,
-  quotaUsd: 5,
-  killGraceMs: 5_000,
+  outputBytes: 1 * 1024 * 1024,
 } as const;
 
 export type SubagentProcessStatus = "running" | "complete" | "failed" | "cancelled" | "limited";
@@ -63,11 +64,12 @@ export interface SubagentProcessChild {
 }
 
 export interface SubagentProcessOptions {
-  /** Exact Pi arguments. Include `--mode json` and `--no-session`. */
+  /** Exact Pi arguments. Include `--mode json` and either `--no-session` or an isolated session id and directory. */
   args: readonly string[];
   cwd: string;
   signal?: AbortSignal;
   limits?: Partial<SubagentProcessLimits>;
+  retention?: Partial<SubagentProcessRetention>;
   environment?: NodeJS.ProcessEnv;
   onUpdate?: (result: Readonly<SubagentProcessResult>) => void;
   /** Test or embed hook. It receives the exact Pi arguments supplied above. */
@@ -75,14 +77,21 @@ export interface SubagentProcessOptions {
 }
 
 export interface SubagentProcessLimits {
-  wallTimeMs: number;
-  jsonlLineBytes: number;
+  wallTimeMs?: number;
+  jsonlLineBytes?: number;
+  traceBytes?: number;
+  stderrBytes?: number;
+  outputBytes?: number;
+  quotaTokens?: number;
+  quotaUsd?: number;
+  killGraceMs: number;
+}
+
+export interface SubagentProcessRetention {
+  jsonlMemoryBytes: number;
   traceBytes: number;
   stderrBytes: number;
   outputBytes: number;
-  quotaTokens: number;
-  quotaUsd: number;
-  killGraceMs: number;
 }
 
 export interface SubagentProcessHandle {
@@ -178,11 +187,11 @@ function traceMessage(message: any): string[] {
   return entries;
 }
 
-function appendTrace(result: SubagentProcessResult, entries: string[], maxBytes: number): boolean {
+function appendTrace(result: SubagentProcessResult, entries: string[], maxBytes: number | undefined): boolean {
   let truncated = false;
   for (const entry of entries) {
     const entryBytes = Buffer.byteLength(entry, "utf8");
-    const retained = truncateUtf8(entry, Math.max(0, maxBytes - result.traceBytes));
+    const retained = truncateUtf8(entry, maxBytes === undefined ? entryBytes : Math.max(0, maxBytes - result.traceBytes));
     if (retained.text) result.trace.push(retained.text);
     result.traceBytes += Buffer.byteLength(retained.text, "utf8");
     result.traceTruncatedBytes += entryBytes - Buffer.byteLength(retained.text, "utf8");
@@ -195,19 +204,35 @@ function hasJsonMode(args: readonly string[]): boolean {
   return args.some((arg, index) => arg === "--mode=json" || arg === "--mode" && args[index + 1] === "json");
 }
 
+function hasIsolatedSession(args: readonly string[]): boolean {
+  const sessionId = args.indexOf("--session-id");
+  const sessionDir = args.indexOf("--session-dir");
+  return sessionId >= 0 && typeof args[sessionId + 1] === "string"
+    && sessionDir >= 0 && typeof args[sessionDir + 1] === "string";
+}
+
 function normalizeLimits(overrides: Partial<SubagentProcessLimits> | undefined): SubagentProcessLimits {
   const limits = { ...SUBAGENT_PROCESS_LIMITS, ...overrides };
   for (const name of ["wallTimeMs", "jsonlLineBytes", "traceBytes", "stderrBytes", "outputBytes", "killGraceMs"] as const) {
     const value = limits[name];
-    if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be a positive safe integer`);
+    if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) throw new RangeError(`${name} must be a positive safe integer`);
   }
   for (const name of ["quotaTokens", "quotaUsd"] as const) {
     const value = limits[name];
-    if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a positive finite number`);
+    if (value !== undefined && (!Number.isFinite(value) || value <= 0)) throw new RangeError(`${name} must be a positive finite number`);
   }
   return limits;
 }
 
+function normalizeRetention(overrides: Partial<SubagentProcessRetention> | undefined): SubagentProcessRetention {
+  const retention = { ...SUBAGENT_PROCESS_RETENTION, ...overrides };
+  for (const name of ["jsonlMemoryBytes", "traceBytes", "stderrBytes", "outputBytes"] as const) {
+    const value = retention[name];
+    if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be a positive safe integer`);
+  }
+  return retention;
+}
+
 function getPiInvocation(args: string[]): { command: string; args: string[] } {
   const currentScript = process.argv[1];
   const isBunVirtualScript = currentScript?.startsWith("/$bunfs/root/");
@@ -270,13 +295,16 @@ function terminateProcess(child: SubagentProcessChild, force: boolean): void {
 
 /**
  * Run one isolated Pi JSON process. The caller owns all Pi arguments, including
- * model, tools, prompt, and extension flags. This runner never applies a turn cap.
+ * model, tools, prompt, and extension flags. Resource limits are opt-in.
  */
 export function runSubagentProcess(options: SubagentProcessOptions): SubagentProcessHandle {
   const args = [...options.args];
   if (!hasJsonMode(args)) throw new Error("Subagent Pi arguments must include --mode json");
-  if (!args.includes("--no-session")) throw new Error("Subagent Pi arguments must include --no-session");
+  if (!args.includes("--no-session") && !hasIsolatedSession(args)) {
+    throw new Error("Subagent Pi arguments must include --no-session or an isolated --session-id and --session-dir");
+  }
   const limits = normalizeLimits(options.limits);
+  const retention = normalizeRetention(options.retention);
   const startedAt = Date.now();
   const state: SubagentProcessResult = {
     status: "running",
@@ -302,6 +330,8 @@ export function runSubagentProcess(options: SubagentProcessOptions): SubagentPro
   let requestedReason: string | undefined;
   let stdoutLine = Buffer.alloc(0);
   let stdoutLineBytes = 0;
+  let stdoutLineSpoolDirectory: string | undefined;
+  let stdoutLineSpoolDescriptor: number | undefined;
   let stderr = Buffer.alloc(0);
   let outputBytesSeen = 0;
   let forceTimer: NodeJS.Timeout | undefined;
@@ -310,16 +340,53 @@ export function runSubagentProcess(options: SubagentProcessOptions): SubagentPro
   let resolveResult!: (result: SubagentProcessResult) => void;
   const result = new Promise<SubagentProcessResult>((resolve) => { resolveResult = resolve; });
 
+  const clearStdoutLine = (): void => {
+    if (stdoutLineSpoolDescriptor !== undefined) {
+      try {
+        closeSync(stdoutLineSpoolDescriptor);
+      } catch (error) {
+        state.errorMessage ??= `Could not close child JSONL spool: ${error instanceof Error ? error.message : String(error)}`;
+      }
+      stdoutLineSpoolDescriptor = undefined;
+    }
+    if (stdoutLineSpoolDirectory) {
+      try {
+        rmSync(stdoutLineSpoolDirectory, { recursive: true, force: true });
+      } catch (error) {
+        state.errorMessage ??= `Could not remove child JSONL spool: ${error instanceof Error ? error.message : String(error)}`;
+      }
+      stdoutLineSpoolDirectory = undefined;
+    }
+    stdoutLine = Buffer.alloc(0);
+    stdoutLineBytes = 0;
+  };
+  const readStdoutLine = (): string => {
+    if (stdoutLineSpoolDirectory) {
+      const filePath = path.join(stdoutLineSpoolDirectory, "line.jsonl");
+      try {
+        if (stdoutLineSpoolDescriptor !== undefined) {
+          closeSync(stdoutLineSpoolDescriptor);
+          stdoutLineSpoolDescriptor = undefined;
+        }
+        return readFileSync(filePath, "utf8");
+      } catch (error) {
+        state.errorMessage ??= `Could not read child JSONL spool: ${error instanceof Error ? error.message : String(error)}`;
+        return "";
+      } finally {
+        clearStdoutLine();
+      }
+    }
+    const line = stdoutLine.toString("utf8", 0, stdoutLineBytes);
+    clearStdoutLine();
+    return line;
+  };
+
   const publish = (): void => options.onUpdate?.(cloneResult(state));
   const finish = (code: number | null): void => {
     if (closed || finishing) return;
     finishing = true;
-    if (stdoutLineBytes && !requestedStatus) {
-      const finalLine = stdoutLine.toString("utf8", 0, stdoutLineBytes);
-      stdoutLine = Buffer.alloc(0);
-      stdoutLineBytes = 0;
-      processLine(finalLine);
-    }
+    if (stdoutLineBytes && !requestedStatus) processLine(readStdoutLine());
+    else clearStdoutLine();
     closed = true;
     if (forceTimer) clearTimeout(forceTimer);
     if (settleTimer) clearTimeout(settleTimer);
@@ -331,9 +398,12 @@ export function runSubagentProcess(options: SubagentProcessOptions): SubagentPro
     if (requestedStatus) {
       state.status = requestedStatus;
       state.terminationReason = requestedReason;
-    } else if (code !== 0 || state.errorMessage || state.stopReason && state.stopReason !== "stop" && state.stopReason !== "toolUse") {
-      state.status = "failed";
+    } else if (code !== 0 || state.errorMessage || state.stopReason === "error" || state.stopReason === "aborted") {
+      state.status = state.stopReason === "aborted" ? "cancelled" : "failed";
       state.terminationReason ??= code === null ? "process_closed" : `exit_${code}`;
+    } else if (state.stopReason !== undefined && !["stop", "toolUse", "length"].includes(state.stopReason)) {
+      state.status = "failed";
+      state.terminationReason = state.stopReason;
     } else if (state.usage.turns === 0) {
       state.status = "failed";
       state.terminationReason = "missing_assistant_message";
@@ -382,23 +452,26 @@ export function runSubagentProcess(options: SubagentProcessOptions): SubagentPro
       state.usage.turns += 1;
       addUsage(state.usage, { ...message.usage, turns: 0 });
       state.toolCallCount += toolCallCount(message);
-      if (state.usage.totalTokens > limits.quotaTokens) {
+      if (limits.quotaTokens !== undefined && state.usage.totalTokens > limits.quotaTokens) {
         requestTermination("limited", "quota_tokens", `Child token usage exceeds ${limits.quotaTokens}`);
-      } else if (state.usage.cost.total > limits.quotaUsd) {
+      } else if (limits.quotaUsd !== undefined && state.usage.cost.total > limits.quotaUsd) {
         requestTermination("limited", "quota_cost", `Child cost exceeds $${limits.quotaUsd}`);
       }
-      if (appendTrace(state, traceMessage(message), limits.traceBytes)) {
+      const traceTruncatedBefore = state.traceTruncatedBytes;
+      appendTrace(state, traceMessage(message), Math.min(retention.traceBytes, limits.traceBytes ?? retention.traceBytes));
+      if (limits.traceBytes !== undefined && state.traceTruncatedBytes > traceTruncatedBefore && state.traceBytes >= limits.traceBytes) {
         requestTermination("limited", "trace_limit", `Retained child trace exceeds ${limits.traceBytes} bytes`);
       }
       const output = textContent(message);
       if (output) {
-        const capped = truncateUtf8(output, limits.outputBytes);
+        const outputLimit = Math.min(retention.outputBytes, limits.outputBytes ?? retention.outputBytes);
+        const capped = truncateUtf8(output, outputLimit);
         state.output = capped.text;
         state.outputTruncatedBytes = capped.omittedBytes;
         outputBytesSeen += Buffer.byteLength(output, "utf8");
         state.outputBytes = outputBytesSeen;
-        state.outputTruncatedBytes = Math.max(state.outputTruncatedBytes, outputBytesSeen - limits.outputBytes);
-        if (outputBytesSeen > limits.outputBytes) requestTermination("limited", "output_limit", `Child output exceeds ${limits.outputBytes} bytes`);
+        state.outputTruncatedBytes = Math.max(state.outputTruncatedBytes, outputBytesSeen - (limits.outputBytes ?? retention.outputBytes));
+        if (limits.outputBytes !== undefined && outputBytesSeen > limits.outputBytes) requestTermination("limited", "output_limit", `Child output exceeds ${limits.outputBytes} bytes`);
       }
       if (typeof message.model === "string") state.model = message.provider ? `${message.provider}/${message.model}` : message.model;
       if (typeof message.stopReason === "string") {
@@ -407,11 +480,12 @@ export function runSubagentProcess(options: SubagentProcessOptions): SubagentPro
         else state.terminationReason = message.stopReason;
       }
       if (typeof message.errorMessage === "string") state.errorMessage = message.errorMessage;
-      if (message.stopReason === "length") requestTermination("limited", "model_output_limit");
       publish();
     } else if (event?.type === "tool_result_end" && event.message) {
       const name = typeof event.message.toolName === "string" ? event.message.toolName : "tool";
-      if (appendTrace(state, [`${name} result${event.message.isError ? " (error)" : ""}`], limits.traceBytes)) {
+      const traceTruncatedBefore = state.traceTruncatedBytes;
+      appendTrace(state, [`${name} result${event.message.isError ? " (error)" : ""}`], Math.min(retention.traceBytes, limits.traceBytes ?? retention.traceBytes));
+      if (limits.traceBytes !== undefined && state.traceTruncatedBytes > traceTruncatedBefore && state.traceBytes >= limits.traceBytes) {
         requestTermination("limited", "trace_limit", `Retained child trace exceeds ${limits.traceBytes} bytes`);
       }
       publish();
@@ -419,12 +493,30 @@ export function runSubagentProcess(options: SubagentProcessOptions): SubagentPro
   };
   const appendStdout = (fragment: Buffer): boolean => {
     const nextBytes = stdoutLineBytes + fragment.length;
-    if (nextBytes > limits.jsonlLineBytes) {
+    if (limits.jsonlLineBytes !== undefined && nextBytes > limits.jsonlLineBytes) {
       requestTermination("limited", "jsonl_line_limit", `Child JSONL line exceeds ${limits.jsonlLineBytes} bytes`);
       return false;
     }
+    if (nextBytes > retention.jsonlMemoryBytes) {
+      try {
+        if (stdoutLineSpoolDescriptor === undefined) {
+          stdoutLineSpoolDirectory = mkdtempSync(path.join(os.tmpdir(), "killeros-jsonl-"));
+          stdoutLineSpoolDescriptor = openSync(path.join(stdoutLineSpoolDirectory, "line.jsonl"), "w");
+          if (stdoutLineBytes) writeSync(stdoutLineSpoolDescriptor, stdoutLine);
+          stdoutLine = Buffer.alloc(0);
+        }
+        if (fragment.length) writeSync(stdoutLineSpoolDescriptor, fragment);
+      } catch (error) {
+        requestTermination("failed", "jsonl_spool_error", `Could not spool child JSONL: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+      }
+      stdoutLineBytes = nextBytes;
+      return true;
+    }
     if (nextBytes > stdoutLine.length) {
-      const nextCapacity = Math.min(limits.jsonlLineBytes, Math.max(nextBytes, stdoutLine.length * 2, 4_096));
+      const nextCapacity = limits.jsonlLineBytes === undefined
+        ? Math.max(nextBytes, stdoutLine.length * 2, 4_096)
+        : Math.min(limits.jsonlLineBytes, Math.max(nextBytes, stdoutLine.length * 2, 4_096));
       const expanded = Buffer.allocUnsafe(nextCapacity);
       stdoutLine.copy(expanded, 0, 0, stdoutLineBytes);
       stdoutLine = expanded;
@@ -452,23 +544,23 @@ export function runSubagentProcess(options: SubagentProcessOptions): SubagentPro
           const end = newline < 0 ? buffer.length : newline;
           if (!appendStdout(buffer.subarray(offset, end))) return;
           if (newline < 0) return;
-          const line = stdoutLine.toString("utf8", 0, stdoutLineBytes);
-          stdoutLine = Buffer.alloc(0);
-          stdoutLineBytes = 0;
-          processLine(line);
+          processLine(readStdoutLine());
           offset = newline + 1;
         }
       });
       child.stderr.on("data", (chunk: Buffer | string) => {
         const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        const retained = buffer.subarray(0, Math.max(0, limits.stderrBytes - stderr.length));
+        const stderrLimit = Math.min(retention.stderrBytes, limits.stderrBytes ?? retention.stderrBytes);
+        const retained = buffer.subarray(0, Math.max(0, stderrLimit - stderr.length));
         if (retained.length) stderr = Buffer.concat([stderr, retained]);
         state.stderrTruncatedBytes += buffer.length - retained.length;
-        if (buffer.length > retained.length) requestTermination("limited", "stderr_limit", `Child stderr exceeds ${limits.stderrBytes} bytes`);
+        if (limits.stderrBytes !== undefined && stderr.length + state.stderrTruncatedBytes > limits.stderrBytes) {
+          requestTermination("limited", "stderr_limit", `Child stderr exceeds ${limits.stderrBytes} bytes`);
+        }
       });
       child.on("error", (error) => requestTermination("failed", "spawn_error", error.message));
       child.once("close", finish);
-      timeoutTimer = setTimeout(() => requestTermination("limited", "wall_time_limit"), limits.wallTimeMs);
+      if (limits.wallTimeMs !== undefined) timeoutTimer = setTimeout(() => requestTermination("limited", "wall_time_limit"), limits.wallTimeMs);
       options.signal?.addEventListener("abort", abortHandler, { once: true });
       if (options.signal?.aborted) abortHandler();
     } catch (error) {

package/subagent-ui.ts

@@ -120,14 +120,31 @@ function toRecord(item: ThreadListItem): ThreadRecord {
   };
 }
 
-export function formatThreadState(thread: Pick<ThreadRecord, "status" | "terminationReason">): ThreadStateView {
+function threadStatus(thread: Pick<ThreadRecord, "status" | "terminationReason">): ThreadStatus {
   const reason = thread.terminationReason;
-  if (thread.status === "complete") return { status: thread.status, label: "Complete" };
-  if (thread.status === "failed") return { status: thread.status, label: "Failed", reason, partialWork: "Failed before completion. Any saved output is partial work." };
-  if (thread.status === "cancelled") return { status: thread.status, label: "Stopped", reason, partialWork: "Stopped before completion. Any saved output is partial work." };
-  if (thread.status === "limited") return { status: thread.status, label: "Limited", reason, partialWork: "Stopped at a limit before completion. Any saved output is partial work." };
-  if (thread.status === "running") return { status: thread.status, label: "Running", reason };
-  return { status: thread.status, label: "Queued", reason };
+  if (thread.status === "failed" || reason === "error" || reason === "spawn_error" || reason === "process_closed" || reason === "missing_assistant_message" || reason === "malformed_jsonl" || reason === "invalid_usage" || reason?.startsWith("exit_")) return "failed";
+  if (thread.status === "cancelled" || reason === "abort" || reason === "interrupt") return "cancelled";
+  if (thread.status === "complete" || reason === "completed") return "complete";
+  return thread.status;
+}
+
+function threadReason(thread: Pick<ThreadRecord, "terminationReason" | "errorMessage">, status: ThreadStatus): string | undefined {
+  if (status === "cancelled" && thread.terminationReason === "interrupt") return "Interrupted by user.";
+  if (status === "cancelled" && thread.terminationReason === "abort") return "Cancelled by parent.";
+  if (status === "failed" && thread.errorMessage && thread.terminationReason) return `${thread.terminationReason}: ${thread.errorMessage}`;
+  if (status === "failed") return thread.errorMessage ?? thread.terminationReason ?? "Child process failed.";
+  return thread.terminationReason;
+}
+
+export function formatThreadState(thread: Pick<ThreadRecord, "status" | "terminationReason" | "errorMessage">): ThreadStateView {
+  const status = threadStatus(thread);
+  const reason = threadReason(thread, status);
+  if (status === "complete") return { status, label: "Complete" };
+  if (status === "failed") return { status, label: "Failed", reason, partialWork: "Failed before completion. Any saved output is partial work." };
+  if (status === "cancelled") return { status, label: "Stopped", reason, partialWork: "Stopped before completion. Any saved output is partial work." };
+  if (status === "limited") return { status, label: "Limited", reason, partialWork: "Stopped at a limit before completion. Any saved output is partial work." };
+  if (status === "running") return { status, label: "Running", reason };
+  return { status, label: "Queued", reason };
 }
 
 export function formatThreadUsage(usage: ThreadUsage): ThreadUsageView {
@@ -148,9 +165,9 @@ export function formatThreadTrace(thread: Pick<ThreadRecord, "trace" | "traceTru
   };
 }
 
-export function formatThreadHandoff(thread: Pick<ThreadRecord, "status" | "handoff" | "output">): ThreadHandoffView {
+export function formatThreadHandoff(thread: Pick<ThreadRecord, "status" | "terminationReason" | "handoff" | "output">): ThreadHandoffView {
   const text = thread.handoff ?? thread.output ?? "No handoff yet.";
-  return { label: "Handoff", text, isPartial: thread.status !== "complete" };
+  return { label: "Handoff", text, isPartial: threadStatus(thread) !== "complete" };
 }
 
 export function formatThreadControls(status: ThreadStatus): readonly ThreadBoardControl[] {

package/subagents.ts

@@ -15,25 +15,17 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { CHILD_TOOL_BUDGET_ENV, type ChildToolBudget } from "./subagent-budget.ts";
 import { SubagentThreadRegistry, type SubagentThread, type SubagentThreadId, type SubagentThreadState } from "./subagent-lifecycle.ts";
 import { runSubagentProcess, type SubagentProcessHandle, type SubagentProcessResult } from "./subagent-process.ts";
 import { formatThreadBoard, formatThreadInspection, type ThreadRecord as ThreadBoardRecord } from "./subagent-ui.ts";
 
 export const SUBAGENT_LIMITS = {
-  maxTasks: 8,
+  maxTasks: 10,
   maxReadConcurrency: 4,
-  defaultTimeoutMs: 300_000,
-  maxTimeoutMs: 600_000,
-  jsonlLineBytes: 32 * 1024 * 1024,
-  traceBytes: 2 * 1024 * 1024,
-  stderrBytes: 64 * 1024,
-  taskOutputBytes: 50 * 1024,
   toolOutputBytes: 50 * 1024,
-  quotaTokens: 250_000,
-  quotaUsd: 5,
-  readToolBudgetSoft: 24,
-  readToolBudgetHard: 32,
+  traceRetentionBytes: 8 * 1024 * 1024,
+  stderrRetentionBytes: 1 * 1024 * 1024,
+  taskOutputRetentionBytes: 1 * 1024 * 1024,
   roleFileBytes: 64 * 1024,
   taskCharacters: 20_000,
   killGraceMs: 5_000,
@@ -44,16 +36,9 @@ const READ_TOOLS = new Set(["read", "grep", "find", "ls", ...WEB_TOOLS]);
 const WRITE_TOOLS = new Set(["bash", "edit", "write"]);
 const KNOWN_TOOLS = new Set([...READ_TOOLS, ...WRITE_TOOLS]);
 const SUBAGENT_WEB_EXTENSION = "npm:pi-web-access";
-const SUBAGENT_BUDGET_EXTENSION = fileURLToPath(new URL("./subagent-budget.ts", import.meta.url));
 const INHERIT_SETTING = "inherit";
 const MAX_RUNTIME_STEERING_MESSAGES = 20;
 const ROLE_FIELDS = new Set(["name", "description", "access", "tools", "model", "thinking", "timeoutMs"]);
-const CHILD_REPORT_PROTOCOL = [
-  "## Child report protocol",
-  "Work in bounded passes. After the first useful evidence, write a concise report with findings, exact files, checks run, and remaining work.",
-  "Do not keep opening files or searching after you have enough evidence to answer the task.",
-  "If a tool budget notice or blocked-tool message appears, stop research and report from the context you have. A partial report is better than no report.",
-].join("\n");
 
 type ThinkingLevel = ModelThinkingLevel;
 export type AgentAccess = "read" | "write";
@@ -68,7 +53,7 @@ export interface AgentRole {
   tools: string[];
   model?: string;
   thinking?: string;
-  timeoutMs: number;
+  timeoutMs?: number;
   prompt: string;
   source: AgentSource;
   filePath: string;
@@ -160,7 +145,15 @@ 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;
+  stderrBytes?: number;
+  taskOutputBytes?: number;
+  quotaTokens?: number;
+  quotaUsd?: number;
+};
 
 export interface SubagentRuntimeOptions {
   bundledAgentsDir?: string;
@@ -243,14 +236,15 @@ function optionalPositiveInteger(
   frontmatter: Record<string, unknown>,
   filePath: string,
   field: string,
-  fallback: number,
-  maximum: number,
-): number {
+  fallback?: number,
+  maximum?: number,
+): number | undefined {
   const value = frontmatter[field];
   if (value === undefined || value === "") return fallback;
   const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
-  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > maximum) {
-    throw new AgentConfigurationError(filePath, field, `must be a positive integer no greater than ${maximum}`);
+  if (!Number.isInteger(parsed) || parsed <= 0 || maximum !== undefined && parsed > maximum) {
+    const bound = maximum === undefined ? "" : " no greater than " + maximum;
+    throw new AgentConfigurationError(filePath, field, `must be a positive integer${bound}`);
   }
   return parsed;
 }
@@ -307,7 +301,7 @@ function parseAgentFile(filePath: string, source: AgentSource, limits: SubagentL
     tools,
     model: typeof modelValue === "string" ? modelValue.trim() : undefined,
     thinking: typeof thinkingValue === "string" ? thinkingValue.trim() : undefined,
-    timeoutMs: optionalPositiveInteger(frontmatter, filePath, "timeoutMs", limits.defaultTimeoutMs, limits.maxTimeoutMs),
+    timeoutMs: optionalPositiveInteger(frontmatter, filePath, "timeoutMs"),
     prompt,
     source,
     filePath,
@@ -520,14 +514,19 @@ function cloneResult(result: SubagentTaskResult): SubagentTaskResult {
   };
 }
 
-function mergeTaskResults(previous: SubagentTaskResult | undefined, next: SubagentTaskResult, maxTraceBytes: number): SubagentTaskResult {
+function mergeTaskResults(
+  previous: SubagentTaskResult | undefined,
+  next: SubagentTaskResult,
+  maxTraceBytes?: number,
+  maxStderrBytes?: number,
+): SubagentTaskResult {
   if (!previous) return cloneResult(next);
   const merged = cloneResult(next);
   const trace: string[] = [];
   let traceBytes = 0;
   let traceTruncatedBytes = previous.traceTruncatedBytes + next.traceTruncatedBytes;
   for (const entry of [...previous.trace, ...next.trace]) {
-    const retained = truncateUtf8(entry, Math.max(0, maxTraceBytes - traceBytes));
+    const retained = truncateUtf8(entry, maxTraceBytes === undefined ? Buffer.byteLength(entry, "utf8") : Math.max(0, maxTraceBytes - traceBytes));
     if (retained.text) trace.push(retained.text);
     const retainedBytes = Buffer.byteLength(retained.text, "utf8");
     traceBytes += retainedBytes;
@@ -536,9 +535,11 @@ function mergeTaskResults(previous: SubagentTaskResult | undefined, next: Subage
   merged.trace = trace;
   merged.traceBytes = traceBytes;
   merged.traceTruncatedBytes = traceTruncatedBytes;
-  merged.stderr = [previous.stderr, next.stderr].filter(Boolean).join("\n");
+  const stderr = [previous.stderr, next.stderr].filter(Boolean).join("\n");
+  const retainedStderr = truncateUtf8(stderr, maxStderrBytes === undefined ? Buffer.byteLength(stderr, "utf8") : maxStderrBytes);
+  merged.stderr = retainedStderr.text;
   merged.stderrBytes = previous.stderrBytes + next.stderrBytes;
-  merged.stderrTruncatedBytes = previous.stderrTruncatedBytes + next.stderrTruncatedBytes;
+  merged.stderrTruncatedBytes = previous.stderrTruncatedBytes + next.stderrTruncatedBytes + retainedStderr.omittedBytes;
   merged.output = next.output || previous.output;
   merged.outputBytes = previous.outputBytes + next.outputBytes;
   merged.outputTruncatedBytes = previous.outputTruncatedBytes + next.outputTruncatedBytes;
@@ -558,7 +559,7 @@ function cloneDetails(mode: SubagentDetails["mode"], scope: AgentScope, projectA
 async function writeRolePrompt(agent: AgentRole): Promise<{ directory: string; filePath: string }> {
   const directory = await mkdtemp(path.join(os.tmpdir(), "killeros-subagent-"));
   const filePath = path.join(directory, `${agent.name.replace(/[^A-Za-z0-9_.-]/gu, "_")}.md`);
-  await writeFile(filePath, `${agent.prompt}\n\n${CHILD_REPORT_PROTOCOL}`, { encoding: "utf8", mode: 0o600 });
+  await writeFile(filePath, agent.prompt, { encoding: "utf8", mode: 0o600 });
   return { directory, filePath };
 }
 
@@ -574,10 +575,11 @@ interface RunTaskOptions {
   webExtension?: string;
   projectTrusted: boolean;
   limits: SubagentLimits;
+  sessionDirectory: string;
+  sessionId: string;
   timeoutMs?: number;
   onChange: (result: SubagentTaskResult) => void;
   onHandle?: (handle: SubagentProcessHandle) => void;
-  toolBudget?: ChildToolBudget;
 }
 
 function applyProcessResult(
@@ -641,10 +643,10 @@ async function runTask(options: RunTaskOptions): Promise<SubagentTaskResult> {
     const args = [
       "--mode", "json",
       "-p",
-      "--no-session",
+      "--session-dir", options.sessionDirectory,
+      "--session-id", options.sessionId,
       "--no-extensions",
       "--extension", options.webExtension ?? SUBAGENT_WEB_EXTENSION,
-      "--extension", SUBAGENT_BUDGET_EXTENSION,
       "--no-prompt-templates",
       options.projectTrusted ? "--approve" : "--no-approve",
       "--model", options.model.model,
@@ -659,18 +661,20 @@ async function runTask(options: RunTaskOptions): Promise<SubagentTaskResult> {
       signal: options.signal,
       spawnProcess: options.spawnProcess,
       limits: {
-        wallTimeMs: options.timeoutMs ?? agent.timeoutMs,
-        jsonlLineBytes: limits.jsonlLineBytes,
-        traceBytes: limits.traceBytes,
-        stderrBytes: limits.stderrBytes,
-        outputBytes: limits.taskOutputBytes,
-        quotaTokens: limits.quotaTokens,
-        quotaUsd: limits.quotaUsd,
+        ...(options.timeoutMs === undefined ? {} : { wallTimeMs: options.timeoutMs }),
+        ...(limits.jsonlLineBytes === undefined ? {} : { jsonlLineBytes: limits.jsonlLineBytes }),
+        ...(limits.traceBytes === undefined ? {} : { traceBytes: limits.traceBytes }),
+        ...(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,
       },
-      environment: options.toolBudget ? {
-        [CHILD_TOOL_BUDGET_ENV]: JSON.stringify(options.toolBudget),
-      } : undefined,
+      retention: {
+        traceBytes: limits.traceRetentionBytes,
+        stderrBytes: limits.stderrRetentionBytes,
+        outputBytes: limits.taskOutputRetentionBytes,
+      },
       onUpdate: (next) => applyProcessResult(result, next, startedAt, options.onChange),
     });
     options.onHandle?.(handle);
@@ -708,35 +712,35 @@ async function mapReadTasks<T>(items: T[], concurrency: number, run: (item: T, i
   await Promise.all(workers);
 }
 
-const TaskSchema = Type.Object({
-  agent: Type.String({ minLength: 1, maxLength: 64, description: "Agent role name" }),
-  task: Type.String({ minLength: 1, maxLength: SUBAGENT_LIMITS.taskCharacters, description: "Bounded task for the role" }),
-});
-
-const ChainTaskSchema = Type.Object({
-  agent: Type.String({ minLength: 1, maxLength: 64, description: "Agent role name" }),
-  task: Type.String({ minLength: 1, maxLength: SUBAGENT_LIMITS.taskCharacters, description: "Task with optional {previous} handoff placeholder" }),
-});
-
-const SubagentParams = Type.Object({
-  action: Type.Optional(StringEnum(["spawn", "list", "inspect", "steer", "interrupt", "collect", "close"] as const, {
-    default: "spawn",
-    description: "Thread lifecycle action",
-  })),
-  threadId: Type.Optional(Type.String({ minLength: 1, maxLength: 128, description: "Stable child thread ID" })),
-  message: Type.Optional(Type.String({ minLength: 1, maxLength: 4_000, description: "Bounded steering message" })),
-  all: Type.Optional(Type.Boolean({ description: "Interrupt every active child thread" })),
-  agent: Type.Optional(Type.String({ minLength: 1, maxLength: 64, description: "Agent role for single mode" })),
-  task: Type.Optional(Type.String({ minLength: 1, maxLength: SUBAGENT_LIMITS.taskCharacters, description: "Task for single mode" })),
-  tasks: Type.Optional(Type.Array(TaskSchema, { minItems: 1, maxItems: SUBAGENT_LIMITS.maxTasks, description: "Parallel role tasks" })),
-  chain: Type.Optional(Type.Array(ChainTaskSchema, { minItems: 1, maxItems: SUBAGENT_LIMITS.maxTasks, description: "Sequential role tasks; {previous} inserts the prior result" })),
-  model: Type.Optional(Type.String({ minLength: 1, maxLength: 256, description: "Model for every task as provider/model; inherit uses each role setting or the active parent" })),
-  thinking: Type.Optional(Type.String({ minLength: 1, maxLength: 16, description: "Thinking effort for every task: off, minimal, low, medium, high, xhigh, max, or inherit" })),
-  agentScope: Type.Optional(StringEnum(["user", "project", "both"] as const, {
-    default: "user",
-    description: "Role sources: user includes bundled and personal; project includes bundled and trusted project; both includes all",
-  })),
-});
+function createSubagentParams(limits: Pick<SubagentLimits, "maxTasks" | "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" }),
+  });
+  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" }),
+  });
+  return Type.Object({
+    action: Type.Optional(StringEnum(["spawn", "list", "inspect", "steer", "interrupt", "collect", "close"] as const, {
+      default: "spawn",
+      description: "Thread lifecycle action",
+    })),
+    threadId: Type.Optional(Type.String({ minLength: 1, maxLength: 128, description: "Stable child thread ID" })),
+    message: Type.Optional(Type.String({ minLength: 1, maxLength: 4_000, description: "Bounded steering message" })),
+    all: Type.Optional(Type.Boolean({ description: "Interrupt every active child thread" })),
+    agent: Type.Optional(Type.String({ minLength: 1, maxLength: 64, description: "Agent role for single mode" })),
+    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" })),
+    chain: Type.Optional(Type.Array(chainTaskSchema, { minItems: 1, maxItems: limits.maxTasks, description: "Sequential role tasks; {previous} inserts the prior result" })),
+    model: Type.Optional(Type.String({ minLength: 1, maxLength: 256, description: "Model for every task as provider/model; inherit uses each role setting or the active parent" })),
+    thinking: Type.Optional(Type.String({ minLength: 1, maxLength: 16, description: "Thinking effort for every task: off, minimal, low, medium, high, xhigh, max, or inherit" })),
+    agentScope: Type.Optional(StringEnum(["user", "project", "both"] as const, {
+      default: "user",
+      description: "Role sources: user includes bundled and personal; project includes bundled and trusted project; both includes all",
+    })),
+  });
+}
 
 type TaskInput = { agent: string; task: string };
 
@@ -753,16 +757,12 @@ function clipCharacters(text: string, maxCharacters: number, fromEnd = false): s
   return (fromEnd ? characters.slice(-maxCharacters) : characters.slice(0, maxCharacters)).join("");
 }
 
-function buildSteeredTask(task: string, steering: readonly string[], previousOutput: string | undefined, maxCharacters: number): string {
+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 previousLabel = previousOutput ? "\n\nPrevious child handoff:\n" : "";
-  const required = [...steeringLabel, ...steeringText, ...previousLabel].length;
+  const required = [...steeringLabel, ...steeringText].length;
   const taskText = clipCharacters(task, Math.max(0, maxCharacters - required));
-  const previousText = previousOutput
-    ? clipCharacters(previousOutput, Math.max(0, maxCharacters - [...taskText, ...steeringLabel, ...steeringText, ...previousLabel].length))
-    : "";
-  return `${taskText}${previousText ? `${previousLabel}${previousText}` : ""}${steeringLabel}${steeringText}`;
+  return `${taskText}${steeringLabel}${steeringText}`;
 }
 
 function formatUsage(usage: SubagentUsage): string {
@@ -967,7 +967,7 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
   };
 
   const syncThread = (threadId: SubagentThreadId, next: SubagentTaskResult, runtime?: ActiveThreadRuntime): SubagentTaskResult => {
-    const effective = mergeTaskResults(runtime?.aggregate, next, limits.traceBytes);
+    const effective = mergeTaskResults(runtime?.aggregate, next, limits.traceRetentionBytes, limits.stderrRetentionBytes);
     if (runtime?.requestedReason && next.status === "cancelled") effective.terminationReason = runtime.requestedReason;
     savedResults.set(threadId, cloneResult(effective));
     let thread = threads.inspect(threadId);
@@ -980,7 +980,9 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
     const from = runtime?.traceCount ?? 0;
     let retainedTraceBytes = thread.trace.reduce((total, entry) => total + Buffer.byteLength(entry.message ?? "", "utf8"), 0);
     for (const entry of next.trace.slice(from)) {
-      const retained = truncateUtf8(entry, Math.max(0, limits.traceBytes - retainedTraceBytes));
+      const retained = truncateUtf8(entry, limits.traceRetentionBytes === undefined
+        ? Buffer.byteLength(entry, "utf8")
+        : Math.max(0, limits.traceRetentionBytes - retainedTraceBytes));
       if (retained.text) {
         threads.trace(threadId, { kind: "child", message: retained.text });
         retainedTraceBytes += Buffer.byteLength(retained.text, "utf8");
@@ -1027,7 +1029,7 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
   pi.registerTool({
     name: "subagent",
     label: "Subagents",
-    description: "Spawn and manage named child threads. Children finish naturally; time, output, trace, stderr, quota, task count, and concurrency are the hard edges. Use action list, inspect, steer, interrupt, collect, and close to manage active and completed handoffs.",
+    description: "Spawn and manage named child threads. Children finish naturally; explicit execution guards, task count, and concurrency are the hard edges. Retention only bounds stored detail. Use action list, inspect, steer, interrupt, collect, and close to manage active and completed 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.",
@@ -1036,7 +1038,7 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
       "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.",
     ],
-    parameters: SubagentParams,
+    parameters: createSubagentParams(limits),
     executionMode: "parallel",
 
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
@@ -1226,6 +1228,23 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
           emit();
           return;
         }
+        let sessionDirectory: string;
+        try {
+          sessionDirectory = await mkdtemp(path.join(os.tmpdir(), "killeros-subagent-session-"));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          results[index] = {
+            ...results[index]!,
+            status: "failed",
+            terminationReason: "session_error",
+            errorMessage: message,
+          };
+          threads.fail(threadId, { message, code: "session_error" });
+          savedResults.set(threadId, cloneResult(results[index]!));
+          emit();
+          return;
+        }
+        const sessionId = `killeros-${threadId.replace(/[^A-Za-z0-9_.-]/gu, "_")}`;
         const controller = new AbortController();
         const abortParent = (): void => controller.abort();
         if (signal) {
@@ -1235,11 +1254,8 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         const runtime: ActiveThreadRuntime = { controller, steering: [], restarting: false, traceCount: 0, startedAt: Date.now() };
         activeRuntimes.set(threadId, runtime);
         const agent = roles.get(input.agent)!;
-        const baseToolBudget: ChildToolBudget | undefined = agent.access === "read"
-          ? { soft: limits.readToolBudgetSoft, hard: limits.readToolBudgetHard, block: [...READ_TOOLS] }
-          : undefined;
         const queuedSteering = initialThread.steering.map((entry) => entry.message);
-        let currentTask = queuedSteering.length ? buildSteeredTask(task, queuedSteering, undefined, limits.taskCharacters) : task;
+        let currentTask = queuedSteering.length ? buildSteeredTask(task, queuedSteering, limits.taskCharacters) : task;
         const stopForBudget = (reason: string, message: string): void => {
           const limited = cloneResult(runtime.aggregate ?? results[index]!);
           limited.status = "limited";
@@ -1261,49 +1277,38 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
         try {
           while (true) {
             const aggregate = runtime.aggregate;
-            const remainingWallTimeMs = agent.timeoutMs - (Date.now() - runtime.startedAt);
-            const usedTraceBytes = aggregate?.traceBytes ?? 0;
+            const wallTimeMs = agent.timeoutMs ?? limits.wallTimeMs;
+            const remainingWallTimeMs = wallTimeMs === undefined ? undefined : wallTimeMs - (Date.now() - runtime.startedAt);
+            const usedTraceBytes = (aggregate?.traceBytes ?? 0) + (aggregate?.traceTruncatedBytes ?? 0);
             const usedStderrBytes = aggregate?.stderrBytes ?? 0;
             const usedOutputBytes = aggregate?.outputBytes ?? 0;
-            const usedToolCalls = aggregate?.toolCallCount ?? 0;
             const usedTokens = aggregate?.usage.totalTokens ?? 0;
             const usedCost = aggregate?.usage.cost.total ?? 0;
-            if (remainingWallTimeMs <= 0) {
-              stopForBudget("wall_time_limit", `Child thread exceeds ${agent.timeoutMs} ms`);
+            if (remainingWallTimeMs !== undefined && remainingWallTimeMs <= 0) {
+              stopForBudget("wall_time_limit", `Child thread exceeds ${wallTimeMs} ms`);
               break;
             }
-            if (usedTraceBytes >= limits.traceBytes || aggregate?.traceTruncatedBytes) {
+            if (limits.traceBytes !== undefined && usedTraceBytes >= limits.traceBytes) {
               stopForBudget("trace_limit", `Child thread retains more than ${limits.traceBytes} trace bytes`);
               break;
             }
-            if (usedStderrBytes >= limits.stderrBytes || aggregate?.stderrTruncatedBytes) {
+            if (limits.stderrBytes !== undefined && usedStderrBytes >= limits.stderrBytes) {
               stopForBudget("stderr_limit", `Child thread emits more than ${limits.stderrBytes} stderr bytes`);
               break;
             }
-            if (usedOutputBytes >= limits.taskOutputBytes || aggregate?.outputTruncatedBytes) {
+            if (limits.taskOutputBytes !== undefined && usedOutputBytes >= limits.taskOutputBytes) {
               stopForBudget("output_limit", `Child thread emits more than ${limits.taskOutputBytes} output bytes`);
               break;
             }
-            if (baseToolBudget && usedToolCalls >= baseToolBudget.hard) {
-              stopForBudget("tool_call_limit", `Child thread exceeds ${baseToolBudget.hard} tool calls`);
-              break;
-            }
-            if (usedTokens >= limits.quotaTokens) {
+            if (limits.quotaTokens !== undefined && usedTokens >= limits.quotaTokens) {
               stopForBudget("quota_tokens", `Child thread exceeds ${limits.quotaTokens} tokens`);
               break;
             }
-            if (usedCost >= limits.quotaUsd) {
+            if (limits.quotaUsd !== undefined && usedCost >= limits.quotaUsd) {
               stopForBudget("quota_cost", `Child thread exceeds $${limits.quotaUsd}`);
               break;
             }
             runtime.traceCount = 0;
-            const toolBudget = baseToolBudget
-              ? {
-                ...baseToolBudget,
-                soft: Math.max(1, (baseToolBudget.soft ?? baseToolBudget.hard) - usedToolCalls),
-                hard: baseToolBudget.hard - usedToolCalls,
-              }
-              : undefined;
             const next = await runTask({
               cwd: ctx.cwd,
               agent: roles.get(input.agent)!,
@@ -1315,24 +1320,25 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
               webExtension: options.webExtension,
               projectTrusted: ctx.isProjectTrusted(),
               spawnProcess,
+              sessionDirectory,
+              sessionId,
               limits: {
                 ...limits,
-                traceBytes: limits.traceBytes - usedTraceBytes,
-                stderrBytes: limits.stderrBytes - usedStderrBytes,
-                taskOutputBytes: limits.taskOutputBytes - usedOutputBytes,
-                quotaTokens: limits.quotaTokens - usedTokens,
-                quotaUsd: limits.quotaUsd - usedCost,
+                ...(limits.traceBytes === undefined ? {} : { traceBytes: limits.traceBytes - usedTraceBytes }),
+                ...(limits.stderrBytes === undefined ? {} : { stderrBytes: limits.stderrBytes - usedStderrBytes }),
+                ...(limits.taskOutputBytes === undefined ? {} : { taskOutputBytes: limits.taskOutputBytes - usedOutputBytes }),
+                ...(limits.quotaTokens === undefined ? {} : { quotaTokens: limits.quotaTokens - usedTokens }),
+                ...(limits.quotaUsd === undefined ? {} : { quotaUsd: limits.quotaUsd - usedCost }),
               },
               timeoutMs: remainingWallTimeMs,
               onHandle: (handle) => { runtime.handle = handle; },
-              toolBudget,
               onChange: (changed) => {
                 results[index] = syncThread(threadId, changed, runtime);
                 emit();
               },
             });
             next.task = task;
-            runtime.aggregate = mergeTaskResults(runtime.aggregate, next, limits.traceBytes);
+            runtime.aggregate = mergeTaskResults(runtime.aggregate, next, limits.traceRetentionBytes, limits.stderrRetentionBytes);
             runtime.aggregate.task = task;
             results[index] = cloneResult(runtime.aggregate);
             savedResults.set(threadId, cloneResult(runtime.aggregate));
@@ -1348,11 +1354,16 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
                 handoff: runtime.aggregate.output ? { summary: runtime.aggregate.output } : undefined,
               });
             }
-            currentTask = buildSteeredTask(task, steering, runtime.aggregate.output, limits.taskCharacters);
+            currentTask = buildSteeredTask(task, steering, limits.taskCharacters);
           }
         } finally {
           activeRuntimes.delete(threadId);
           signal?.removeEventListener("abort", abortParent);
+          try {
+            await rm(sessionDirectory, { recursive: true, force: true });
+          } catch {
+            // Temporary child session cleanup is best effort after process termination.
+          }
         }
         emit();
       };

package/subagent-budget.ts

@@ -1,65 +0,0 @@
-import type { ExtensionAPI, ToolCallEventResult } from "@earendil-works/pi-coding-agent";
-
-export const CHILD_TOOL_BUDGET_ENV = "PI_KILLEROS_TOOL_BUDGET";
-
-export interface ChildToolBudget {
-	soft?: number;
-	hard: number;
-	block: "*" | string[];
-}
-
-export function parseChildToolBudget(value: string | undefined): ChildToolBudget | undefined {
-	if (!value?.trim()) return undefined;
-	try {
-		const parsed = JSON.parse(value) as Record<string, unknown>;
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
-		const hard = parsed.hard;
-		const soft = parsed.soft;
-		const block = parsed.block;
-		if (typeof hard !== "number" || !Number.isSafeInteger(hard) || hard < 1) return undefined;
-		if (soft !== undefined && (typeof soft !== "number" || !Number.isSafeInteger(soft) || soft < 1 || soft > hard)) return undefined;
-		if (block !== "*" && (!Array.isArray(block) || block.length === 0 || block.some((tool) => typeof tool !== "string" || !tool.trim()))) return undefined;
-		return {
-			hard,
-			...(soft === undefined ? {} : { soft }),
-			block: block === "*" ? "*" : [...new Set((block as string[]).map((tool) => tool.trim()))],
-		};
-	} catch {
-		return undefined;
-	}
-}
-
-function softNudge(budget: ChildToolBudget, calls: number): string {
-	return `Tool budget soft limit reached after ${calls} tool call${calls === 1 ? "" : "s"} (soft ${budget.soft}, hard ${budget.hard}). Stop starting new browsing/search work and finalize from the context you already have.`;
-}
-
-function shouldBlock(budget: ChildToolBudget, toolName: string, calls: number): boolean {
-	return calls > budget.hard && (budget.block === "*" || budget.block.includes(toolName));
-}
-
-export default function registerSubagentBudget(pi: ExtensionAPI): void {
-	const budget = parseChildToolBudget(process.env[CHILD_TOOL_BUDGET_ENV]);
-	if (!budget) return;
-	let calls = 0;
-	let nudged = false;
-	const sendUserMessage = (pi as unknown as {
-		sendUserMessage?: (content: string, options: { deliverAs: "steer" }) => unknown;
-	}).sendUserMessage;
-
-	pi.on("tool_call", (event): ToolCallEventResult | void => {
-		calls += 1;
-		if (!nudged && budget.soft !== undefined && calls >= budget.soft) {
-			nudged = true;
-			try {
-				sendUserMessage?.(softNudge(budget, calls), { deliverAs: "steer" });
-			} catch {
-				// The hard block below remains authoritative if steering is unavailable.
-			}
-		}
-		if (!shouldBlock(budget, event.toolName, calls)) return undefined;
-		return {
-			block: true,
-			reason: `Tool budget hard limit reached after ${calls} tool calls (hard ${budget.hard}). Finalize from the context you already have.`,
-		};
-	});
-}