killeros 1.5.5 → 1.5.7

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [1.5.7] - 2026-08-06
+
+### Fixed
+
+- Stopped runaway subagents at 64 turns or 2,000,000 reported tokens by default while preserving Pi's built-in model retries and the 30-minute wall limit.
+- Kept in-flight model retries labeled `Running`, exposed requested stops as terminal at once, and kept failed or limited children out of the **Active** list.
+- Replaced the frozen queued spawn result with a static launch receipt so only the separate live widget claims current state and usage.
+
+## [1.5.6] - 2026-08-05
+
+### Fixed
+
+- Rejected unknown named subagent roles before child launch and returned the available roles instead of falling back to the write-capable `worker`.
+- Kept the real child-boundary test isolated from parent Pi session variables and added direct coverage for inline parallel and chain spawns.
+- Clarified and tested the shared `message` field limits: 20,000 characters for a spawn task alias and 4,000 characters for steering.
+
 ## [1.5.5] - 2026-08-05
 
 ### Added

package/README.md

@@ -116,15 +116,15 @@ The tool supports a single `agent` plus `task` or its `message` alias, parallel
 | `resume` | `threadId` | `task` |
 | `close` | `threadId` | none |
 
-The three spawn shapes cannot be mixed. On a single spawn, `message` aliases `task`; supplying both is invalid. With `action: "steer"`, `message` remains required, and other lifecycle actions reject it. An unknown role name falls back to `worker` on a new spawn and reports that choice in the tool output. The `wait` action defaults to all queued or active children, waits up to 30 seconds by default, and never stops a child when it times out. The `resume` action keeps the same thread ID, name, session ID, and session directory and increments `attempt`; it requires the original named role and rejects inline roles. KillerOS rejects malformed requests before role discovery, project confirmation, thread creation, or child launch. The TUI shows a parallel or shared-pool schedule only after shape validation; malformed calls show `invalid request` instead of queued work. For example:
+The three spawn shapes cannot be mixed. On a single spawn, `message` aliases `task` with the same 20,000-character limit; supplying both is invalid. With `action: "steer"`, `message` remains required and has a 4,000-character limit, while other lifecycle actions reject it. An unknown named role fails before child launch and reports the available roles. The `wait` action defaults to all queued or active children, waits up to 30 seconds by default, and never stops a child when it times out. The `resume` action keeps the same thread ID, name, session ID, and session directory and increments `attempt`; it requires the original named role and rejects inline roles. KillerOS rejects malformed requests before role discovery, project confirmation, thread creation, or child launch. The TUI shows a parallel or shared-pool schedule only after shape validation; malformed calls show `invalid request` instead of queued work. For example:
 
 ```json
 {"agent":"reviewer","task":"Review the change","name":"auth-audit","model":"provider/model","thinking":"high"}
 ```
 
-Spawn returns the generated thread IDs immediately while the children continue in the background. This lets the parent use `list`, `inspect`, `wait`, `steer`, `interrupt`, `collect`, `resume`, and `close` in later tool calls. Compact thread records persist through Pi custom session entries. On parent restart, an active record restores as `orphaned`; `close` removes the child session only after confirmed process exit. When the batch settles, KillerOS delivers its bounded handoff as a Pi follow-up and triggers the parent turn. A batch cancelled by parent Escape remains inspectable but does not trigger a replacement turn.
+Spawn returns the generated thread IDs immediately while the children continue in the background. The completed spawn card is a static launch receipt; the separate live widget shows current state and usage until the batch settles. This lets the parent use `list`, `inspect`, `wait`, `steer`, `interrupt`, `collect`, `resume`, and `close` in later tool calls. Compact thread records persist through Pi custom session entries. On parent restart, an active record restores as `orphaned`; `close` removes the child session only after confirmed process exit. When the batch settles, KillerOS delivers its bounded handoff as a Pi follow-up and triggers the parent turn. A batch cancelled by parent Escape remains inspectable but does not trigger a replacement turn.
 
-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. An empty final assistant response is a failure. The default child wall time is 30 minutes; token and dollar quotas remain opt-in. Each JSONL record still has a bounded 8 MiB parser ceiling. 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, read-only-only batches to four concurrent readers, and bounds role files, task input, and combined parent output. An embedding caller may opt into named child resource guards. Aborting the originating parent turn stops its queued and active children; explicit `interrupt` actions and session shutdown also terminate active children and use a bounded 10-second process-exit wait.
+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. An empty final assistant response is a failure. Each child stops at the first default limit reached: 64 turns, 2,000,000 reported tokens, or 30 minutes. Dollar quotas remain opt-in. Each JSONL record still has a bounded 8 MiB parser ceiling. 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, read-only-only batches to four concurrent readers, and bounds role files, task input, and combined parent output. Embedding options can adjust the turn, token, wall-time, and other named resource guards. Aborting the originating parent turn stops its queued and active children; explicit `interrupt` actions and session shutdown also terminate active children and use a bounded 10-second process-exit wait.
 
 The command grammar is:
 
@@ -150,7 +150,7 @@ Threads move through `queued`, `active`, `done`, `failed`, `stopped`, `orphaned`
 
 The parent can inspect a thread’s prompt, role, model, tools, trace, usage, and handoff; wait for one named or ID child or all queued and active children; steer an active or queued thread with a bounded follow-up (at most 20 pending messages; further steering is rejected explicitly until the child restarts or drains the queue); interrupt one child or all active and queued children; collect a concise handoff into parent context; resume a terminal or orphaned child; and close a finished, stopped, or orphaned thread. An interrupt preserves the partial trace, states the reason, and reports the handoff as partial rather than successful. Closing removes a thread from the active workspace; heavy trace and result payloads are evicted as needed under the bounded retention budget, leaving a small inspectable tombstone.
 
-A child completes only when it returns usable final assistant text. The default wall time is 30 minutes; token and dollar quotas remain opt-in, while every JSONL record has an 8 MiB parser ceiling. Explicit embedding options can add 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. Aborting the originating parent turn settles queued work as cancelled and terminates active children; explicit `interrupt` actions and real child-process failures remain visible. Session shutdown also terminates active children and waits up to 10 seconds for confirmed process exit.
+A child completes only when it returns usable final assistant text. The default child limits are 64 turns, 2,000,000 reported tokens, and 30 minutes; dollar quotas remain opt-in, and every JSONL record has an 8 MiB parser ceiling. Explicit embedding options can adjust those limits or add output, trace, stderr, JSONL, or cost guards; each guard reports its cause and returns partial work clearly. The parent still bounds task count, reader concurrency, role files, task input, and combined parent output. Aborting the originating parent turn settles queued work as cancelled and terminates active children; explicit `interrupt` actions and real child-process failures remain visible. Session shutdown also terminates active children and waits up to 10 seconds for confirmed process exit.
 
 The replacement lifecycle has nine phases:
 
@@ -160,7 +160,7 @@ The replacement lifecycle has nine phases:
 4. **Steer:** append a bounded parent follow-up to an active or queued thread.
 5. **Interrupt:** stop one or all active or queued children while preserving partial work.
 6. **Collect:** return a concise handoff while retaining the expanded trace.
-7. **Guard:** honor only explicitly configured child resource guards; do not impose a routine turn stop.
+7. **Guard:** stop at the default turn, token, or wall-time limit and honor explicit resource-limit overrides.
 8. **Close:** remove a finished or stopped thread from the workspace while retaining a small inspectable tombstone; heavy payloads may be evicted under the retention budget.
 9. **Prove:** test identity, visibility, controls, natural completion, guards, partial handoffs, bounded retention, and closure.
 

package/killeros/subagent-process.ts

@@ -81,9 +81,10 @@ export interface SubagentProcessOptions {
   spawnProcess?: (args: string[], cwd: string, environment?: NodeJS.ProcessEnv) => SubagentProcessChild;
 }
 
-export interface SubagentProcessLimits {
-  wallTimeMs?: number;
-  jsonlLineBytes?: number;
+export interface SubagentProcessLimits {
+  wallTimeMs?: number;
+  maxTurns?: number;
+  jsonlLineBytes?: number;
   traceBytes?: number;
   stderrBytes?: number;
   outputBytes?: number;
@@ -223,7 +224,7 @@ function hasIsolatedSession(args: readonly string[]): boolean {
 
 function normalizeLimits(overrides: Partial<SubagentProcessLimits> | undefined): SubagentProcessLimits {
   const limits = { ...SUBAGENT_PROCESS_LIMITS, ...overrides };
-  for (const name of ["wallTimeMs", "jsonlLineBytes", "traceBytes", "stderrBytes", "outputBytes", "killGraceMs", "processExitWaitMs"] as const) {
+  for (const name of ["wallTimeMs", "maxTurns", "jsonlLineBytes", "traceBytes", "stderrBytes", "outputBytes", "killGraceMs", "processExitWaitMs"] as const) {
     const value = limits[name];
     if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0 || value > MAX_NODE_TIMER_MS
       && (name === "wallTimeMs" || name === "killGraceMs" || name === "processExitWaitMs"))) {
@@ -450,11 +451,14 @@ export function runSubagentProcess(options: SubagentProcessOptions): SubagentPro
     publish();
     resolveResult(cloneResult(state));
   };
-  const requestTermination = (status: Exclude<SubagentProcessStatus, "running" | "complete">, reason: string, errorMessage?: string): void => {
-    if (requestedStatus || closed) return;
-    requestedStatus = status;
-    requestedReason = reason;
-    if (errorMessage) state.errorMessage = errorMessage;
+  const requestTermination = (status: Exclude<SubagentProcessStatus, "running" | "complete">, reason: string, errorMessage?: string): void => {
+    if (requestedStatus || closed) return;
+    requestedStatus = status;
+    requestedReason = reason;
+    if (errorMessage) state.errorMessage = errorMessage;
+    state.status = status;
+    state.terminationReason = reason;
+    publish();
     if (!child) {
       finish(null);
       return;
@@ -485,8 +489,8 @@ export function runSubagentProcess(options: SubagentProcessOptions): SubagentPro
       state.usage.turns += 1;
       addUsage(state.usage, { ...message.usage, turns: 0 });
       state.toolCallCount += toolCallCount(message);
-      if (limits.quotaTokens !== undefined && state.usage.totalTokens > limits.quotaTokens) {
-        requestTermination("limited", "quota_tokens", `Child token usage exceeds ${limits.quotaTokens}`);
+      if (limits.quotaTokens !== undefined && state.usage.totalTokens >= limits.quotaTokens) {
+        requestTermination("limited", "quota_tokens", `Child token usage reaches ${limits.quotaTokens}`);
       } else if (limits.quotaUsd !== undefined && state.usage.cost.total > limits.quotaUsd) {
         requestTermination("limited", "quota_cost", `Child cost exceeds $${limits.quotaUsd}`);
       }
@@ -515,8 +519,11 @@ export function runSubagentProcess(options: SubagentProcessOptions): SubagentPro
           hasUsableAssistantResponse = true;
         }
       }
-      if (typeof message.errorMessage === "string") state.errorMessage = message.errorMessage;
-      publish();
+      if (typeof message.errorMessage === "string") state.errorMessage = message.errorMessage;
+      if (message.stopReason === "toolUse" && limits.maxTurns !== undefined && state.usage.turns >= limits.maxTurns) {
+        requestTermination("limited", "turn_limit", `Child turn count reached ${limits.maxTurns}`);
+      }
+      publish();
     } else if (event?.type === "tool_result_end" && event.message) {
       const name = typeof event.message.toolName === "string" ? event.message.toolName : "tool";
       const traceTruncatedBefore = state.traceTruncatedBytes;

package/killeros/subagent-ui.ts

@@ -131,7 +131,8 @@ function toRecord(item: ThreadListItem): ThreadRecord {
 function threadStatus(thread: Pick<ThreadRecord, "status" | "terminationReason">): ThreadStatus {
   const reason = thread.terminationReason;
   if (thread.status === "orphaned") return "orphaned";
-  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 === "queued" || thread.status === "running") return thread.status;
+  if (thread.status === "failed" || reason === "error" || reason === "model_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;
@@ -194,6 +195,7 @@ export function formatThreadControls(status: ThreadStatus): readonly ThreadBoard
 }
 
 export function formatThreadInspection(thread: ThreadRecord): ThreadInspectionView {
+  const state = formatThreadState(thread);
   return {
     id: thread.id,
     displayName: thread.displayName,
@@ -201,11 +203,11 @@ export function formatThreadInspection(thread: ThreadRecord): ThreadInspectionVi
     agent: thread.agent,
     task: thread.task,
     step: thread.step,
-    state: formatThreadState(thread),
+    state,
     usage: formatThreadUsage(thread.usage),
     trace: formatThreadTrace(thread),
     handoff: formatThreadHandoff(thread),
-    controls: formatThreadControls(thread.status),
+    controls: formatThreadControls(state.status),
   };
 }
 
@@ -231,8 +233,8 @@ export function formatThreadBoard(input: ThreadBoardInput): ParentThreadBoard {
     .filter((thread) => !closed.has(thread.id) && !current.has(thread.id))
     .map(toRecord) ?? [];
   const threads = [...current.values(), ...retained];
-  const active = threads.filter((thread) => !isDone(thread.status)).map((thread) => formatThreadListItem(thread, input.selectedThreadId));
-  const done = threads.filter((thread) => isDone(thread.status)).map((thread) => formatThreadListItem(thread, input.selectedThreadId));
+  const active = threads.filter((thread) => !isDone(threadStatus(thread))).map((thread) => formatThreadListItem(thread, input.selectedThreadId));
+  const done = threads.filter((thread) => isDone(threadStatus(thread))).map((thread) => formatThreadListItem(thread, input.selectedThreadId));
   const selectedThread = input.selectedThreadId ? threads.find((thread) => thread.id === input.selectedThreadId) : undefined;
   return {
     title: input.title ?? "Threads",

package/killeros/subagents.ts

@@ -29,9 +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,
+  taskCharacters: 20_000,
+  killGraceMs: 5_000,
+  defaultMaxTurns: 64,
+  defaultQuotaTokens: 2_000_000,
+  defaultWallTimeMs: 1_800_000,
   processExitWaitMs: 10_000,
 } as const;
 
@@ -136,8 +138,9 @@ export interface SubagentDetails {
   threads?: SubagentThread[];
   activeThreads?: SubagentThread[];
   doneThreads?: SubagentThread[];
-  selectedThreadId?: string;
-  wait?: SubagentWaitSummary;
+  selectedThreadId?: string;
+  wait?: SubagentWaitSummary;
+  backgroundStarted?: boolean;
 }
 
 export interface SubagentWaitSummary {
@@ -192,9 +195,10 @@ interface SpawnedProcess {
   once(event: "close", listener: (code: number | null) => void): this;
 }
 
-type SubagentLimits = { [Key in keyof typeof SUBAGENT_LIMITS]: number } & {
-  wallTimeMs?: number;
-  jsonlLineBytes?: number;
+type SubagentLimits = { [Key in keyof typeof SUBAGENT_LIMITS]: number } & {
+  wallTimeMs?: number;
+  maxTurns?: number;
+  jsonlLineBytes?: number;
   traceBytes?: number;
   stderrBytes?: number;
   taskOutputBytes?: number;
@@ -723,9 +727,10 @@ async function runTask(options: RunTaskOptions): Promise<SubagentTaskResult> {
       cwd: options.cwd,
       signal: options.signal,
       spawnProcess: options.spawnProcess,
-      limits: {
-        ...(options.timeoutMs === undefined ? {} : { wallTimeMs: options.timeoutMs }),
-        ...(limits.jsonlLineBytes === undefined ? {} : { jsonlLineBytes: limits.jsonlLineBytes }),
+      limits: {
+        ...(options.timeoutMs === undefined ? {} : { wallTimeMs: options.timeoutMs }),
+        ...(limits.maxTurns === undefined ? {} : { maxTurns: limits.maxTurns }),
+        ...(limits.jsonlLineBytes === undefined ? {} : { jsonlLineBytes: limits.jsonlLineBytes }),
         ...(limits.traceBytes === undefined ? {} : { traceBytes: limits.traceBytes }),
         ...(limits.stderrBytes === undefined ? {} : { stderrBytes: limits.stderrBytes }),
         ...(limits.taskOutputBytes === undefined ? {} : { outputBytes: limits.taskOutputBytes }),
@@ -1166,7 +1171,7 @@ function createSubagentParams(limits: Pick<SubagentLimits, "maxTasks" | "maxRead
     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: "Task alias when spawning; steering message with action steer" })),
+    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),
@@ -2292,26 +2297,18 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
       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 fallbackNotices: string[] = [];
-      const rolesForInputs = rawInputs.map((input) => {
+      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;
-        if (isResume) {
-          const available = discovery.agents.map((agent) => `${agent.name} (${agent.source})`).join(", ") || "none";
-          throw new Error(`Unknown subagent ${JSON.stringify(input.agent)}. Available: ${available}`);
-        }
-        const worker = roles.get("worker");
-        if (!worker) throw new Error(`Unknown subagent ${JSON.stringify(input.agent)} and fallback role "worker" is unavailable`);
-        const notice = `Unknown role ${JSON.stringify(input.agent)} - used worker`;
-        if (!fallbackNotices.includes(notice)) fallbackNotices.push(notice);
-        return worker;
+        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,
@@ -2351,7 +2348,7 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
           ? `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 = [...fallbackNotices, ...(scheduleNote ? [scheduleNote] : [])].join("\n") || undefined;
+      const executionNote = scheduleNote;
 
       const inFlight = threads.listAll().filter((thread) => ["queued", "active"].includes(thread.state)).length;
       if (inFlight + inputs.length > limits.maxTasks) {
@@ -2600,9 +2597,12 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
             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 usedTokens = aggregate?.usage.totalTokens ?? 0;
-            const usedCost = aggregate?.usage.cost.total ?? 0;
+            const usedOutputBytes = aggregate?.outputBytes ?? 0;
+            const usedTokens = aggregate?.usage.totalTokens ?? 0;
+            const usedCost = aggregate?.usage.cost.total ?? 0;
+            const usedTurns = aggregate?.usage.turns ?? 0;
+            const maxTurns = limits.maxTurns ?? limits.defaultMaxTurns;
+            const quotaTokens = limits.quotaTokens ?? limits.defaultQuotaTokens;
             if (remainingWallTimeMs !== undefined && remainingWallTimeMs <= 0) {
               stopForBudget("wall_time_limit", `Child thread exceeds ${wallTimeMs} ms`);
               break;
@@ -2619,10 +2619,14 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
               stopForBudget("output_limit", `Child thread emits more than ${limits.taskOutputBytes} output bytes`);
               break;
             }
-            if (limits.quotaTokens !== undefined && usedTokens >= limits.quotaTokens) {
-              stopForBudget("quota_tokens", `Child thread exceeds ${limits.quotaTokens} tokens`);
-              break;
-            }
+            if (usedTurns >= maxTurns) {
+              stopForBudget("turn_limit", `Child thread reaches ${maxTurns} turns`);
+              break;
+            }
+            if (usedTokens >= quotaTokens) {
+              stopForBudget("quota_tokens", `Child thread reaches ${quotaTokens} tokens`);
+              break;
+            }
             if (limits.quotaUsd !== undefined && usedCost >= limits.quotaUsd) {
               stopForBudget("quota_cost", `Child thread exceeds $${limits.quotaUsd}`);
               break;
@@ -2646,10 +2650,11 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
               limits: {
                 ...limits,
                 ...(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 }),
+                ...(limits.stderrBytes === undefined ? {} : { stderrBytes: limits.stderrBytes - usedStderrBytes }),
+                ...(limits.taskOutputBytes === undefined ? {} : { taskOutputBytes: limits.taskOutputBytes - usedOutputBytes }),
+                maxTurns: maxTurns - usedTurns,
+                quotaTokens: quotaTokens - usedTokens,
+                ...(limits.quotaUsd === undefined ? {} : { quotaUsd: limits.quotaUsd - usedCost }),
               },
               timeoutMs: remainingWallTimeMs,
               onHandle: (handle) => {
@@ -2884,9 +2889,10 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
 
       const queuedBoard = detailsFor(parentId, mode, scope, discovery.projectAgentsDir, isResume ? resumeTarget?.id : undefined);
       const queuedResults = results.map(cloneResult);
-      const queuedDetails: SubagentDetails = {
-        ...queuedBoard,
-        executionNote,
+      const queuedDetails: SubagentDetails = {
+        ...queuedBoard,
+        backgroundStarted: true,
+        executionNote,
         results: queuedResults,
         aggregateUsage: aggregateUsage(queuedResults),
       };
@@ -2968,11 +2974,20 @@ export function registerSubagentTool(pi: ExtensionAPI, options: SubagentRuntimeO
 
     renderResult(result, { expanded }, theme) {
       const details = result.details as SubagentDetails | undefined;
-      if (!details?.results.length) {
-        const first = result.content[0];
-        return new Text(first?.type === "text" ? first.text : "(no output)", 0, 0);
-      }
-      const board = formatThreadBoard({
+      if (!details?.results.length) {
+        const first = result.content[0];
+        return new Text(first?.type === "text" ? first.text : "(no output)", 0, 0);
+      }
+      if (details.backgroundStarted) {
+        const lines = [
+          theme.fg("toolTitle", theme.bold(`Started in background (${details.results.length})`)),
+          ...details.results.map((task) => `${theme.fg("toolTitle", theme.bold(task.name ?? task.agent))}${theme.fg("dim", ` · role ${task.agent} · ${task.id} · attempt ${task.attempt ?? 1}`)}`),
+        ];
+        if (details.executionNote) lines.push(theme.fg("dim", details.executionNote));
+        lines.push(theme.fg("dim", "Live status appears below while child threads run."));
+        return new Text(lines.join("\n"), 0, 0);
+      }
+      const board = formatThreadBoard({
         title: `Subagents · ${details.mode}`,
         threads: details.results.map(threadBoardRecord),
         selectedThreadId: details.selectedThreadId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "1.5.5",
+  "version": "1.5.7",
   "description": "A production-hardened TUI and workflow extension for the Pi coding agent.",
   "type": "module",
   "keywords": [