7b4c47b fix(subagents): preserve pending resume tracking · zut

M README.md +3 -3


@@ -401,11 +401,11 @@ Background subagents that run alongside your main session. Each one is a separat
401	401
402	402		`/session export` does NOT bundle subagents. A `.zutsession` is just the main chat transcript; per-agent state (session file, unix-socket inbox) is machine-local and doesn't round-trip through a JSONL file. To share what an agent said, copy it out of the transcript view manually.
403	403
404		-	Auto-subagents. With `/settings` -> auto-subagents on, the interactive primary agent enters strict orchestrator mode and gets whichever of the canonical `subagent_spawn` and `subagent_status` tools are permitted by launch-time policy. It must delegate all implementation, debugging/testing, and code-review work to an appropriately named profile, or to a clearly described general worker when no profile fits. It must not write or edit code, make direct implementation tool calls, inspect or review code, or apply worker patches itself. It may decompose requests, select and spawn workers, check status, coordinate follow-ups, and synthesize results. Give workers self-contained tasks: shared-worktree workers edit the same working directory and need coordination, while `isolation:"worktree"` is for parallel coding in separate trees; a worktree patch must be integrated by a worker rather than applied by the primary agent. Child workers cannot recursively spawn more sub-agents in v1. The `subagent_status` tool accepts an optional `agent_id`: omit it to list visible workers, or pass a full id / unique prefix to query one without waiting for completion. It returns privacy-safe JSON metadata with the worker id, lifecycle state (`starting`, `running`, `completed`, `failed`, `cancelled`, or `detached`), underlying process/turn state, timestamps, a bounded first-line task summary, and terminal-result metadata when available; it does not return prompts, transcripts, result output, credentials, provider settings, or filesystem paths. The spawn tool returns the child id and initial state immediately; completion is a durable `turn.result` with a `subagent://<id>/result` reference. It accepts named profiles, timeout, `max_turns`, and shared/worktree isolation. Omit `max_turns` to use the supervisor policy; the default ceiling is 3 and `subagents.max_turns` changes it. Global concurrency limits apply equally to slash commands, tool calls, and batches. Completion is host-event-driven: wait for the host-injected `[auto-subagents update]`, the only completion signal. Never use `bash sleep`, `watch`, `tail -f`, polling loops, repeated `subagent_status`, or dashboard/metadata/event-log/file checks solely to wait; work on unrelated independent tasks or end/yield your turn. Legitimate waits inside user-requested commands, provider flows, extensions, or tests remain allowed. Off by default; toggle from `/settings`. When off, the permitted canonical subagent tools remain available for user-requested delegation or when an active skill workflow requires it; the primary otherwise performs work itself without the strict orchestrator contract or profile manifest.
	404	+	Auto-subagents. With `/settings` -> auto-subagents on, the interactive primary agent enters strict orchestrator mode and gets whichever of the canonical `subagent_spawn` and `subagent_status` tools are permitted by launch-time policy. It must delegate all implementation, debugging/testing, and code-review work to an appropriately named profile, or to a clearly described general worker when no profile fits. It must not write or edit code, make direct implementation tool calls, inspect or review code, or apply worker patches itself. It may decompose requests, select and spawn workers, check status, coordinate follow-ups, and synthesize results. Give workers self-contained tasks: shared-worktree workers edit the same working directory and need coordination, while `isolation:"worktree"` is for parallel coding in separate trees; a worktree patch must be integrated by a worker rather than applied by the primary agent. Child workers cannot recursively spawn more sub-agents in v1. The `subagent_status` tool accepts an optional `agent_id`: omit it to list visible workers, or pass a full id / unique prefix to query one without waiting for completion. It returns privacy-safe JSON metadata with the worker id, lifecycle state (`starting`, `running`, `completed`, `failed`, `cancelled`, or `detached`), underlying process/turn state, timestamps, a bounded first-line task summary, and terminal-result metadata when available; it does not return prompts, transcripts, result output, credentials, provider settings, or filesystem paths. The spawn tool returns the child id and initial state immediately; completion is a durable `turn.result` with a `subagent://<id>/result` reference. It accepts named profiles, timeout, `max_turns`, and shared/worktree isolation. Omit `max_turns` to use the supervisor policy; the default ceiling is 3 and `subagents.max_turns` changes it. Global concurrency limits apply equally to slash commands, tool calls, and batches. Completion is host-event-driven: wait for the host-injected `[auto-subagents update]`, the only completion signal. Never use `bash sleep`, `watch`, `tail -f`, polling loops, repeated `subagent_status`, or dashboard/metadata/event-log/file checks solely to wait; work on unrelated independent tasks or end/yield your turn. Legitimate waits inside user-requested commands, provider flows, extensions, or tests remain allowed. Off by default; toggle from `/settings`. When off, the permitted canonical subagent tools and profile manifest remain available for user-requested delegation or when an active skill workflow requires it; the primary otherwise performs work itself without the strict orchestrator contract.
405	405
406	406		### Named subagent profiles
407	407
408		-	zut discovers the common markdown/frontmatter profile layout from `~/.agents/agents/*.md` by default. With auto-subagents enabled and `subagent_spawn` available, the orchestrator receives `[subagents_list]` metadata and should select the appropriately named profile for each worker when one matches; otherwise it can spawn a clearly described general worker without an `agent` field. If launch-time policy withholds `subagent_spawn`, strict orchestrator guidance remains active but profile metadata is omitted; the primary reports that delegation is unavailable instead of implementing directly. Profile bodies are applied only to the selected child. See [docs/subagents.md](docs/subagents.md) for discovery, supported fields, reasoning levels, and examples.
	408	+	zut discovers the common markdown/frontmatter profile layout from `~/.agents/agents/*.md` by default. Whenever `subagent_spawn` is available, the primary agent receives `[subagents_list]` metadata and should select the appropriately named profile for each worker when one matches; otherwise it can spawn a clearly described general worker without an `agent` field. If launch-time policy withholds `subagent_spawn`, strict orchestrator guidance remains active but profile metadata is omitted; the primary reports that delegation is unavailable instead of implementing directly. Profile bodies are applied only to the selected child. See [docs/subagents.md](docs/subagents.md) for discovery, supported fields, reasoning levels, and examples.
409	409
410	410		### `/settings`
411	411

@@ -415,7 +415,7 @@ Opens a dialog with every persistent setting. `up`/`down` to navigate, `enter` o
415	415		- render images when supported — draw screenshots / `read`-returned images inline using the terminal's image protocol, or fall back to a text placeholder. Auto-detected from `TERM_PROGRAM`; the toggle overrides the detection. The row is greyed out and forced off on terminals that don't speak any image protocol.
416	416		- terminal alerts — emit a terminal bell when the main session stops with work that may need attention, or when an extension raises a structured alert. Enabled by default; changes apply immediately and persist as `terminal_alerts_enabled`. Terminal emulators may render the bell audibly, visually, or not at all.
417	417		- AI terminal titles — after the first real prompt of a fresh interactive session, make one small hidden request to the active model and set the terminal title to `zut: <title>`. The title is limited to 40 Unicode characters, persisted with the session, restored on resume, and never added to the conversation. Enabled by default; disable it to avoid the extra model request. The toggle applies immediately, but title generation still waits for the first real prompt and never starts from startup context, resumed history, or slash commands. Persists as `terminal_title_enabled`.
418		-	- auto-subagents — enable strict primary-agent orchestrator mode: delegate implementation, debugging/testing, and code-review work to named or general workers; the primary agent coordinates but does not make direct implementation changes. It can spawn background sub-agents via `subagent_spawn` and query live state via `subagent_status` when those tools are permitted. If delegation is unavailable because of launch-time restrictions, the contract remains active, profile metadata is withheld, and the primary reports the limitation rather than implementing directly. Off by default. When off, the permitted canonical subagent tools remain available for user-requested delegation or when an active skill workflow requires it; the primary otherwise works directly without the strict orchestrator contract or profile manifest. The tools accept named profiles, reasoning, timeout, turn limits, and shared/worktree isolation where applicable; lifecycle and result references are persisted. Completion is host-event-driven: `[auto-subagents update]` completion updates are the only signal; do not poll or inspect dashboards, metadata, event logs, or files solely to wait. See `/subagents` and [docs/subagents.md](docs/subagents.md) for details.
	418	+	- auto-subagents — enable strict primary-agent orchestrator mode: delegate implementation, debugging/testing, and code-review work to named or general workers; the primary agent coordinates but does not make direct implementation changes. It can spawn background sub-agents via `subagent_spawn` and query live state via `subagent_status` when those tools are permitted. If delegation is unavailable because of launch-time restrictions, the contract remains active, profile metadata is withheld, and the primary reports the limitation rather than implementing directly. Off by default. When off, the permitted canonical subagent tools and profile manifest remain available for user-requested delegation or when an active skill workflow requires it; the primary otherwise works directly without the strict orchestrator contract. The tools accept named profiles, reasoning, per-spawn fast-mode overrides, timeout, turn limits, and shared/worktree isolation where applicable; lifecycle and result references are persisted. Completion is host-event-driven: `[auto-subagents update]` completion updates are the only signal; do not poll or inspect dashboards, metadata, event logs, or files solely to wait. See `/subagents` and [docs/subagents.md](docs/subagents.md) for details.
419	419		- Ponytail coding mode — include compact engineering guidance in each resolved system prompt; the guidance tells the model to apply it to coding, debugging, and review work rather than ordinary conversation. It favors understanding the real flow, small validated changes, reuse, and preserving safety checks. Enabled by default; changes apply to the next model call and persist as `ponytail_enabled` in `$ZUT_HOME/config.json`. It is included by interactive, print, stream, JSON, RPC, subagent, bot, SDK, and Zutfile agents.
420	420		- fast mode — request the provider's fast tier where supported. It currently uses OpenAI's Fast service tier for OpenAI, OpenAI Responses, and OpenAI Codex models. Off by default; toggle it with `/fast` or `/settings`; changes apply on the next model call and persist as `fast_mode`. Other providers currently return an unsupported-provider error. Fast mode may cost more and depends on the selected model/account.
421	421		- lsp in main session — enable the built-in `lsp` tool and code diagnostics for the main agent. Enabled by default; changes persist as `lsp_enabled`.


@@ -401,11 +401,11 @@ Background subagents that run alongside your main session. Each one is a separat
401			401
402		`/session export` does NOT bundle subagents. A `.zutsession` is just the main chat transcript; per-agent state (session file, unix-socket inbox) is machine-local and doesn't round-trip through a JSONL file. To share what an agent said, copy it out of the transcript view manually.	402		`/session export` does NOT bundle subagents. A `.zutsession` is just the main chat transcript; per-agent state (session file, unix-socket inbox) is machine-local and doesn't round-trip through a JSONL file. To share what an agent said, copy it out of the transcript view manually.
403			403
404	-	Auto-subagents. With `/settings` -> auto-subagents on, the interactive primary agent enters strict orchestrator mode and gets whichever of the canonical `subagent_spawn` and `subagent_status` tools are permitted by launch-time policy. It must delegate all implementation, debugging/testing, and code-review work to an appropriately named profile, or to a clearly described general worker when no profile fits. It must not write or edit code, make direct implementation tool calls, inspect or review code, or apply worker patches itself. It may decompose requests, select and spawn workers, check status, coordinate follow-ups, and synthesize results. Give workers self-contained tasks: shared-worktree workers edit the same working directory and need coordination, while `isolation:"worktree"` is for parallel coding in separate trees; a worktree patch must be integrated by a worker rather than applied by the primary agent. Child workers cannot recursively spawn more sub-agents in v1. The `subagent_status` tool accepts an optional `agent_id`: omit it to list visible workers, or pass a full id / unique prefix to query one without waiting for completion. It returns privacy-safe JSON metadata with the worker id, lifecycle state (`starting`, `running`, `completed`, `failed`, `cancelled`, or `detached`), underlying process/turn state, timestamps, a bounded first-line task summary, and terminal-result metadata when available; it does not return prompts, transcripts, result output, credentials, provider settings, or filesystem paths. The spawn tool returns the child id and initial state immediately; completion is a durable `turn.result` with a `subagent://<id>/result` reference. It accepts named profiles, timeout, `max_turns`, and shared/worktree isolation. Omit `max_turns` to use the supervisor policy; the default ceiling is 3 and `subagents.max_turns` changes it. Global concurrency limits apply equally to slash commands, tool calls, and batches. Completion is host-event-driven: wait for the host-injected `[auto-subagents update]`, the only completion signal. Never use `bash sleep`, `watch`, `tail -f`, polling loops, repeated `subagent_status`, or dashboard/metadata/event-log/file checks solely to wait; work on unrelated independent tasks or end/yield your turn. Legitimate waits inside user-requested commands, provider flows, extensions, or tests remain allowed. Off by default; toggle from `/settings`. When off, the permitted canonical subagent tools remain available for user-requested delegation or when an active skill workflow requires it; the primary otherwise performs work itself without the strict orchestrator contract or profile manifest.	404	+	Auto-subagents. With `/settings` -> auto-subagents on, the interactive primary agent enters strict orchestrator mode and gets whichever of the canonical `subagent_spawn` and `subagent_status` tools are permitted by launch-time policy. It must delegate all implementation, debugging/testing, and code-review work to an appropriately named profile, or to a clearly described general worker when no profile fits. It must not write or edit code, make direct implementation tool calls, inspect or review code, or apply worker patches itself. It may decompose requests, select and spawn workers, check status, coordinate follow-ups, and synthesize results. Give workers self-contained tasks: shared-worktree workers edit the same working directory and need coordination, while `isolation:"worktree"` is for parallel coding in separate trees; a worktree patch must be integrated by a worker rather than applied by the primary agent. Child workers cannot recursively spawn more sub-agents in v1. The `subagent_status` tool accepts an optional `agent_id`: omit it to list visible workers, or pass a full id / unique prefix to query one without waiting for completion. It returns privacy-safe JSON metadata with the worker id, lifecycle state (`starting`, `running`, `completed`, `failed`, `cancelled`, or `detached`), underlying process/turn state, timestamps, a bounded first-line task summary, and terminal-result metadata when available; it does not return prompts, transcripts, result output, credentials, provider settings, or filesystem paths. The spawn tool returns the child id and initial state immediately; completion is a durable `turn.result` with a `subagent://<id>/result` reference. It accepts named profiles, timeout, `max_turns`, and shared/worktree isolation. Omit `max_turns` to use the supervisor policy; the default ceiling is 3 and `subagents.max_turns` changes it. Global concurrency limits apply equally to slash commands, tool calls, and batches. Completion is host-event-driven: wait for the host-injected `[auto-subagents update]`, the only completion signal. Never use `bash sleep`, `watch`, `tail -f`, polling loops, repeated `subagent_status`, or dashboard/metadata/event-log/file checks solely to wait; work on unrelated independent tasks or end/yield your turn. Legitimate waits inside user-requested commands, provider flows, extensions, or tests remain allowed. Off by default; toggle from `/settings`. When off, the permitted canonical subagent tools and profile manifest remain available for user-requested delegation or when an active skill workflow requires it; the primary otherwise performs work itself without the strict orchestrator contract.
405			405
406		### Named subagent profiles	406		### Named subagent profiles
407			407
408	-	zut discovers the common markdown/frontmatter profile layout from `~/.agents/agents/*.md` by default. With auto-subagents enabled and `subagent_spawn` available, the orchestrator receives `[subagents_list]` metadata and should select the appropriately named profile for each worker when one matches; otherwise it can spawn a clearly described general worker without an `agent` field. If launch-time policy withholds `subagent_spawn`, strict orchestrator guidance remains active but profile metadata is omitted; the primary reports that delegation is unavailable instead of implementing directly. Profile bodies are applied only to the selected child. See [docs/subagents.md](docs/subagents.md) for discovery, supported fields, reasoning levels, and examples.	408	+	zut discovers the common markdown/frontmatter profile layout from `~/.agents/agents/*.md` by default. Whenever `subagent_spawn` is available, the primary agent receives `[subagents_list]` metadata and should select the appropriately named profile for each worker when one matches; otherwise it can spawn a clearly described general worker without an `agent` field. If launch-time policy withholds `subagent_spawn`, strict orchestrator guidance remains active but profile metadata is omitted; the primary reports that delegation is unavailable instead of implementing directly. Profile bodies are applied only to the selected child. See [docs/subagents.md](docs/subagents.md) for discovery, supported fields, reasoning levels, and examples.
409			409
410		### `/settings`	410		### `/settings`
411			411

@@ -415,7 +415,7 @@ Opens a dialog with every persistent setting. `up`/`down` to navigate, `enter` o
415		- render images when supported — draw screenshots / `read`-returned images inline using the terminal's image protocol, or fall back to a text placeholder. Auto-detected from `TERM_PROGRAM`; the toggle overrides the detection. The row is greyed out and forced off on terminals that don't speak any image protocol.	415		- render images when supported — draw screenshots / `read`-returned images inline using the terminal's image protocol, or fall back to a text placeholder. Auto-detected from `TERM_PROGRAM`; the toggle overrides the detection. The row is greyed out and forced off on terminals that don't speak any image protocol.
416		- terminal alerts — emit a terminal bell when the main session stops with work that may need attention, or when an extension raises a structured alert. Enabled by default; changes apply immediately and persist as `terminal_alerts_enabled`. Terminal emulators may render the bell audibly, visually, or not at all.	416		- terminal alerts — emit a terminal bell when the main session stops with work that may need attention, or when an extension raises a structured alert. Enabled by default; changes apply immediately and persist as `terminal_alerts_enabled`. Terminal emulators may render the bell audibly, visually, or not at all.
417		- AI terminal titles — after the first real prompt of a fresh interactive session, make one small hidden request to the active model and set the terminal title to `zut: <title>`. The title is limited to 40 Unicode characters, persisted with the session, restored on resume, and never added to the conversation. Enabled by default; disable it to avoid the extra model request. The toggle applies immediately, but title generation still waits for the first real prompt and never starts from startup context, resumed history, or slash commands. Persists as `terminal_title_enabled`.	417		- AI terminal titles — after the first real prompt of a fresh interactive session, make one small hidden request to the active model and set the terminal title to `zut: <title>`. The title is limited to 40 Unicode characters, persisted with the session, restored on resume, and never added to the conversation. Enabled by default; disable it to avoid the extra model request. The toggle applies immediately, but title generation still waits for the first real prompt and never starts from startup context, resumed history, or slash commands. Persists as `terminal_title_enabled`.
418	-	- auto-subagents — enable strict primary-agent orchestrator mode: delegate implementation, debugging/testing, and code-review work to named or general workers; the primary agent coordinates but does not make direct implementation changes. It can spawn background sub-agents via `subagent_spawn` and query live state via `subagent_status` when those tools are permitted. If delegation is unavailable because of launch-time restrictions, the contract remains active, profile metadata is withheld, and the primary reports the limitation rather than implementing directly. Off by default. When off, the permitted canonical subagent tools remain available for user-requested delegation or when an active skill workflow requires it; the primary otherwise works directly without the strict orchestrator contract or profile manifest. The tools accept named profiles, reasoning, timeout, turn limits, and shared/worktree isolation where applicable; lifecycle and result references are persisted. Completion is host-event-driven: `[auto-subagents update]` completion updates are the only signal; do not poll or inspect dashboards, metadata, event logs, or files solely to wait. See `/subagents` and [docs/subagents.md](docs/subagents.md) for details.	418	+	- auto-subagents — enable strict primary-agent orchestrator mode: delegate implementation, debugging/testing, and code-review work to named or general workers; the primary agent coordinates but does not make direct implementation changes. It can spawn background sub-agents via `subagent_spawn` and query live state via `subagent_status` when those tools are permitted. If delegation is unavailable because of launch-time restrictions, the contract remains active, profile metadata is withheld, and the primary reports the limitation rather than implementing directly. Off by default. When off, the permitted canonical subagent tools and profile manifest remain available for user-requested delegation or when an active skill workflow requires it; the primary otherwise works directly without the strict orchestrator contract. The tools accept named profiles, reasoning, per-spawn fast-mode overrides, timeout, turn limits, and shared/worktree isolation where applicable; lifecycle and result references are persisted. Completion is host-event-driven: `[auto-subagents update]` completion updates are the only signal; do not poll or inspect dashboards, metadata, event logs, or files solely to wait. See `/subagents` and [docs/subagents.md](docs/subagents.md) for details.
419		- Ponytail coding mode — include compact engineering guidance in each resolved system prompt; the guidance tells the model to apply it to coding, debugging, and review work rather than ordinary conversation. It favors understanding the real flow, small validated changes, reuse, and preserving safety checks. Enabled by default; changes apply to the next model call and persist as `ponytail_enabled` in `$ZUT_HOME/config.json`. It is included by interactive, print, stream, JSON, RPC, subagent, bot, SDK, and Zutfile agents.	419		- Ponytail coding mode — include compact engineering guidance in each resolved system prompt; the guidance tells the model to apply it to coding, debugging, and review work rather than ordinary conversation. It favors understanding the real flow, small validated changes, reuse, and preserving safety checks. Enabled by default; changes apply to the next model call and persist as `ponytail_enabled` in `$ZUT_HOME/config.json`. It is included by interactive, print, stream, JSON, RPC, subagent, bot, SDK, and Zutfile agents.
420		- fast mode — request the provider's fast tier where supported. It currently uses OpenAI's Fast service tier for OpenAI, OpenAI Responses, and OpenAI Codex models. Off by default; toggle it with `/fast` or `/settings`; changes apply on the next model call and persist as `fast_mode`. Other providers currently return an unsupported-provider error. Fast mode may cost more and depends on the selected model/account.	420		- fast mode — request the provider's fast tier where supported. It currently uses OpenAI's Fast service tier for OpenAI, OpenAI Responses, and OpenAI Codex models. Off by default; toggle it with `/fast` or `/settings`; changes apply on the next model call and persist as `fast_mode`. Other providers currently return an unsupported-provider error. Fast mode may cost more and depends on the selected model/account.
421		- lsp in main session — enable the built-in `lsp` tool and code diagnostics for the main agent. Enabled by default; changes persist as `lsp_enabled`.	421		- lsp in main session — enable the built-in `lsp` tool and code diagnostics for the main agent. Enabled by default; changes persist as `lsp_enabled`.

M docs/subagents.md +7 -6


@@ -70,9 +70,9 @@ Output follows the selected existing mode. Print writes only the final synthesis
70	70
71	71		When auto-subagents is enabled in `/settings`, the interactive primary agent runs in strict orchestrator mode. It must delegate all implementation, debugging/testing, and code-review work to an appropriately named profile, or to a clearly described general worker when no profile fits. The primary agent must not write or edit code, make direct implementation tool calls, inspect or review code, or apply worker patches. It may decompose requests, select and spawn workers, check status, coordinate follow-ups, and synthesize their results.
72	72
73		-	When auto-subagents is disabled, the canonical subagent tools remain available subject to launch-time policy. The primary may use them when the user requests delegation or an active skill workflow requires delegation. It continues to perform work itself otherwise and does not receive the profile manifest or strict orchestrator contract. The setting changes prompting, not tool availability.
	73	+	When auto-subagents is disabled, the canonical subagent tools remain available subject to launch-time policy. The primary may use them when the user requests delegation or an active skill workflow requires delegation. It continues to perform work itself otherwise and does not receive the strict orchestrator contract. The setting changes orchestration prompting, not tool or profile availability.
74	74
75		-	When `subagent_spawn` is available, the orchestrator receives a compact `[subagents_list]` section in its system prompt and should select the profile whose description best matches each worker task. If launch-time policy withholds `subagent_spawn`, strict orchestrator guidance remains active, profile metadata is omitted, and the primary must report that delegation is unavailable rather than implementing directly. If no profile fits when spawning is available, omit `agent` to use a general worker:
	75	+	When `subagent_spawn` is available, the primary agent receives a compact `[subagents_list]` section in its system prompt and should select the profile whose description best matches each worker task. If launch-time policy withholds `subagent_spawn`, strict orchestrator guidance remains active, profile metadata is omitted, and the primary must report that delegation is unavailable rather than implementing directly. If no profile fits when spawning is available, omit `agent` to use a general worker:
76	76
77	77		```json
78	78		{

@@ -99,17 +99,18 @@ This profile metadata is a tool-selection boundary, not a general network sandbo
99	99
100	100		Completion is host-event-driven. After spawning, never use `bash sleep`, `watch`, `tail -f`, polling loops, repeated `subagent_status`, or dashboard, metadata, event-log, or file checks solely to wait; those are not completion signals. The primary may work on unrelated independent tasks, but otherwise must end or yield its turn until the host injects `[auto-subagents update]`. Completion updates are the only completion signal. Legitimate waits inside user-requested commands, provider flows, extensions, or tests are not prohibited.
101	101
102		-	A per-spawn reasoning override is also accepted:
	102	+	Per-spawn reasoning and fast-mode overrides are also accepted:
103	103
104	104		```json
105	105		{
106	106		"task": "Implement the parser change and add regression tests.",
107	107		"agent": "implementer",
108		-	"reasoning": "high"
	108	+	"reasoning": "high",
	109	+	"fast_mode": true
109	110		}
110	111		```
111	112
112		-	`thinking` is accepted as an alias for `reasoning`. If neither is supplied, the child inherits the host reasoning level for an unnamed spawn, or the profile's `thinking` value for a named spawn.
	113	+	`thinking` is accepted as an alias for `reasoning`. If neither is supplied, the child inherits the host reasoning level for an unnamed spawn, or the profile's `thinking` value for a named spawn. An explicit `fast_mode` value takes precedence over the selected profile and host setting; omit it to inherit them.
113	114
114	115		The interactive command also supports the same selection explicitly:
115	116

@@ -118,7 +119,7 @@ The interactive command also supports the same selection explicitly:
118	119		/subagents new --agent implementer --reasoning high Implement the parser change
119	120		```
120	121
121		-	Shared mode preserves the historical host working directory, so workers there must be coordinated to avoid conflicting edits and to sequence dependent tasks. For parallel coding, pass `isolation:"worktree"` to `subagent_spawn`; zut creates a detached Git worktree and captures changed files and a patch without merging automatically. In orchestrator mode, assign any worktree patch integration to a worker rather than applying it in the primary session. Named profiles change the child's instructions and configuration; they are not a security sandbox. A profile's `systemPromptMode` controls its own body relative to the built-in identity; globally appended instructions, including enabled Ponytail coding guidance, remain present. Child credentials are transferred over stdin rather than argv or persisted metadata, and the active provider endpoint/TLS setting is inherited only when the child uses that provider. Fast mode is inherited by default. A profile with `fastMode: false` opts out, while `fastMode: true` enables fast mode even when the host setting is off; the `subagent_spawn` result warns the parent session when this override occurs. Child providers that do not yet support fast mode return an unsupported-provider error instead of silently ignoring an enabled setting.
	122	+	Shared mode preserves the historical host working directory, so workers there must be coordinated to avoid conflicting edits and to sequence dependent tasks. For parallel coding, pass `isolation:"worktree"` to `subagent_spawn`; zut creates a detached Git worktree and captures changed files and a patch without merging automatically. In orchestrator mode, assign any worktree patch integration to a worker rather than applying it in the primary session. Named profiles change the child's instructions and configuration; they are not a security sandbox. A profile's `systemPromptMode` controls its own body relative to the built-in identity; globally appended instructions, including enabled Ponytail coding guidance, remain present. Child credentials are transferred over stdin rather than argv or persisted metadata, and the active provider endpoint/TLS setting is inherited only when the child uses that provider. Fast mode is inherited by default. An explicit `fast_mode` spawn argument has highest precedence. Otherwise, a profile with `fastMode: false` opts out, while `fastMode: true` enables fast mode even when the host setting is off; the `subagent_spawn` result warns the parent session when this profile override occurs. Child providers that do not yet support fast mode return an unsupported-provider error instead of silently ignoring an enabled setting.
122	123
123	124		## Lifecycle, results, and recovery
124	125

 When **auto-subagents** is enabled in `/settings`, the interactive primary agent runs in strict orchestrator mode. It must delegate all implementation, debugging/testing, and code-review work to an appropriately named profile, or to a clearly described general worker when no profile fits. The primary agent must not write or edit code, make direct implementation tool calls, inspect or review code, or apply worker patches. It may decompose requests, select and spawn workers, check status, coordinate follow-ups, and synthesize their results.
-When auto-subagents is disabled, the canonical subagent tools remain available subject to launch-time policy. The primary may use them when the user requests delegation or an active skill workflow requires delegation. It continues to perform work itself otherwise and does not receive the profile manifest or strict orchestrator contract. The setting changes prompting, not tool availability.
+When auto-subagents is disabled, the canonical subagent tools remain available subject to launch-time policy. The primary may use them when the user requests delegation or an active skill workflow requires delegation. It continues to perform work itself otherwise and does not receive the strict orchestrator contract. The setting changes orchestration prompting, not tool or profile availability.
-When `subagent_spawn` is available, the orchestrator receives a compact `[subagents_list]` section in its system prompt and should select the profile whose description best matches each worker task. If launch-time policy withholds `subagent_spawn`, strict orchestrator guidance remains active, profile metadata is omitted, and the primary must report that delegation is unavailable rather than implementing directly. If no profile fits when spawning is available, omit `agent` to use a general worker:
+When `subagent_spawn` is available, the primary agent receives a compact `[subagents_list]` section in its system prompt and should select the profile whose description best matches each worker task. If launch-time policy withholds `subagent_spawn`, strict orchestrator guidance remains active, profile metadata is omitted, and the primary must report that delegation is unavailable rather than implementing directly. If no profile fits when spawning is available, omit `agent` to use a general worker:
 ```json
 {
 Completion is host-event-driven. After spawning, never use `bash sleep`, `watch`, `tail -f`, polling loops, repeated `subagent_status`, or dashboard, metadata, event-log, or file checks solely to wait; those are not completion signals. The primary may work on unrelated independent tasks, but otherwise must end or yield its turn until the host injects `[auto-subagents update]`. Completion updates are the only completion signal. Legitimate waits inside user-requested commands, provider flows, extensions, or tests are not prohibited.
-A per-spawn reasoning override is also accepted:
+Per-spawn reasoning and fast-mode overrides are also accepted:
 ```json
 {
   "task": "Implement the parser change and add regression tests.",
   "agent": "implementer",
-  "reasoning": "high"
+  "reasoning": "high",
+  "fast_mode": true
 }
 ```
-`thinking` is accepted as an alias for `reasoning`. If neither is supplied, the child inherits the host reasoning level for an unnamed spawn, or the profile's `thinking` value for a named spawn.
+`thinking` is accepted as an alias for `reasoning`. If neither is supplied, the child inherits the host reasoning level for an unnamed spawn, or the profile's `thinking` value for a named spawn. An explicit `fast_mode` value takes precedence over the selected profile and host setting; omit it to inherit them.
 The interactive command also supports the same selection explicitly:
 /subagents new --agent implementer --reasoning high Implement the parser change
 ```
-Shared mode preserves the historical host working directory, so workers there must be coordinated to avoid conflicting edits and to sequence dependent tasks. For parallel coding, pass `isolation:"worktree"` to `subagent_spawn`; zut creates a detached Git worktree and captures changed files and a patch without merging automatically. In orchestrator mode, assign any worktree patch integration to a worker rather than applying it in the primary session. Named profiles change the child's instructions and configuration; they are not a security sandbox. A profile's `systemPromptMode` controls its own body relative to the built-in identity; globally appended instructions, including enabled Ponytail coding guidance, remain present. Child credentials are transferred over stdin rather than argv or persisted metadata, and the active provider endpoint/TLS setting is inherited only when the child uses that provider. Fast mode is inherited by default. A profile with `fastMode: false` opts out, while `fastMode: true` enables fast mode even when the host setting is off; the `subagent_spawn` result warns the parent session when this override occurs. Child providers that do not yet support fast mode return an unsupported-provider error instead of silently ignoring an enabled setting.
+Shared mode preserves the historical host working directory, so workers there must be coordinated to avoid conflicting edits and to sequence dependent tasks. For parallel coding, pass `isolation:"worktree"` to `subagent_spawn`; zut creates a detached Git worktree and captures changed files and a patch without merging automatically. In orchestrator mode, assign any worktree patch integration to a worker rather than applying it in the primary session. Named profiles change the child's instructions and configuration; they are not a security sandbox. A profile's `systemPromptMode` controls its own body relative to the built-in identity; globally appended instructions, including enabled Ponytail coding guidance, remain present. Child credentials are transferred over stdin rather than argv or persisted metadata, and the active provider endpoint/TLS setting is inherited only when the child uses that provider. Fast mode is inherited by default. An explicit `fast_mode` spawn argument has highest precedence. Otherwise, a profile with `fastMode: false` opts out, while `fastMode: true` enables fast mode even when the host setting is off; the `subagent_spawn` result warns the parent session when this profile override occurs. Child providers that do not yet support fast mode return an unsupported-provider error instead of silently ignoring an enabled setting.
 ## Lifecycle, results, and recovery

M packages/agent/build.go +13 -19


@@ -859,36 +859,30 @@ func Resolve(args Args, requireCred bool) (Resolved, error) {
859	859		append_ = append(append_, skillAddendum)
860	860		}
861	861		interactiveMode := args.Mode == "" \|\| args.Mode == ModeInteractive
862		-	if selectedProfile == nil && args.Orchestrate {
863		-	// Headless orchestration owns its prompt contract rather than inheriting
864		-	// the interactive setting. Discover and append the compact manifest once;
865		-	// child profile bodies remain private to the selected child.
866		-	if autoSubagentsToolAllowed(args) {
867		-	homeDir, _ := os.UserHomeDir()
868		-	profiles, _ := subagents.Discover(args.CWD, homeDir)
869		-	if subagentsAddendum := subagents.SystemPromptAddendum(profiles); subagentsAddendum != "" {
870		-	append_ = append(append_, subagentsAddendum)
871		-	}
	862	+	primaryInteractive := selectedProfile == nil && interactiveMode
	863	+	primaryOrchestrator := selectedProfile == nil && args.Orchestrate
	864	+	if (primaryInteractive \|\| primaryOrchestrator) && autoSubagentsToolAllowed(args) {
	865	+	homeDir, _ := os.UserHomeDir()
	866	+	profiles, _ := subagents.Discover(args.CWD, homeDir)
	867	+	if subagentsAddendum := subagents.SystemPromptAddendum(profiles); subagentsAddendum != "" {
	868	+	append_ = append(append_, subagentsAddendum)
872	869		}
	870	+	}
	871	+	if primaryOrchestrator {
	872	+	// Headless orchestration owns its strict prompt contract rather than
	873	+	// inheriting the interactive setting.
873	874		append_ = append(append_, AutoSubagentsSystemAddendumFor(
874	875		autoSubagentsToolAllowed(args),
875	876		autoSubagentsStopToolAllowed(args),
876	877		autoSubagentsResumeToolAllowed(args),
877	878		))
878		-	} else if selectedProfile == nil && interactiveMode && cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {
879		-	if autoSubagentsToolAllowed(args) {
880		-	homeDir, _ := os.UserHomeDir()
881		-	profiles, _ := subagents.Discover(args.CWD, homeDir)
882		-	if subagentsAddendum := subagents.SystemPromptAddendum(profiles); subagentsAddendum != "" {
883		-	append_ = append(append_, subagentsAddendum)
884		-	}
885		-	}
	879	+	} else if primaryInteractive && cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {
886	880		append_ = append(append_, AutoSubagentsSystemAddendumFor(
887	881		autoSubagentsToolAllowed(args),
888	882		autoSubagentsStopToolAllowed(args),
889	883		autoSubagentsResumeToolAllowed(args),
890	884		))
891		-	} else if selectedProfile == nil && interactiveMode && autoSubagentsAnyToolAllowed(args) {
	885	+	} else if primaryInteractive && autoSubagentsAnyToolAllowed(args) {
892	886		append_ = append(append_, OnDemandSubagentsSystemAddendum)
893	887		}
894	888		if selectedProfile != nil && selectedProfile.SystemPromptMode != "replace" && selectedProfile.SystemPrompt != "" {

 		append_ = append(append_, skillAddendum)
 	}
 	interactiveMode := args.Mode == "" || args.Mode == ModeInteractive
-	if selectedProfile == nil && args.Orchestrate {
+	primaryInteractive := selectedProfile == nil && interactiveMode
-		// Headless orchestration owns its prompt contract rather than inheriting
+	primaryOrchestrator := selectedProfile == nil && args.Orchestrate
-		// the interactive setting. Discover and append the compact manifest once;
+	if (primaryInteractive || primaryOrchestrator) && autoSubagentsToolAllowed(args) {
-		// child profile bodies remain private to the selected child.
+		homeDir, _ := os.UserHomeDir()
-		if autoSubagentsToolAllowed(args) {
+		profiles, _ := subagents.Discover(args.CWD, homeDir)
-			homeDir, _ := os.UserHomeDir()
+		if subagentsAddendum := subagents.SystemPromptAddendum(profiles); subagentsAddendum != "" {
-			profiles, _ := subagents.Discover(args.CWD, homeDir)
+			append_ = append(append_, subagentsAddendum)
-			if subagentsAddendum := subagents.SystemPromptAddendum(profiles); subagentsAddendum != "" {
-				append_ = append(append_, subagentsAddendum)
-			}
 		}
+	}
+	if primaryOrchestrator {
+		// Headless orchestration owns its strict prompt contract rather than
+		// inheriting the interactive setting.
 		append_ = append(append_, AutoSubagentsSystemAddendumFor(
 			autoSubagentsToolAllowed(args),
 			autoSubagentsStopToolAllowed(args),
 			autoSubagentsResumeToolAllowed(args),
 		))
-	} else if selectedProfile == nil && interactiveMode && cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {
+	} else if primaryInteractive && cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {
-		if autoSubagentsToolAllowed(args) {
-			homeDir, _ := os.UserHomeDir()
-			profiles, _ := subagents.Discover(args.CWD, homeDir)
-			if subagentsAddendum := subagents.SystemPromptAddendum(profiles); subagentsAddendum != "" {
-				append_ = append(append_, subagentsAddendum)
-			}
-		}
 		append_ = append(append_, AutoSubagentsSystemAddendumFor(
 			autoSubagentsToolAllowed(args),
 			autoSubagentsStopToolAllowed(args),
 			autoSubagentsResumeToolAllowed(args),
 		))
-	} else if selectedProfile == nil && interactiveMode && autoSubagentsAnyToolAllowed(args) {
+	} else if primaryInteractive && autoSubagentsAnyToolAllowed(args) {
 		append_ = append(append_, OnDemandSubagentsSystemAddendum)
 	}
 	if selectedProfile != nil && selectedProfile.SystemPromptMode != "replace" && selectedProfile.SystemPrompt != "" {

M packages/agent/build_test.go +15 -3


@@ -514,20 +514,29 @@ func TestAutoSubagentsSystemAddendumRequiresHostCompletionUpdate(t *testing.T) {
514	514		}
515	515		}
516	516
517		-	func TestResolveOmitsAutoSubagentsOrchestratorContractWhenDisabled(t *testing.T) {
	517	+	func TestResolveKeepsNamedSubagentsListWithoutOrchestratorContractWhenDisabled(t *testing.T) {
518	518		root := t.TempDir()
519	519		home := filepath.Join(root, "home")
520	520		zutHome := filepath.Join(root, "zut-home")
521	521		project := filepath.Join(root, "repo")
	522	+	profilesDir := filepath.Join(home, ".agents", "agents")
	523	+	if err := os.MkdirAll(profilesDir, 0o755); err != nil {
	524	+	t.Fatal(err)
	525	+	}
522	526		if err := os.MkdirAll(project, 0o755); err != nil {
523	527		t.Fatal(err)
524	528		}
525	529		t.Setenv("HOME", home)
526	530		t.Setenv("ZUT_HOME", zutHome)
	531	+	t.Setenv("ZUT_AGENT_PROFILES", profilesDir)
527	532		disabled := false
528	533		if err := SaveConfig(Config{Provider: "openai", Model: "gpt-5", AutoSubagentsEnabled: &disabled}); err != nil {
529	534		t.Fatal(err)
530	535		}
	536	+	profile := "---\nname: reviewer\ndescription: Read-only code reviewer\n---\nReview without editing.\n"
	537	+	if err := os.WriteFile(filepath.Join(profilesDir, "reviewer.md"), []byte(profile), 0o600); err != nil {
	538	+	t.Fatal(err)
	539	+	}
531	540
532	541		r, err := Resolve(Args{CWD: project}, false)
533	542		if err != nil {

@@ -536,18 +545,21 @@ func TestResolveOmitsAutoSubagentsOrchestratorContractWhenDisabled(t *testing.T)
536	545		for _, unwanted := range []string{
537	546		AutoSubagentsSystemAddendum,
538	547		"primary-agent orchestrator",
539		-	"[subagents_list]",
540	548		} {
541	549		if strings.Contains(r.SystemPrompt, unwanted) {
542	550		t.Fatalf("disabled system prompt contains auto-subagents contract %q:\n%s", unwanted, r.SystemPrompt)
543	551		}
544	552		}
545	553		for _, required := range []string{
	554	+	"[subagents_list]",
	555	+	"reviewer",
	556	+	"Read-only code reviewer",
	557	+	"[/subagents_list]",
546	558		"user asks you to delegate",
547	559		"active skill workflow requires delegation",
548	560		} {
549	561		if !strings.Contains(r.SystemPrompt, required) {
550		-	t.Fatalf("disabled system prompt omits permitted delegation path %q:\n%s", required, r.SystemPrompt)
	562	+	t.Fatalf("disabled system prompt omits available delegation context %q:\n%s", required, r.SystemPrompt)
551	563		}
552	564		}
553	565		}

 	}
 }
-func TestResolveOmitsAutoSubagentsOrchestratorContractWhenDisabled(t *testing.T) {
+func TestResolveKeepsNamedSubagentsListWithoutOrchestratorContractWhenDisabled(t *testing.T) {
 	root := t.TempDir()
 	home := filepath.Join(root, "home")
 	zutHome := filepath.Join(root, "zut-home")
 	project := filepath.Join(root, "repo")
+	profilesDir := filepath.Join(home, ".agents", "agents")
+	if err := os.MkdirAll(profilesDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
 	if err := os.MkdirAll(project, 0o755); err != nil {
 		t.Fatal(err)
 	}
 	t.Setenv("HOME", home)
 	t.Setenv("ZUT_HOME", zutHome)
+	t.Setenv("ZUT_AGENT_PROFILES", profilesDir)
 	disabled := false
 	if err := SaveConfig(Config{Provider: "openai", Model: "gpt-5", AutoSubagentsEnabled: &disabled}); err != nil {
 		t.Fatal(err)
 	}
+	profile := "---\nname: reviewer\ndescription: Read-only code reviewer\n---\nReview without editing.\n"
+	if err := os.WriteFile(filepath.Join(profilesDir, "reviewer.md"), []byte(profile), 0o600); err != nil {
+		t.Fatal(err)
+	}
 	r, err := Resolve(Args{CWD: project}, false)
 	if err != nil {
 	for _, unwanted := range []string{
 		AutoSubagentsSystemAddendum,
 		"primary-agent orchestrator",
-		"[subagents_list]",
 	} {
 		if strings.Contains(r.SystemPrompt, unwanted) {
 			t.Fatalf("disabled system prompt contains auto-subagents contract %q:\n%s", unwanted, r.SystemPrompt)
 		}
 	}
 	for _, required := range []string{
+		"[subagents_list]",
+		"reviewer",
+		"Read-only code reviewer",
+		"[/subagents_list]",
 		"user asks you to delegate",
 		"active skill workflow requires delegation",
 	} {
 		if !strings.Contains(r.SystemPrompt, required) {
-			t.Fatalf("disabled system prompt omits permitted delegation path %q:\n%s", required, r.SystemPrompt)
+			t.Fatalf("disabled system prompt omits available delegation context %q:\n%s", required, r.SystemPrompt)
 		}
 	}
 }

M packages/agent/modes/auto_subagents_test.go +9 -5


@@ -15,7 +15,7 @@ import (
15	15
16	16		const autoSubagentsTestTimeout = 10 * time.Second
17	17
18		-	func TestAutoSubagentsSystemPromptTogglesProfileManifestWithDelegationGuidance(t *testing.T) {
	18	+	func TestAutoSubagentsSystemPromptKeepsProfileManifestWhileTogglingDelegationGuidance(t *testing.T) {
19	19		const onDemand = "delegate only on an explicit user request"
20	20		iv := &Interactive{
21	21		agent: &core.Agent{System: "base system"},

@@ -38,8 +38,11 @@ func TestAutoSubagentsSystemPromptTogglesProfileManifestWithDelegationGuidance(t
38	38		}
39	39
40	40		iv.applyAutoSubagentsSystemPrompt(false)
41		-	if strings.Contains(iv.agent.System, "[subagents_list]") \|\| strings.Contains(iv.agent.System, "auto-subagents guidance") {
42		-	t.Fatalf("disabled system prompt retained subagent blocks: %q", iv.agent.System)
	41	+	if !strings.Contains(iv.agent.System, "[subagents_list]") {
	42	+	t.Fatalf("disabled system prompt omitted profile manifest: %q", iv.agent.System)
	43	+	}
	44	+	if strings.Contains(iv.agent.System, "auto-subagents guidance") {
	45	+	t.Fatalf("disabled system prompt retained orchestrator guidance: %q", iv.agent.System)
43	46		}
44	47		if !strings.Contains(iv.agent.System, onDemand) {
45	48		t.Fatalf("disabled system prompt omitted on-demand delegation guidance: %q", iv.agent.System)

@@ -64,8 +67,9 @@ func TestAutoSubagentsTogglePreservesMatchingBasePromptBlocks(t *testing.T) {
64	67		t.Fatalf("enabling should append owned duplicate blocks: %q", iv.agent.System)
65	68		}
66	69		iv.applyAutoSubagentsSystemPrompt(false)
67		-	if got := strings.TrimSpace(iv.agent.System); got != base {
68		-	t.Fatalf("disabling changed matching base prompt: %q; want %q", got, base)
	70	+	want := base + "\n\n" + manifest
	71	+	if got := strings.TrimSpace(iv.agent.System); got != want {
	72	+	t.Fatalf("disabling changed matching base prompt blocks: %q; want %q", got, want)
69	73		}
70	74		}
71	75

 const autoSubagentsTestTimeout = 10 * time.Second
-func TestAutoSubagentsSystemPromptTogglesProfileManifestWithDelegationGuidance(t *testing.T) {
+func TestAutoSubagentsSystemPromptKeepsProfileManifestWhileTogglingDelegationGuidance(t *testing.T) {
 	const onDemand = "delegate only on an explicit user request"
 	iv := &Interactive{
 		agent: &core.Agent{System: "base system"},
 	}
 	iv.applyAutoSubagentsSystemPrompt(false)
-	if strings.Contains(iv.agent.System, "[subagents_list]") || strings.Contains(iv.agent.System, "auto-subagents guidance") {
+	if !strings.Contains(iv.agent.System, "[subagents_list]") {
-		t.Fatalf("disabled system prompt retained subagent blocks: %q", iv.agent.System)
+		t.Fatalf("disabled system prompt omitted profile manifest: %q", iv.agent.System)
+	}
+	if strings.Contains(iv.agent.System, "auto-subagents guidance") {
+		t.Fatalf("disabled system prompt retained orchestrator guidance: %q", iv.agent.System)
 	}
 	if !strings.Contains(iv.agent.System, onDemand) {
 		t.Fatalf("disabled system prompt omitted on-demand delegation guidance: %q", iv.agent.System)
 		t.Fatalf("enabling should append owned duplicate blocks: %q", iv.agent.System)
 	}
 	iv.applyAutoSubagentsSystemPrompt(false)
-	if got := strings.TrimSpace(iv.agent.System); got != base {
+	want := base + "\n\n" + manifest
-		t.Fatalf("disabling changed matching base prompt: %q; want %q", got, base)
+	if got := strings.TrimSpace(iv.agent.System); got != want {
+		t.Fatalf("disabling changed matching base prompt blocks: %q; want %q", got, want)
 	}
 }

M packages/agent/modes/interactive.go +17 -16


@@ -189,7 +189,7 @@ type InteractiveConfig struct {
189	189		OnDemandSubagentsSystemAddendum string
190	190
191	191		// SubagentsSystemAddendum is the metadata-only [subagents_list]
192		-	// block that is added or removed together with auto-subagents.
	192	+	// block available whenever the primary agent can spawn subagents.
193	193		SubagentsSystemAddendum string
194	194		SettingsStore SettingsStore
195	195

@@ -8853,25 +8853,26 @@ func (i *Interactive) deliverCompletionUpdates() {
8853	8853		}
8854	8854		}
8855	8855
8856		-	// autoSubagentsAddenda returns the prompt blocks owned by the auto-subagents
8857		-	// setting, in the same order Resolve appends them to a new agent.
	8856	+	// autoSubagentsAddenda returns the prompt blocks owned by subagent prompting,
	8857	+	// in the same order Resolve appends them to a new agent. The profile manifest
	8858	+	// is independent of strict orchestration and remains available in on-demand
	8859	+	// mode whenever the primary agent can spawn a worker.
8858	8860		func autoSubagentsAddenda(cfg InteractiveConfig, orchestrating bool) []string {
8859		-	if !orchestrating {
8860		-	if cfg.Supervisor == nil \|\| !autoSubagentsAnyToolAllowedConfig(cfg) {
8861		-	return nil
8862		-	}
8863		-	if addendum := strings.TrimSpace(cfg.OnDemandSubagentsSystemAddendum); addendum != "" {
8864		-	return []string{addendum}
8865		-	}
8866		-	return nil
8867		-	}
8868		-
8869	8861		addenda := make([]string, 0, 2)
8870	8862		if cfg.Supervisor != nil && autoSubagentsToolAllowedConfig(cfg) {
8871	8863		if addendum := strings.TrimSpace(cfg.SubagentsSystemAddendum); addendum != "" {
8872	8864		addenda = append(addenda, addendum)
8873	8865		}
8874	8866		}
	8867	+	if !orchestrating {
	8868	+	if cfg.Supervisor != nil && autoSubagentsAnyToolAllowedConfig(cfg) {
	8869	+	if addendum := strings.TrimSpace(cfg.OnDemandSubagentsSystemAddendum); addendum != "" {
	8870	+	addenda = append(addenda, addendum)
	8871	+	}
	8872	+	}
	8873	+	return addenda
	8874	+	}
	8875	+
8875	8876		if addendum := strings.TrimSpace(cfg.AutoSubagentsSystemAddendum); addendum != "" {
8876	8877		addenda = append(addenda, addendum)
8877	8878		}

@@ -8889,9 +8890,9 @@ func removeLastAutoSubagentsAddendum(system, addendum string) (string, bool) {
8889	8890		return system[:idx] + system[idx+len(addendum):], true
8890	8891		}
8891	8892
8892		-	// applyAutoSubagentsSystemPrompt swaps the prompt blocks owned by the
8893		-	// auto-subagents setting on the running agent. The profile manifest belongs
8894		-	// only to strict orchestration; disabled mode keeps on-demand guidance.
	8893	+	// applyAutoSubagentsSystemPrompt swaps the prompt blocks owned by subagent
	8894	+	// prompting on the running agent. Toggling strict orchestration changes the
	8895	+	// delegation guidance while retaining the profile manifest when usable.
8895	8896		func (i *Interactive) applyAutoSubagentsSystemPrompt(orchestrating bool) {
8896	8897		// i.mu is sufficient here: this path updates the existing agent's system
8897	8898		// prompt and managed addenda in place; it does not replace the agent or

 	OnDemandSubagentsSystemAddendum string
 	// SubagentsSystemAddendum is the metadata-only [subagents_list]
-	// block that is added or removed together with auto-subagents.
+	// block available whenever the primary agent can spawn subagents.
 	SubagentsSystemAddendum string
 	SettingsStore           SettingsStore
 	}
 }
-// autoSubagentsAddenda returns the prompt blocks owned by the auto-subagents
+// autoSubagentsAddenda returns the prompt blocks owned by subagent prompting,
-// setting, in the same order Resolve appends them to a new agent.
+// in the same order Resolve appends them to a new agent. The profile manifest
+// is independent of strict orchestration and remains available in on-demand
+// mode whenever the primary agent can spawn a worker.
 func autoSubagentsAddenda(cfg InteractiveConfig, orchestrating bool) []string {
-	if !orchestrating {
-		if cfg.Supervisor == nil || !autoSubagentsAnyToolAllowedConfig(cfg) {
-			return nil
-		}
-		if addendum := strings.TrimSpace(cfg.OnDemandSubagentsSystemAddendum); addendum != "" {
-			return []string{addendum}
-		}
-		return nil
-	}
 	addenda := make([]string, 0, 2)
 	if cfg.Supervisor != nil && autoSubagentsToolAllowedConfig(cfg) {
 		if addendum := strings.TrimSpace(cfg.SubagentsSystemAddendum); addendum != "" {
 			addenda = append(addenda, addendum)
 		}
 	}
+	if !orchestrating {
+		if cfg.Supervisor != nil && autoSubagentsAnyToolAllowedConfig(cfg) {
+			if addendum := strings.TrimSpace(cfg.OnDemandSubagentsSystemAddendum); addendum != "" {
+				addenda = append(addenda, addendum)
+			}
+		}
+		return addenda
+	}
 	if addendum := strings.TrimSpace(cfg.AutoSubagentsSystemAddendum); addendum != "" {
 		addenda = append(addenda, addendum)
 	}
 	return system[:idx] + system[idx+len(addendum):], true
 }
-// applyAutoSubagentsSystemPrompt swaps the prompt blocks owned by the
+// applyAutoSubagentsSystemPrompt swaps the prompt blocks owned by subagent
-// auto-subagents setting on the running agent. The profile manifest belongs
+// prompting on the running agent. Toggling strict orchestration changes the
-// only to strict orchestration; disabled mode keeps on-demand guidance.
+// delegation guidance while retaining the profile manifest when usable.
 func (i *Interactive) applyAutoSubagentsSystemPrompt(orchestrating bool) {
 	// i.mu is sufficient here: this path updates the existing agent's system
 	// prompt and managed addenda in place; it does not replace the agent or

M packages/agent/subagents/persist.go +13 -5


@@ -1080,6 +1080,7 @@ func (f *Supervisor) resumeWithHook(ctx context.Context, id string, resuming boo
1080	1080		currentRunTurns := existing.CurrentRunTurnsValue()
1081	1081		pendingResume := existing.resumePromptState()
1082	1082		pendingResumePrompt, pendingResumePromptAt, pendingResumePromptID := pendingResume.Prompt, pendingResume.AcceptedAt, pendingResume.CommandID
	1083	+	hadPendingResumePrompt := pendingResumePrompt != ""
1083	1084		pendingResumeQueue := existing.resumePromptQueueSnapshot()
1084	1085		if pendingResumePrompt != "" && pendingResumePromptID == "" {
1085	1086		pendingResumePromptID = uuid.NewString()

@@ -1287,11 +1288,18 @@ func (f *Supervisor) resumeWithHook(ctx context.Context, id string, resuming boo
1287	1288		// Refreshing metadata happened before queue admission, so a later
1288	1289		// supervisor can reconstruct this resumed attempt even if the runner
1289	1290		// has not reached its first event yet. Register the turn before the
1290		-	// scheduler can start the worker and emit a fast turn_end.
1291		-	if before != nil && resumePrompt != "" {
1292		-	// No rejecting operation remains before scheduling, so there is no path
1293		-	// that needs the hook's rollback after this point.
1294		-	_ = before(a, resumePrompt)
	1291	+	// scheduler can start the worker and emit a fast turn_end. A durable pending
	1292	+	// prompt is consumed before the newly requested prompt, so tracker
	1293	+	// registrations must preserve that scheduler order.
	1294	+	if before != nil {
	1295	+	if hadPendingResumePrompt {
	1296	+	_ = before(a, pendingResumePrompt)
	1297	+	}
	1298	+	if resumePrompt != "" {
	1299	+	// No rejecting operation remains before scheduling, so there is no path
	1300	+	// that needs the hook's rollback after this point.
	1301	+	_ = before(a, resumePrompt)
	1302	+	}
1295	1303		}
1296	1304		f.armQueueTimeout(a)
1297	1305		f.schedule()

 	currentRunTurns := existing.CurrentRunTurnsValue()
 	pendingResume := existing.resumePromptState()
 	pendingResumePrompt, pendingResumePromptAt, pendingResumePromptID := pendingResume.Prompt, pendingResume.AcceptedAt, pendingResume.CommandID
+	hadPendingResumePrompt := pendingResumePrompt != ""
 	pendingResumeQueue := existing.resumePromptQueueSnapshot()
 	if pendingResumePrompt != "" && pendingResumePromptID == "" {
 		pendingResumePromptID = uuid.NewString()
 	// Refreshing metadata happened before queue admission, so a later
 	// supervisor can reconstruct this resumed attempt even if the runner
 	// has not reached its first event yet. Register the turn before the
-	// scheduler can start the worker and emit a fast turn_end.
+	// scheduler can start the worker and emit a fast turn_end. A durable pending
-	if before != nil && resumePrompt != "" {
+	// prompt is consumed before the newly requested prompt, so tracker
-		// No rejecting operation remains before scheduling, so there is no path
+	// registrations must preserve that scheduler order.
-		// that needs the hook's rollback after this point.
+	if before != nil {
-		_ = before(a, resumePrompt)
+		if hadPendingResumePrompt {
+			_ = before(a, pendingResumePrompt)
+		}
+		if resumePrompt != "" {
+			// No rejecting operation remains before scheduling, so there is no path
+			// that needs the hook's rollback after this point.
+			_ = before(a, resumePrompt)
+		}
 	}
 	f.armQueueTimeout(a)
 	f.schedule()

M packages/agent/subagents/resume_prompt_test.go +74 -0


@@ -158,6 +158,80 @@ func TestResumeWithPromptQueuesFollowUpsForActiveWorker(t *testing.T) {
158	158		a.Wait()
159	159		}
160	160
	161	+	func TestResumeWithPromptRestartTracksExistingPendingPromptBeforeNewPrompt(t *testing.T) {
	162	+	root := t.TempDir()
	163	+	started := make(chan *Agent, 2)
	164	+	f := New(Config{
	165	+	Root: root, RepoRoot: root,
	166	+	NewRunner: func(a *Agent) Runner {
	167	+	return RunnerFunc(func(ctx context.Context, _ Sink) error {
	168	+	started <- a
	169	+	<-ctx.Done()
	170	+	return ctx.Err()
	171	+	})
	172	+	},
	173	+	})
	174	+	t.Cleanup(f.StopAll)
	175	+
	176	+	original, err := f.Spawn(context.Background(), "review the implementation")
	177	+	if err != nil {
	178	+	t.Fatal(err)
	179	+	}
	180	+	select {
	181	+	case <-started:
	182	+	case <-time.After(time.Second):
	183	+	t.Fatal("original runner did not start")
	184	+	}
	185	+	if err := f.Stop(original.ID); err != nil {
	186	+	t.Fatal(err)
	187	+	}
	188	+	original.Wait()
	189	+
	190	+	const (
	191	+	pendingPrompt = "finish the queued review"
	192	+	newPrompt = "then review the follow-up"
	193	+	)
	194	+	original.setResumePrompt(pendingPrompt, time.Now())
	195	+	if err := f.persistAgent(original); err != nil {
	196	+	t.Fatal(err)
	197	+	}
	198	+
	199	+	tracker := NewCompletionTracker()
	200	+	resumed, err := f.ResumeWithPromptBefore(context.Background(), original.ID, newPrompt, func(agent *Agent, prompt string) func() {
	201	+	return tracker.TrackFutureTurn(agent, prompt, true)
	202	+	})
	203	+	if err != nil {
	204	+	t.Fatal(err)
	205	+	}
	206	+	select {
	207	+	case got := <-started:
	208	+	if got != resumed {
	209	+	t.Fatalf("started agent = %p, want resumed agent %p", got, resumed)
	210	+	}
	211	+	case <-time.After(time.Second):
	212	+	t.Fatal("resumed runner did not start")
	213	+	}
	214	+	if got := resumed.resumePrompt(); got != pendingPrompt {
	215	+	t.Fatalf("first scheduled prompt = %q, want pending prompt %q", got, pendingPrompt)
	216	+	}
	217	+	queue := resumed.resumePromptQueueSnapshot()
	218	+	if len(queue) != 1 \|\| queue[0].Prompt != newPrompt {
	219	+	t.Fatalf("resume queue = %+v, want new prompt queued second", queue)
	220	+	}
	221	+	if resumed.OnTurnEnd == nil {
	222	+	t.Fatal("restart did not install completion tracking before scheduling")
	223	+	}
	224	+	resumed.OnTurnEnd(1, "")
	225	+	resumed.OnTurnEnd(2, "")
	226	+	batch, err := tracker.WaitIdle(context.Background())
	227	+	if err != nil {
	228	+	t.Fatal(err)
	229	+	}
	230	+	if len(batch) != 2 \|\| batch[0].Task != pendingPrompt \|\| batch[1].Task != newPrompt {
	231	+	t.Fatalf("completion order = %+v, want pending prompt then new prompt", batch)
	232	+	}
	233	+	}
	234	+
161	235		func TestResumeWithPromptDeliversFollowUpToIdleWorker(t *testing.T) {
162	236		if runtime.GOOS == "windows" {
163	237		t.Skip("subagent inbox transport uses Unix-domain sockets")


@@ -158,6 +158,80 @@ func TestResumeWithPromptQueuesFollowUpsForActiveWorker(t *testing.T) {
158	a.Wait()	158		a.Wait()
159	}	159		}
160		160
		161	+	func TestResumeWithPromptRestartTracksExistingPendingPromptBeforeNewPrompt(t *testing.T) {
		162	+	root := t.TempDir()
		163	+	started := make(chan *Agent, 2)
		164	+	f := New(Config{
		165	+	Root: root, RepoRoot: root,
		166	+	NewRunner: func(a *Agent) Runner {
		167	+	return RunnerFunc(func(ctx context.Context, _ Sink) error {
		168	+	started <- a
		169	+	<-ctx.Done()
		170	+	return ctx.Err()
		171	+	})
		172	+	},
		173	+	})
		174	+	t.Cleanup(f.StopAll)
		175	+
		176	+	original, err := f.Spawn(context.Background(), "review the implementation")
		177	+	if err != nil {
		178	+	t.Fatal(err)
		179	+	}
		180	+	select {
		181	+	case <-started:
		182	+	case <-time.After(time.Second):
		183	+	t.Fatal("original runner did not start")
		184	+	}
		185	+	if err := f.Stop(original.ID); err != nil {
		186	+	t.Fatal(err)
		187	+	}
		188	+	original.Wait()
		189	+
		190	+	const (
		191	+	pendingPrompt = "finish the queued review"
		192	+	newPrompt = "then review the follow-up"
		193	+	)
		194	+	original.setResumePrompt(pendingPrompt, time.Now())
		195	+	if err := f.persistAgent(original); err != nil {
		196	+	t.Fatal(err)
		197	+	}
		198	+
		199	+	tracker := NewCompletionTracker()
		200	+	resumed, err := f.ResumeWithPromptBefore(context.Background(), original.ID, newPrompt, func(agent *Agent, prompt string) func() {
		201	+	return tracker.TrackFutureTurn(agent, prompt, true)
		202	+	})
		203	+	if err != nil {
		204	+	t.Fatal(err)
		205	+	}
		206	+	select {
		207	+	case got := <-started:
		208	+	if got != resumed {
		209	+	t.Fatalf("started agent = %p, want resumed agent %p", got, resumed)
		210	+	}
		211	+	case <-time.After(time.Second):
		212	+	t.Fatal("resumed runner did not start")
		213	+	}
		214	+	if got := resumed.resumePrompt(); got != pendingPrompt {
		215	+	t.Fatalf("first scheduled prompt = %q, want pending prompt %q", got, pendingPrompt)
		216	+	}
		217	+	queue := resumed.resumePromptQueueSnapshot()
		218	+	if len(queue) != 1 \|\| queue[0].Prompt != newPrompt {
		219	+	t.Fatalf("resume queue = %+v, want new prompt queued second", queue)
		220	+	}
		221	+	if resumed.OnTurnEnd == nil {
		222	+	t.Fatal("restart did not install completion tracking before scheduling")
		223	+	}
		224	+	resumed.OnTurnEnd(1, "")
		225	+	resumed.OnTurnEnd(2, "")
		226	+	batch, err := tracker.WaitIdle(context.Background())
		227	+	if err != nil {
		228	+	t.Fatal(err)
		229	+	}
		230	+	if len(batch) != 2 \|\| batch[0].Task != pendingPrompt \|\| batch[1].Task != newPrompt {
		231	+	t.Fatalf("completion order = %+v, want pending prompt then new prompt", batch)
		232	+	}
		233	+	}
		234	+
161	func TestResumeWithPromptDeliversFollowUpToIdleWorker(t *testing.T) {	235		func TestResumeWithPromptDeliversFollowUpToIdleWorker(t *testing.T) {
162	if runtime.GOOS == "windows" {	236		if runtime.GOOS == "windows" {
163	t.Skip("subagent inbox transport uses Unix-domain sockets")	237		t.Skip("subagent inbox transport uses Unix-domain sockets")

M packages/agent/subagents/supervisor_test.go +3 -0


@@ -234,6 +234,9 @@ func TestStopByRootSessionLeavesOtherSessionsRunning(t *testing.T) {
234	234		}
235	235
236	236		func TestSupervisorShutdownCommandsIdentifyOrigin(t *testing.T) {
	237	+	if runtime.GOOS == "windows" {
	238	+	t.Skip("subagent inbox transport uses Unix-domain sockets")
	239	+	}
237	240		for _, tc := range []struct {
238	241		name string
239	242		origin ShutdownOrigin


@@ -234,6 +234,9 @@ func TestStopByRootSessionLeavesOtherSessionsRunning(t *testing.T) {
234	}	234		}
235		235
236	func TestSupervisorShutdownCommandsIdentifyOrigin(t *testing.T) {	236		func TestSupervisorShutdownCommandsIdentifyOrigin(t *testing.T) {
		237	+	if runtime.GOOS == "windows" {
		238	+	t.Skip("subagent inbox transport uses Unix-domain sockets")
		239	+	}
237	for _, tc := range []struct {	240		for _, tc := range []struct {
238	name string	241		name string
239	origin ShutdownOrigin	242		origin ShutdownOrigin

M packages/agent/tools/subagent_spawn.go +12 -1


@@ -56,6 +56,7 @@ type subagentSpawnArgs struct {
56	56		Provider string `json:"provider,omitempty"`
57	57		Reasoning string `json:"reasoning,omitempty"`
58	58		Thinking string `json:"thinking,omitempty"`
	59	+	FastMode *bool `json:"fast_mode,omitempty"`
59	60		Isolation string `json:"isolation,omitempty"`
60	61		Timeout string `json:"timeout,omitempty"`
61	62		MaxTurns *int `json:"max_turns,omitempty"`

@@ -90,6 +91,10 @@ const subagentSpawnSchemaTemplate = `{
90	91		"enum": ["off", "minimum", "low", "medium", "high", "xhigh", "max"],
91	92		"description": "Alias for reasoning, accepted for compatibility with common agent profile terminology. Prefer reasoning when both are available."
92	93		},
	94	+	"fast_mode": {
	95	+	"type": "boolean",
	96	+	"description": "Optional fast-mode override for the child. Omit to inherit the selected profile or host setting."
	97	+	},
93	98		"isolation": {
94	99		"type": "string",
95	100		"enum": ["shared", "worktree"],

@@ -167,6 +172,7 @@ func (t *SubagentSpawnTool) Execute(ctx context.Context, raw json.RawMessage, pr
167	172		agentName := strings.TrimSpace(a.Agent)
168	173		var profile *subagents.Profile
169	174		var fastModeOverride *bool
	175	+	fastModeFromProfile := false
170	176		if agentName != "" {
171	177		if t.ResolveSubagent == nil {
172	178		return protocolToolError(prefix + ": named subagent profiles are unavailable")

@@ -181,6 +187,11 @@ func (t *SubagentSpawnTool) Execute(ctx context.Context, raw json.RawMessage, pr
181	187		}
182	188		agentName = profile.Name
183	189		fastModeOverride = profile.FastMode
	190	+	fastModeFromProfile = profile.FastMode != nil
	191	+	}
	192	+	if a.FastMode != nil {
	193	+	fastModeOverride = a.FastMode
	194	+	fastModeFromProfile = false
184	195		}
185	196
186	197		model := strings.TrimSpace(a.Model)

@@ -271,7 +282,7 @@ func (t *SubagentSpawnTool) Execute(ctx context.Context, raw json.RawMessage, pr
271	282		if agent.FastMode {
272	283		sb.WriteString("fast mode: enabled\n")
273	284		}
274		-	if fastModeOverride != nil && *fastModeOverride && agent.FastModeOverridesHost() {
	285	+	if fastModeFromProfile && fastModeOverride != nil && *fastModeOverride && agent.FastModeOverridesHost() {
275	286		sb.WriteString("warning: subagent profile has fast mode enabled, overriding global fast mode off\n")
276	287		}
277	288		sb.WriteString("\nThe sub-agent is running in the background. Completion is host-event-driven: wait for the injected [auto-subagents update], the only completion signal. ")

 	Provider  string `json:"provider,omitempty"`
 	Reasoning string `json:"reasoning,omitempty"`
 	Thinking  string `json:"thinking,omitempty"`
+	FastMode  *bool  `json:"fast_mode,omitempty"`
 	Isolation string `json:"isolation,omitempty"`
 	Timeout   string `json:"timeout,omitempty"`
 	MaxTurns  *int   `json:"max_turns,omitempty"`
       "enum": ["off", "minimum", "low", "medium", "high", "xhigh", "max"],
       "description": "Alias for reasoning, accepted for compatibility with common agent profile terminology. Prefer reasoning when both are available."
     },
+    "fast_mode": {
+      "type": "boolean",
+      "description": "Optional fast-mode override for the child. Omit to inherit the selected profile or host setting."
+    },
     "isolation": {
       "type": "string",
       "enum": ["shared", "worktree"],
 	agentName := strings.TrimSpace(a.Agent)
 	var profile *subagents.Profile
 	var fastModeOverride *bool
+	fastModeFromProfile := false
 	if agentName != "" {
 		if t.ResolveSubagent == nil {
 			return protocolToolError(prefix + ": named subagent profiles are unavailable")
 		}
 		agentName = profile.Name
 		fastModeOverride = profile.FastMode
+		fastModeFromProfile = profile.FastMode != nil
+	}
+	if a.FastMode != nil {
+		fastModeOverride = a.FastMode
+		fastModeFromProfile = false
 	}
 	model := strings.TrimSpace(a.Model)
 	if agent.FastMode {
 		sb.WriteString("fast mode: enabled\n")
 	}
-	if fastModeOverride != nil && *fastModeOverride && agent.FastModeOverridesHost() {
+	if fastModeFromProfile && fastModeOverride != nil && *fastModeOverride && agent.FastModeOverridesHost() {
 		sb.WriteString("warning: subagent profile has fast mode enabled, overriding global fast mode off\n")
 	}
 	sb.WriteString("\nThe sub-agent is running in the background. Completion is host-event-driven: wait for the injected [auto-subagents update], the only completion signal. ")

M packages/agent/tools/subagent_spawn_test.go +58 -0


@@ -3,6 +3,7 @@ package tools
3	3		import (
4	4		"context"
5	5		"encoding/json"
	6	+	"fmt"
6	7		"path/filepath"
7	8		"strings"
8	9		"testing"

@@ -349,6 +350,63 @@ func TestSubagentSpawnAppliesProfileFastModeRestriction(t *testing.T) {
349	350		}
350	351		}
351	352
	353	+	func TestSubagentSpawnSchemaAdvertisesFastModeOverride(t *testing.T) {
	354	+	var schema struct {
	355	+	Properties map[string]struct {
	356	+	Type string `json:"type"`
	357	+	Description string `json:"description"`
	358	+	} `json:"properties"`
	359	+	}
	360	+	if err := json.Unmarshal((&SubagentSpawnTool{}).Schema(), &schema); err != nil {
	361	+	t.Fatal(err)
	362	+	}
	363	+	fastMode, ok := schema.Properties["fast_mode"]
	364	+	if !ok {
	365	+	t.Fatal("subagent_spawn schema does not advertise fast_mode")
	366	+	}
	367	+	if fastMode.Type != "boolean" {
	368	+	t.Fatalf("fast_mode type = %q, want boolean", fastMode.Type)
	369	+	}
	370	+	if !strings.Contains(strings.ToLower(fastMode.Description), "inherit") {
	371	+	t.Fatalf("fast_mode description = %q, want inheritance guidance", fastMode.Description)
	372	+	}
	373	+	}
	374	+
	375	+	func TestSubagentSpawnExplicitFastModeOverridesProfile(t *testing.T) {
	376	+	for _, tc := range []struct {
	377	+	name string
	378	+	profileFast bool
	379	+	spawnFast bool
	380	+	}{
	381	+	{name: "enable", profileFast: false, spawnFast: true},
	382	+	{name: "disable", profileFast: true, spawnFast: false},
	383	+	} {
	384	+	t.Run(tc.name, func(t *testing.T) {
	385	+	profileFast := tc.profileFast
	386	+	tool := &SubagentSpawnTool{
	387	+	Supervisor: newTestSupervisor(t),
	388	+	Enabled: func() bool { return true },
	389	+	ResolveSubagent: func(name string) (*subagents.Profile, error) {
	390	+	return &subagents.Profile{Name: name, FastMode: &profileFast}, nil
	391	+	},
	392	+	}
	393	+
	394	+	raw := fmt.Sprintf(`{"task":"review auth","agent":"worker","fast_mode":%t}`, tc.spawnFast)
	395	+	res, err := tool.Execute(context.Background(), json.RawMessage(raw), nil)
	396	+	if err != nil {
	397	+	t.Fatal(err)
	398	+	}
	399	+	if res.IsError {
	400	+	t.Fatalf("unexpected tool error: %s", textResult(res.Content))
	401	+	}
	402	+	agents := tool.Supervisor.List()
	403	+	if len(agents) != 1 \|\| agents[0].FastMode != tc.spawnFast {
	404	+	t.Fatalf("agent fast mode = %#v, want %t", agents, tc.spawnFast)
	405	+	}
	406	+	})
	407	+	}
	408	+	}
	409	+
352	410		func TestSubagentSpawnProfileFastModeOverridesGlobalOffWithWarning(t *testing.T) {
353	411		root := t.TempDir()
354	412		profileFastMode := true


@@ -3,6 +3,7 @@ package tools
3	import (	3		import (
4	"context"	4		"context"
5	"encoding/json"	5		"encoding/json"
		6	+	"fmt"
6	"path/filepath"	7		"path/filepath"
7	"strings"	8		"strings"
8	"testing"	9		"testing"

@@ -349,6 +350,63 @@ func TestSubagentSpawnAppliesProfileFastModeRestriction(t *testing.T) {
349	}	350		}
350	}	351		}
351		352
		353	+	func TestSubagentSpawnSchemaAdvertisesFastModeOverride(t *testing.T) {
		354	+	var schema struct {
		355	+	Properties map[string]struct {
		356	+	Type string `json:"type"`
		357	+	Description string `json:"description"`
		358	+	} `json:"properties"`
		359	+	}
		360	+	if err := json.Unmarshal((&SubagentSpawnTool{}).Schema(), &schema); err != nil {
		361	+	t.Fatal(err)
		362	+	}
		363	+	fastMode, ok := schema.Properties["fast_mode"]
		364	+	if !ok {
		365	+	t.Fatal("subagent_spawn schema does not advertise fast_mode")
		366	+	}
		367	+	if fastMode.Type != "boolean" {
		368	+	t.Fatalf("fast_mode type = %q, want boolean", fastMode.Type)
		369	+	}
		370	+	if !strings.Contains(strings.ToLower(fastMode.Description), "inherit") {
		371	+	t.Fatalf("fast_mode description = %q, want inheritance guidance", fastMode.Description)
		372	+	}
		373	+	}
		374	+
		375	+	func TestSubagentSpawnExplicitFastModeOverridesProfile(t *testing.T) {
		376	+	for _, tc := range []struct {
		377	+	name string
		378	+	profileFast bool
		379	+	spawnFast bool
		380	+	}{
		381	+	{name: "enable", profileFast: false, spawnFast: true},
		382	+	{name: "disable", profileFast: true, spawnFast: false},
		383	+	} {
		384	+	t.Run(tc.name, func(t *testing.T) {
		385	+	profileFast := tc.profileFast
		386	+	tool := &SubagentSpawnTool{
		387	+	Supervisor: newTestSupervisor(t),
		388	+	Enabled: func() bool { return true },
		389	+	ResolveSubagent: func(name string) (*subagents.Profile, error) {
		390	+	return &subagents.Profile{Name: name, FastMode: &profileFast}, nil
		391	+	},
		392	+	}
		393	+
		394	+	raw := fmt.Sprintf(`{"task":"review auth","agent":"worker","fast_mode":%t}`, tc.spawnFast)
		395	+	res, err := tool.Execute(context.Background(), json.RawMessage(raw), nil)
		396	+	if err != nil {
		397	+	t.Fatal(err)
		398	+	}
		399	+	if res.IsError {
		400	+	t.Fatalf("unexpected tool error: %s", textResult(res.Content))
		401	+	}
		402	+	agents := tool.Supervisor.List()
		403	+	if len(agents) != 1 \|\| agents[0].FastMode != tc.spawnFast {
		404	+	t.Fatalf("agent fast mode = %#v, want %t", agents, tc.spawnFast)
		405	+	}
		406	+	})
		407	+	}
		408	+	}
		409	+
352	func TestSubagentSpawnProfileFastModeOverridesGlobalOffWithWarning(t *testing.T) {	410		func TestSubagentSpawnProfileFastModeOverridesGlobalOffWithWarning(t *testing.T) {
353	root := t.TempDir()	411		root := t.TempDir()
354	profileFastMode := true	412		profileFastMode := true