Merge remote-tracking branch 'origin/main' into feat/web-page-exploration

# Conflicts:
#	packages/agent/build.go

commit: 8dff8a1dbea74a9625c07916a53a2c86ad49d1fa
author: brice · 2mo ago · 2026-08-19 05:59 UTC
merge of: 1315561 + cd9706d · diff against the first parent
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

4 files · +97 -14

M README.md +2 -2


@@ -425,7 +425,7 @@ The fair global scheduler defaults to six concurrent turns, one active turn per
425	425
426	426		Worktree isolation captures a patch and changed-file list without applying it. Shared children use the host checkout. The available logical references are `subagent://<id>`, `subagent://<id>/history`, `subagent://<id>/result`, and `subagent://<id>/patch`.
427	427
428		-	Subagent Orchestrator. With `/settings` → Subagent Orchestrator on (or `/orchestrator`), the primary delegates implementation, debugging/testing, and code review to named profiles or explicitly described general children. It coordinates and synthesizes completion updates rather than doing direct implementation. The canonical resident tools remain available for user-requested delegation when the setting is off, subject to launch-time permissions. Do not poll `subagent_status` or journal files solely to wait for completion.
	428	+	Subagent Orchestrator. With `/settings` → Subagent Orchestrator on (or `/orchestrator`), the primary delegates implementation, debugging/testing, and code review to named profiles or explicitly described general children. It may use `read` and `grep` for codebase exploration and `web_search` for public-web research before dispatching work, but does not implement directly. These research tools remain available after a requested tool allowlist is applied unless tools are disabled with `--no-tools`. The canonical resident tools remain available for user-requested delegation when the setting is off, subject to launch-time permissions. Do not poll `subagent_status` or journal files solely to wait for completion.
429	429
430	430		### Named subagent profiles
431	431

@@ -439,7 +439,7 @@ Opens a dialog with every persistent setting. `up`/`down` to navigate, `enter` o
439	439		- 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.
440	440		- 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.
441	441		- 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`.
442		-	- Subagent Orchestrator — 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 optional or required 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, and shared/worktree isolation where applicable; lifecycle and result references are persisted. Completion is host-event-driven through `[auto-subagents update]` for every worker; required work stays asynchronous, persists its outcome, and prevents only the terminal parent response until satisfied or explicitly waived by user removal. 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.
	442	+	- Subagent Orchestrator — enable strict primary-agent orchestrator mode: delegate implementation, debugging/testing, and code-review work to named or general workers; the primary agent may use `read`, `grep`, and `web_search` for read-only research to prepare precise tasks, but does not make direct implementation changes. In orchestrated sessions, these research tools are added after the requested tool allowlist is applied unless tools are disabled with `--no-tools`. It can spawn optional or required 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, and shared/worktree isolation where applicable; lifecycle and result references are persisted. Completion is host-event-driven through `[auto-subagents update]` for every worker; required work stays asynchronous, persists its outcome, and prevents only the terminal parent response until satisfied or explicitly waived by user removal. 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.
443	443		- 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.
444	444		- 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.
445	445		- 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`.


@@ -425,7 +425,7 @@ The fair global scheduler defaults to six concurrent turns, one active turn per
425			425
426		Worktree isolation captures a patch and changed-file list without applying it. Shared children use the host checkout. The available logical references are `subagent://<id>`, `subagent://<id>/history`, `subagent://<id>/result`, and `subagent://<id>/patch`.	426		Worktree isolation captures a patch and changed-file list without applying it. Shared children use the host checkout. The available logical references are `subagent://<id>`, `subagent://<id>/history`, `subagent://<id>/result`, and `subagent://<id>/patch`.
427			427
428	-	Subagent Orchestrator. With `/settings` → Subagent Orchestrator on (or `/orchestrator`), the primary delegates implementation, debugging/testing, and code review to named profiles or explicitly described general children. It coordinates and synthesizes completion updates rather than doing direct implementation. The canonical resident tools remain available for user-requested delegation when the setting is off, subject to launch-time permissions. Do not poll `subagent_status` or journal files solely to wait for completion.	428	+	Subagent Orchestrator. With `/settings` → Subagent Orchestrator on (or `/orchestrator`), the primary delegates implementation, debugging/testing, and code review to named profiles or explicitly described general children. It may use `read` and `grep` for codebase exploration and `web_search` for public-web research before dispatching work, but does not implement directly. These research tools remain available after a requested tool allowlist is applied unless tools are disabled with `--no-tools`. The canonical resident tools remain available for user-requested delegation when the setting is off, subject to launch-time permissions. Do not poll `subagent_status` or journal files solely to wait for completion.
429			429
430		### Named subagent profiles	430		### Named subagent profiles
431			431

@@ -439,7 +439,7 @@ Opens a dialog with every persistent setting. `up`/`down` to navigate, `enter` o
439		- 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.	439		- 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.
440		- 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.	440		- 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.
441		- 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`.	441		- 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`.
442	-	- Subagent Orchestrator — 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 optional or required 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, and shared/worktree isolation where applicable; lifecycle and result references are persisted. Completion is host-event-driven through `[auto-subagents update]` for every worker; required work stays asynchronous, persists its outcome, and prevents only the terminal parent response until satisfied or explicitly waived by user removal. 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.	442	+	- Subagent Orchestrator — enable strict primary-agent orchestrator mode: delegate implementation, debugging/testing, and code-review work to named or general workers; the primary agent may use `read`, `grep`, and `web_search` for read-only research to prepare precise tasks, but does not make direct implementation changes. In orchestrated sessions, these research tools are added after the requested tool allowlist is applied unless tools are disabled with `--no-tools`. It can spawn optional or required 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, and shared/worktree isolation where applicable; lifecycle and result references are persisted. Completion is host-event-driven through `[auto-subagents update]` for every worker; required work stays asynchronous, persists its outcome, and prevents only the terminal parent response until satisfied or explicitly waived by user removal. 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.
443		- 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.	443		- 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.
444		- 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.	444		- 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.
445		- 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`.	445		- 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 packages/agent/build.go +23 -10


@@ -1248,19 +1248,26 @@ func buildToolRegistry(args Args, cwd string, sandbox *tools.Sandbox, lspEnabled
1248	1248		for _, t := range all {
1249	1249		reg[t.Name()] = t
1250	1250		}
1251		-	return reg
1252		-	}
1253		-	for _, name := range args.Tools {
1254		-	if name == "web_search" {
1255		-	for webName, tool := range all {
1256		-	if tools.IsWebCapabilityName(webName) {
1257		-	reg[webName] = tool
	1251	+	} else {
	1252	+	for _, name := range args.Tools {
	1253	+	if name == "web_search" {
	1254	+	for webName, tool := range all {
	1255	+	if tools.IsWebCapabilityName(webName) {
	1256	+	reg[webName] = tool
	1257	+	}
1258	1258		}
	1259	+	continue
	1260	+	}
	1261	+	if t, ok := all[name]; ok {
	1262	+	reg[name] = t
1259	1263		}
1260		-	continue
1261	1264		}
1262		-	if t, ok := all[name]; ok {
1263		-	reg[name] = t
	1265	+	}
	1266	+	if orchestratorExplorationToolsAllowed(args) {
	1267	+	reg["read"] = all["read"]
	1268	+	reg["grep"] = all["grep"]
	1269	+	for name, tool := range tools.NewWebTools() {
	1270	+	reg[name] = tool
1264	1271		}
1265	1272		}
1266	1273		return reg

@@ -1291,6 +1298,12 @@ func autoSubagentsToolAllowed(args Args) bool {
1291	1298		return autoSubagentsToolAllowedFor(args, "subagent_spawn")
1292	1299		}
1293	1300
	1301	+	// orchestratorExplorationToolsAllowed keeps the primary orchestrator's
	1302	+	// read-only exploration tools available without enabling implementation tools.
	1303	+	func orchestratorExplorationToolsAllowed(args Args) bool {
	1304	+	return args.Orchestrate && !args.NoTools
	1305	+	}
	1306	+
1294	1307		func autoSubagentsStatusToolAllowed(args Args) bool {
1295	1308		return autoSubagentsToolAllowedFor(args, "subagent_status")
1296	1309		}

 		for _, t := range all {
 			reg[t.Name()] = t
 		}
-		return reg
+	} else {
-	}
+		for _, name := range args.Tools {
-	for _, name := range args.Tools {
+			if name == "web_search" {
-		if name == "web_search" {
+				for webName, tool := range all {
-			for webName, tool := range all {
+					if tools.IsWebCapabilityName(webName) {
-				if tools.IsWebCapabilityName(webName) {
+						reg[webName] = tool
-					reg[webName] = tool
+					}
 				}
+				continue
+			}
+			if t, ok := all[name]; ok {
+				reg[name] = t
 			}
-			continue
 		}
-		if t, ok := all[name]; ok {
+	}
-			reg[name] = t
+	if orchestratorExplorationToolsAllowed(args) {
+		reg["read"] = all["read"]
+		reg["grep"] = all["grep"]
+		for name, tool := range tools.NewWebTools() {
+			reg[name] = tool
 		}
 	}
 	return reg
 	return autoSubagentsToolAllowedFor(args, "subagent_spawn")
 }
+// orchestratorExplorationToolsAllowed keeps the primary orchestrator's
+// read-only exploration tools available without enabling implementation tools.
+func orchestratorExplorationToolsAllowed(args Args) bool {
+	return args.Orchestrate && !args.NoTools
+}
 func autoSubagentsStatusToolAllowed(args Args) bool {
 	return autoSubagentsToolAllowedFor(args, "subagent_status")
 }

A packages/agent/build_orchestrator_test.go +67 -0

@@ -0,0 +1,67 @@
	1	+	package agent
	2	+
	3	+	import (
	4	+	"testing"
	5	+
	6	+	"github.com/bnema/zut/packages/agent/subagents"
	7	+	"github.com/bnema/zut/packages/agent/tools"
	8	+	)
	9	+
	10	+	func TestOrchestratorAlwaysReceivesResearchTools(t *testing.T) {
	11	+	for _, tc := range []struct {
	12	+	name string
	13	+	args Args
	14	+	wantResearch bool
	15	+	wantWriteTool bool
	16	+	}{
	17	+	{
	18	+	name: "requested allowlist",
	19	+	args: Args{Orchestrate: true, ToolsSet: true, Tools: []string{"subagent_spawn"}},
	20	+	wantResearch: true,
	21	+	wantWriteTool: false,
	22	+	},
	23	+	{
	24	+	name: "web search policy disabled",
	25	+	args: Args{Orchestrate: true, WebSearchPolicy: subagents.WebSearchDeny},
	26	+	wantResearch: true,
	27	+	wantWriteTool: true,
	28	+	},
	29	+	{
	30	+	name: "tools disabled",
	31	+	args: Args{Orchestrate: true, NoTools: true, ToolsSet: true, Tools: []string{"write"}},
	32	+	wantResearch: false,
	33	+	wantWriteTool: false,
	34	+	},
	35	+	{
	36	+	name: "normal session",
	37	+	args: Args{ToolsSet: true, Tools: []string{"write"}},
	38	+	wantResearch: false,
	39	+	wantWriteTool: true,
	40	+	},
	41	+	} {
	42	+	t.Run(tc.name, func(t *testing.T) {
	43	+	registry := buildToolRegistry(tc.args, t.TempDir(), nil, false, false, false)
	44	+
	45	+	if got := orchestratorExplorationToolsAllowed(tc.args); got != tc.wantResearch {
	46	+	t.Fatalf("orchestratorExplorationToolsAllowed = %v, want %v", got, tc.wantResearch)
	47	+	}
	48	+	_, gotRead := registry["read"]
	49	+	if gotRead != tc.wantResearch {
	50	+	t.Fatalf("read present = %v, want %v", gotRead, tc.wantResearch)
	51	+	}
	52	+	if _, ok := registry["grep"].(*tools.GrepTool); ok != tc.wantResearch {
	53	+	t.Fatalf("grep = %T, want research tool present = %v", registry["grep"], tc.wantResearch)
	54	+	}
	55	+	for _, name := range tools.WebCapabilityNames {
	56	+	_, gotWebTool := registry[name]
	57	+	if gotWebTool != tc.wantResearch {
	58	+	t.Fatalf("%s present = %v, want research tool present = %v", name, gotWebTool, tc.wantResearch)
	59	+	}
	60	+	}
	61	+	_, gotWrite := registry["write"]
	62	+	if gotWrite != tc.wantWriteTool {
	63	+	t.Fatalf("write present = %v, want %v", gotWrite, tc.wantWriteTool)
	64	+	}
	65	+	})
	66	+	}
	67	+	}

@@ -0,0 +1,67 @@
	1	+	package agent
	2	+
	3	+	import (
	4	+	"testing"
	5	+
	6	+	"github.com/bnema/zut/packages/agent/subagents"
	7	+	"github.com/bnema/zut/packages/agent/tools"
	8	+	)
	9	+
	10	+	func TestOrchestratorAlwaysReceivesResearchTools(t *testing.T) {
	11	+	for _, tc := range []struct {
	12	+	name string
	13	+	args Args
	14	+	wantResearch bool
	15	+	wantWriteTool bool
	16	+	}{
	17	+	{
	18	+	name: "requested allowlist",
	19	+	args: Args{Orchestrate: true, ToolsSet: true, Tools: []string{"subagent_spawn"}},
	20	+	wantResearch: true,
	21	+	wantWriteTool: false,
	22	+	},
	23	+	{
	24	+	name: "web search policy disabled",
	25	+	args: Args{Orchestrate: true, WebSearchPolicy: subagents.WebSearchDeny},
	26	+	wantResearch: true,
	27	+	wantWriteTool: true,
	28	+	},
	29	+	{
	30	+	name: "tools disabled",
	31	+	args: Args{Orchestrate: true, NoTools: true, ToolsSet: true, Tools: []string{"write"}},
	32	+	wantResearch: false,
	33	+	wantWriteTool: false,
	34	+	},
	35	+	{
	36	+	name: "normal session",
	37	+	args: Args{ToolsSet: true, Tools: []string{"write"}},
	38	+	wantResearch: false,
	39	+	wantWriteTool: true,
	40	+	},
	41	+	} {
	42	+	t.Run(tc.name, func(t *testing.T) {
	43	+	registry := buildToolRegistry(tc.args, t.TempDir(), nil, false, false, false)
	44	+
	45	+	if got := orchestratorExplorationToolsAllowed(tc.args); got != tc.wantResearch {
	46	+	t.Fatalf("orchestratorExplorationToolsAllowed = %v, want %v", got, tc.wantResearch)
	47	+	}
	48	+	_, gotRead := registry["read"]
	49	+	if gotRead != tc.wantResearch {
	50	+	t.Fatalf("read present = %v, want %v", gotRead, tc.wantResearch)
	51	+	}
	52	+	if _, ok := registry["grep"].(*tools.GrepTool); ok != tc.wantResearch {
	53	+	t.Fatalf("grep = %T, want research tool present = %v", registry["grep"], tc.wantResearch)
	54	+	}
	55	+	for _, name := range tools.WebCapabilityNames {
	56	+	_, gotWebTool := registry[name]
	57	+	if gotWebTool != tc.wantResearch {
	58	+	t.Fatalf("%s present = %v, want research tool present = %v", name, gotWebTool, tc.wantResearch)
	59	+	}
	60	+	}
	61	+	_, gotWrite := registry["write"]
	62	+	if gotWrite != tc.wantWriteTool {
	63	+	t.Fatalf("write present = %v, want %v", gotWrite, tc.wantWriteTool)
	64	+	}
	65	+	})
	66	+	}
	67	+	}

M packages/agent/settings_store.go +5 -2


@@ -254,9 +254,12 @@ func AutoSubagentsEnabled() bool {
254	254		// orchestrator.
255	255		const AutoSubagentsSystemAddendum = `Auto-subagents are enabled. You are the primary-agent orchestrator, not an implementer.
256	256
257		-	Delegate all implementation, debugging/testing, and code-review work to an appropriately named subagent profile, or to a clearly described general worker when no profile fits. Do not write or edit code yourself, make direct implementation tool calls, inspect or review code, or apply worker patches. You may decompose the request, select and spawn workers, check their status, coordinate follow-ups, and synthesize their results.
	257	+	- Use read and grep only for read-only codebase exploration before dispatching work. Use web_search only for public-web research that improves worker task instructions.
	258	+	- Delegate all implementation, debugging/testing, and code-review work to an appropriately named subagent profile or a clearly described general worker.
	259	+	- Do not write or edit code yourself, make direct implementation tool calls, inspect or review code through implementation tools, or apply worker patches. You may use read, grep, and web_search for the read-only research above and review worker reports.
	260	+	- Give every worker a self-contained task and synthesize the results.
258	261
259		-	Give every worker a self-contained task because workers start without this conversation's context. Shared-worktree workers edit the same working directory, so coordinate dependent work and avoid conflicting edits. Use isolation:"worktree" for parallel coding when workers need separate trees; its changes are returned as a patch for a worker to integrate, not for you to apply. Do not invent feature scope beyond the user's request. Child workers cannot recursively spawn more sub-agents in v1.
	262	+	Workers start without this conversation's context. Shared-worktree workers edit the same working directory, so coordinate dependent work and avoid conflicting edits. Use isolation:"worktree" for parallel coding when workers need separate trees; its changes are returned as a patch for a worker to integrate, not for you to apply. Do not invent feature scope beyond the user's request. Child workers cannot recursively spawn more sub-agents in v1.
260	263
261	264		Use required:true whenever your answer or a declared workflow depends on that worker, especially for required validation or finalization. Required workers remain asynchronous unless you explicitly set subagent_spawn's wait field: without it, manager calls return immediately, the parent stays free to coordinate or perform independent work, and the host delivers terminal outcomes through completion updates. Failed, canceled, or interrupted required work remains unmet: use an enabled manager follow-up action to retry it and do not claim completion. An indeterminate outcome after host restart must not be retried automatically; the user must inspect durable results and side effects, then explicitly resume, restart, or remove the worker. Only the user can waive required work by explicitly removing the terminal worker with /subagents rm. Keep required:false only for independent work that may safely finish later.
262	265

 // orchestrator.
 const AutoSubagentsSystemAddendum = `Auto-subagents are enabled. You are the primary-agent orchestrator, not an implementer.
-Delegate all implementation, debugging/testing, and code-review work to an appropriately named subagent profile, or to a clearly described general worker when no profile fits. Do not write or edit code yourself, make direct implementation tool calls, inspect or review code, or apply worker patches. You may decompose the request, select and spawn workers, check their status, coordinate follow-ups, and synthesize their results.
+- Use read and grep only for read-only codebase exploration before dispatching work. Use web_search only for public-web research that improves worker task instructions.
+- Delegate all implementation, debugging/testing, and code-review work to an appropriately named subagent profile or a clearly described general worker.
+- Do not write or edit code yourself, make direct implementation tool calls, inspect or review code through implementation tools, or apply worker patches. You may use read, grep, and web_search for the read-only research above and review worker reports.
+- Give every worker a self-contained task and synthesize the results.
-Give every worker a self-contained task because workers start without this conversation's context. Shared-worktree workers edit the same working directory, so coordinate dependent work and avoid conflicting edits. Use isolation:"worktree" for parallel coding when workers need separate trees; its changes are returned as a patch for a worker to integrate, not for you to apply. Do not invent feature scope beyond the user's request. Child workers cannot recursively spawn more sub-agents in v1.
+Workers start without this conversation's context. Shared-worktree workers edit the same working directory, so coordinate dependent work and avoid conflicting edits. Use isolation:"worktree" for parallel coding when workers need separate trees; its changes are returned as a patch for a worker to integrate, not for you to apply. Do not invent feature scope beyond the user's request. Child workers cannot recursively spawn more sub-agents in v1.
 Use required:true whenever your answer or a declared workflow depends on that worker, especially for required validation or finalization. Required workers remain asynchronous unless you explicitly set subagent_spawn's wait field: without it, manager calls return immediately, the parent stays free to coordinate or perform independent work, and the host delivers terminal outcomes through completion updates. Failed, canceled, or interrupted required work remains unmet: use an enabled manager follow-up action to retry it and do not claim completion. An indeterminate outcome after host restart must not be retried automatically; the user must inspect durable results and side effects, then explicitly resume, restart, or remove the worker. Only the user can waive required work by explicitly removing the terminal worker with /subagents rm. Keep required:false only for independent work that may safely finish later.