880bc67 refactor(subagents): canonicalize runtime names · zut

M AGENTS.md +1 -1


@@ -42,7 +42,7 @@ Put behavior in the package that owns the concern:
42		\| `packages/agent/extproto` \| Extension wire protocol \|	42		\| `packages/agent/extproto` \| Extension wire protocol \|
43		\| `packages/agent/ext` \| Public extension SDK \|	43		\| `packages/agent/ext` \| Public extension SDK \|
44		\| `packages/agent/skills` \| Skill discovery and loading \|	44		\| `packages/agent/skills` \| Skill discovery and loading \|
45	-	\| `packages/agent/swarm` \| Background-agent state, supervision, and persistence \|	45	+	\| `packages/agent/subagents` \| Background-agent state, supervision, and persistence \|
46		\| `packages/agent/tools` \| Built-in tools, permission checks, and jail behavior \|	46		\| `packages/agent/tools` \| Built-in tools, permission checks, and jail behavior \|
47		\| `packages/tui` \| Terminal input, layout, rendering, markdown, themes, and images \|	47		\| `packages/tui` \| Terminal input, layout, rendering, markdown, themes, and images \|
48		\| `packages/ignore` \| Ignore-pattern matching \|	48		\| `packages/ignore` \| Ignore-pattern matching \|

M CONTRIBUTING.md +1 -1


@@ -46,7 +46,7 @@ The major ownership boundaries are:
46		- `packages/agent/modes`: interactive and non-interactive user modes	46		- `packages/agent/modes`: interactive and non-interactive user modes
47		- `packages/agent/extensions`, `extproto`, and `ext`: extension hosting, protocol, and SDK	47		- `packages/agent/extensions`, `extproto`, and `ext`: extension hosting, protocol, and SDK
48		- `packages/agent/skills`: reusable instruction discovery	48		- `packages/agent/skills`: reusable instruction discovery
49	-	- `packages/agent/swarm`: background-agent supervision and state	49	+	- `packages/agent/subagents`: background-agent supervision and state
50		- `packages/agent/tools`: built-in tools, permissions, and jail checks	50		- `packages/agent/tools`: built-in tools, permissions, and jail checks
51		- `packages/tui`: terminal mechanics and rendering	51		- `packages/tui`: terminal mechanics and rendering
52		- `packages/ignore`: ignore matching	52		- `packages/ignore`: ignore matching

M README.md +9 -11

 | `/session` | Four ops on the current session: `export` to a portable `.zotsession` file, `import` one back in, `fork` from a past user message into a new branch, `tree` to switch between branches. Opens a picker without an argument; direct forms: `/session export [path]`, `/session import <path>`, `/session fork`, `/session tree`. Default export destination is `~/Downloads`. `Esc` `Esc` from an idle, empty editor is a shortcut for `/session tree` when the terminal supplies two parsed bare Escape events. |
 | `/jump` | Scroll the chat to a previous turn (or `/jump <text>` to filter). |
 | `/btw` | Side chat with full context that doesn't add to the main thread. |
-| `/subagents` | Spawn, monitor, and chat with background subagents. Each is a separate long-lived process with bounded lifecycle state, structured results, and optional Git worktree isolation. `/swarm` remains a compatibility alias. Named profiles can be selected with `agent`; see [docs/subagents.md](docs/subagents.md). |
+| `/subagents` | Spawn, monitor, and chat with background subagents. Each is a separate long-lived process with bounded lifecycle state, structured results, and optional Git worktree isolation. Named profiles can be selected with `agent`; see [docs/subagents.md](docs/subagents.md). |
 | `/skills` | List discovered skills (SKILL.md files) and preview their bodies. |
 | `/compact` | Summarize the transcript into one message to free up context. |
 | `/study` | Run the canned prompt "Read and understand everything in the current directory." so the agent has full project context before you start asking targeted questions. Pass a path — typed, drag-dropped, or selected via `@` — to target a specific file or directory instead: `/study [dir:packages/]`, `/study cmd/zot/main.go`. |
 | `/unjail` | Allow tools to touch paths outside again. |
 | `/reload-ext` | Hot-reload all extensions (re-read manifests, respawn subprocesses, rebuild tool registry). |
 | `/telegram` | Connect, disconnect, or show status of the Telegram bridge (takes `connect` / `disconnect` / `status` as an optional argument; opens a picker without one). When connected, DMs from the paired user become prompts in the running session and the assistant's replies are mirrored back to Telegram. Alias: `/tg`. |
-| `/settings` | Change persistent settings, including inline images, terminal alerts, AI terminal titles, auto-swarm, fast mode, main/sub-agent LSP access, and the auto-compact threshold. Saved to `$ZOT_HOME/config.json`; setting changes apply without a restart, while AI title generation waits for the first real prompt. |
+| `/settings` | Change persistent settings, including inline images, terminal alerts, AI terminal titles, auto-subagents, fast mode, main/sub-agent LSP access, and the auto-compact threshold. Saved to `$ZOT_HOME/config.json`; setting changes apply without a restart, while AI title generation waits for the first real prompt. |
 | `/clear` | Clear the chat transcript. |
 | `/exit` | Exit zot. |
 - **`/session export [path]`**. Writes the running transcript to a portable `.zotsession` file. Default destination is `~/Downloads/<timestamp>-<session-id>-<prompt-slug>.zotsession`. Pass a path to override; a directory is fine (a dated name is built inside), a bare name gets `.zotsession` appended. The meta's cwd is stripped on the way out so the recipient doesn't see your filesystem layout.
-  **What's included.** Only the main chat thread of the running session — messages, tool calls, tool results, compactions, and usage. **`/swarm` subagents are NOT included.** Their transcripts, unix-socket inboxes, and per-agent session files are all machine-local; a `.zotsession` is just a chat transcript and has no way to revive a unix socket on another box. If you want the conversation, copy it out of the dashboard manually.
+  **What's included.** Only the main chat thread of the running session — messages, tool calls, tool results, compactions, and usage. **`/subagents` subagents are NOT included.** Their transcripts, unix-socket inboxes, and per-agent session files are all machine-local; a `.zotsession` is just a chat transcript and has no way to revive a unix socket on another box. If you want the conversation, copy it out of the dashboard manually.
 - **`/session import <path>`**. Copies a `.zotsession` file into `$ZOT_HOME/sessions/<cwd-hash>/` with a fresh id and the current cwd, then switches the running agent onto it. Imported sessions are first-class: they show up in `/sessions` and `/jump`, and in the current-family tree when they are part of that family. Drag-drop paths in the editor are accepted (zot strips the surrounding quotes automatically).
 - **`/fork`** (also available as **`/session fork`**). Opens a turn picker (same shape as `/jump`). Pick any past user message; zot copies the transcript through that turn into a new branch and switches to it without starting a provider request. The parent session stays on disk. Use it to try a different question without polluting the original transcript, or to rewind after the agent went down the wrong path. Use a user-message row in `/session tree` when you want the prompt restored for editing, including image attachments.
 - **`/session tree`**. Shows the current session's family: its root ancestor and descendants, not unrelated root sessions in the same cwd. Use `up`/`down` and `enter` to choose a row; `esc` closes the tree. The picker keeps pre-compaction history available as forkable user and assistant messages, while hiding tool calls, tool results, compaction checkpoints, shell/image helper rows, and other internal context. Message rows are indented at their branch points and the current endpoint is tagged `[current]`. Empty and detached branch points are represented by visible boundary rows. A child whose historical fork point no longer matches after compaction stays discoverable as a detached branch under the parent's current tail rather than disappearing. Parentless sessions are roots; orphaned children (whose parent file was deleted) remain roots.
 /subagents restart-task <id>                   # intentionally run the stored task again
 /subagents kill <id>                            # cancel gracefully, then force-stop
 /subagents remove <id>                          # delete durable state
-# /swarm remains an alias for /subagents
 ```
 **Dashboard (`/subagents` with no arg)** — a list of every agent for the current session, with process/turn state, queue position, age, workspace mode, and current activity. Keys:
 **Session scoping** — each agent is stamped with the host session that spawned it and only shows up in that session's dashboard. Swap sessions with `/sessions` and the dashboard re-narrows accordingly. Agents from other sessions keep running in the background and reappear when you switch back.
-**Persistence across zot restarts** — every spawn writes a durable manifest, append-only event log, session file, and structured `result.json` under `$ZOT_HOME/swarm/agents/<id>/`. On the next `zot` launch they show up as **detached**; use `R` or `/subagents resume-session <id>` to continue the existing session. `/subagents restart-task <id>` is the explicit operation that intentionally replays the stored task. Existing `$ZOT_HOME/swarm` state remains readable.
+**Persistence across zot restarts** — every spawn writes a durable manifest, append-only event log, session file, and structured `result.json` under `$ZOT_HOME/subagents/agents/<id>/`. On the next `zot` launch they show up as **detached**; use `R` or `/subagents resume-session <id>` to continue the existing session. `/subagents restart-task <id>` is the explicit operation that intentionally replays the stored task.
-**Where state lives** — per-agent manifests, session files, events, results, and patches live under `$ZOT_HOME/swarm/agents/<id>/`; inbox sockets are runtime-only and permission-restricted. Shared-mode edits land directly in the repo. Worktree-mode edits are captured as durable patches and changed-file summaries before cleanup.
+**Where state lives** — per-agent manifests, session files, events, results, and patches live under `$ZOT_HOME/subagents/agents/<id>/`; inbox sockets are runtime-only and permission-restricted. Shared-mode edits land directly in the repo. Worktree-mode edits are captured as durable patches and changed-file summaries before cleanup.
 **`/session export` does NOT bundle subagents.** A `.zotsession` 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.
-**Auto-swarm.** With `/settings` -> auto-swarm on, the main agent gets the canonical `subagent_spawn` tool (`swarm_spawn` remains an alias) and a system-prompt nudge to delegate independent work. The tool returns the child id and lifecycle state immediately; completion is a durable `turn.result` with a `subagent://<id>/result` reference. It accepts named profiles, timeout, `max_turns`, and `isolation:"shared"` or `isolation:"worktree"`. Global concurrency and total-spawn budgets apply equally to slash commands, tool calls, and batches. Off by default; toggle from `/settings`.
+**Auto-subagents.** With `/settings` -> auto-subagents on, the main agent gets the canonical `subagent_spawn` tool and a system-prompt nudge to delegate independent work. The tool returns the child id and lifecycle state immediately; completion is a durable `turn.result` with a `subagent://<id>/result` reference. It accepts named profiles, timeout, `max_turns`, and `isolation:"shared"` or `isolation:"worktree"`. Global concurrency and total-spawn budgets apply equally to slash commands, tool calls, and batches. Off by default; toggle from `/settings`.
 ### Named subagent profiles
-zot discovers the common markdown/frontmatter profile layout from `~/.agents/agents/*.md` by default. With auto-swarm enabled, the main agent receives `[subagents_list]` metadata and can select a named profile through `subagent_spawn` (`swarm_spawn` remains an alias). Profile bodies are applied only to the selected child. See [docs/subagents.md](docs/subagents.md) for discovery, supported fields, reasoning levels, and examples.
+zot discovers the common markdown/frontmatter profile layout from `~/.agents/agents/*.md` by default. With auto-subagents enabled, the main agent receives `[subagents_list]` metadata and can select a named profile through `subagent_spawn`. Profile bodies are applied only to the selected child. See [docs/subagents.md](docs/subagents.md) for discovery, supported fields, reasoning levels, and examples.
 ### `/settings`
 - **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.
 - **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.
 - **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 `zot: <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`.
-- **auto-swarm** — let the main agent spawn background sub-agents in parallel via the canonical `subagent_spawn` tool (`swarm_spawn` remains an alias). Off by default. The tool accepts named profiles, reasoning, timeout, turn limits, and shared/worktree isolation; lifecycle and result references are persisted. Completion updates still arrive through the auto-swarm watcher. See `/subagents` and [docs/subagents.md](docs/subagents.md) for details.
+- **auto-subagents** — let the main agent spawn background sub-agents in parallel via the canonical `subagent_spawn` tool. Off by default. The tool accepts named profiles, reasoning, timeout, turn limits, and shared/worktree isolation; lifecycle and result references are persisted. Completion updates still arrive through the auto-subagents watcher. See `/subagents` and [docs/subagents.md](docs/subagents.md) for details.
 - **fast mode** — request OpenAI's Fast service tier for OpenAI, OpenAI Responses, and OpenAI Codex models. Off by default; changes apply on the next model call and persist as `fast_mode`. Other providers return an unsupported-provider error. Fast mode may cost more and depends on the selected OpenAI model/account.
 - **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`.
 - **lsp in sub-agents** — allow newly spawned background sub-agents to use the built-in `lsp` tool. Enabled by default; changes persist as `subagent_lsp_enabled` and apply when a child starts.
 packages/agent/modes/telegram/        telegram adapter, api client, daemon
 packages/agent/tools/                 read, write, edit, bash, lsp, sandbox
 packages/agent/skills/                skill discovery, frontmatter parser, skill tool
-packages/agent/subagents/             named markdown profile discovery and dispatch
+packages/agent/subagents/             named profiles, supervisor, and background runtime
-packages/agent/swarm/                 background subagent runtime
 packages/agent/sdk/                   public Go SDK for embedding zot in-process (package sdk)
 packages/agent/ext/                   public Go SDK for writing extensions (package ext)
 ```

M docs/lsp.md +1 -1


@@ -120,7 +120,7 @@ diagnostics allows a later recurrence to be surfaced again.
120			120
121		- lsp in main session (`lsp_enabled`) controls the main agent and applies	121		- lsp in main session (`lsp_enabled`) controls the main agent and applies
122		immediately to the live tool registry.	122		immediately to the live tool registry.
123	-	- lsp in sub-agents (`subagent_lsp_enabled`) controls newly spawned swarm	123	+	- lsp in sub-agents (`subagent_lsp_enabled`) controls newly spawned subagent
124		child processes.	124		child processes.
125			125
126		The sub-agent setting does not grant access to a child whose profile or	126		The sub-agent setting does not grant access to a child whose profile or

M docs/providers.md +1 -1


@@ -123,7 +123,7 @@ off by default and is stored as `fast_mode` in `$ZOT_HOME/config.json`.
123			123
124		Fast mode is currently limited to those OpenAI provider IDs. Enabling it while	124		Fast mode is currently limited to those OpenAI provider IDs. Enabling it while
125		using another provider returns an error instead of silently changing that	125		using another provider returns an error instead of silently changing that
126	-	provider's request. Swarm children inherit the setting from their parent.	126	+	provider's request. Subagent children inherit the setting from their parent.
127			127
128		Example:	128		Example:
129			129

M docs/subagents.md +3 -3


@@ -39,7 +39,7 @@ Supported metadata:
39			39
40		\| Field \| Meaning \|	40		\| Field \| Meaning \|
41		\|---\|---\|	41		\|---\|---\|
42	-	\| `name` \| Name passed to `subagent_spawn`'s `agent` field (`swarm_spawn` is a compatibility alias). Falls back to the filename. \|	42	+	\| `name` \| Name passed to `subagent_spawn`'s `agent` field. Falls back to the filename. \|
43		\| `description` \| Short description shown to the main agent. \|	43		\| `description` \| Short description shown to the main agent. \|
44		\| `tools` \| Comma-separated or list-form tool names. zot enforces its built-in `read`, `write`, `edit`, `bash`, and `lsp` registry; the conditional `skill` tool is available when skills are enabled. Unknown names do not grant capabilities. \|	44		\| `tools` \| Comma-separated or list-form tool names. zot enforces its built-in `read`, `write`, `edit`, `bash`, and `lsp` registry; the conditional `skill` tool is available when skills are enabled. Unknown names do not grant capabilities. \|
45		\| `model` \| Optional model ID. A qualified value such as `openai-codex/gpt-5.6-luna` selects both provider and model. \|	45		\| `model` \| Optional model ID. A qualified value such as `openai-codex/gpt-5.6-luna` selects both provider and model. \|

@@ -54,7 +54,7 @@ Other frontmatter from another agent host is ignored when zot does not have an e
54			54
55		## Selecting a profile	55		## Selecting a profile
56			56
57	-	When auto-swarm is enabled in `/settings`, the main agent receives a compact `[subagents_list]` section in its system prompt and can select a profile for `subagent_spawn`:	57	+	When auto-subagents is enabled in `/settings`, the main agent receives a compact `[subagents_list]` section in its system prompt and can select a profile for `subagent_spawn`:
58			58
59		```json	59		```json
60		{	60		{

@@ -90,7 +90,7 @@ Shared mode preserves the historical host working directory. For parallel coding
90			90
91		Every child has independent process and turn state. A process may be `alive` while its turn is `idle`; a supervisor restart marks the process `detached` without claiming that its last turn failed. Durable manifests include the task, parent/root session identity, workspace mode, attempt, process/turn state, heartbeat timestamps, and logical result references.	91		Every child has independent process and turn state. A process may be `alive` while its turn is `idle`; a supervisor restart marks the process `detached` without claiming that its last turn failed. Durable manifests include the task, parent/root session identity, workspace mode, attempt, process/turn state, heartbeat timestamps, and logical result references.
92			92
93	-	The worker and supervisor communicate over newline-delimited JSON. Current messages use version `1` envelopes with `version`, `message_id`, `agent_id`, `turn_id`, `timestamp`, and `payload`. Unknown event names and payload fields are retained. Older flat JSON events and text commands (`user ...`, `cancel`, `shutdown`) remain readable during the compatibility window.	93	+	The worker and supervisor communicate over newline-delimited JSON. Current messages use version `1` envelopes with `version`, `message_id`, `agent_id`, `turn_id`, `timestamp`, and `payload`. Unknown event names and payload fields are retained. Only versioned JSONL envelopes are accepted on the worker protocol.
94			94
95		A completed worker emits a `turn.result` event and writes `result.json`. The inline output is bounded; inspect the full session through the stable references:	95		A completed worker emits a `turn.result` event and writes `result.json`. The inline output is bounded; inspect the full session through the stable references:
96			96

M packages/agent/args.go +16 -17

 	ModeStream      Mode = "stream"
 	ModeJSON        Mode = "json"
 	ModeRPC         Mode = "rpc"
-	// ModeSwarmAgent is the long-lived, headless daemon mode used by
+	// ModeSubagentWorker is the long-lived, headless daemon mode used by
-	// swarm-spawned agents. The binary opens a unix-socket inbox at
+	// subagent-spawned agents. The binary opens a unix-socket inbox at
-	// the path provided by --subagent-worker, reads supervisor messages
+	// the path provided by --subagent-worker, reads versioned JSONL
-	// off it (versioned JSONL, with a legacy text reader), runs each user
+	// supervisor messages, runs each user turn against a persistent session,
-	// turn against a persistent session, and streams JSONL events on
+	// and streams JSONL events on
-	// stdout. --swarm-agent remains an input compatibility alias.
+	// stdout.
 	ModeSubagentWorker Mode = "subagent-worker"
-	ModeSwarmAgent     Mode = ModeSubagentWorker
 )
 // Args holds parsed command-line options.
 	Model    string
 	APIKey   string
-	// inheritedCredential is populated only by swarm-agent mode from
+	// inheritedCredential is populated only by subagent-worker mode from
 	// the supervisor's stdin. It is never accepted as a CLI argument.
 	inheritedCredential string
 	inheritedAuthMethod string
 	Reasoning          string
 	Temperature        *float32
-	// FastMode is an internal swarm-child propagation flag. Normal users
+	// FastMode is an internal subagent-child propagation flag. Normal users
 	// enable fast mode through the persisted config /settings toggle.
 	FastMode bool
 	// FastModeSet distinguishes an explicit child override (including
-	// --no-fast-mode) from an omitted flag so persisted swarm settings
+	// --no-fast-mode) from an omitted flag so persisted subagent settings
 	// survive a parent config change.
 	FastModeSet bool
 	// mode auto-submits it once at startup before InitialInput handling.
 	StartupPre string
-	// SwarmAgent is the inbox-socket path when this process is a
+	// SubagentWorker is the inbox-socket path when this process is a
 	// subagent worker. Empty in every other mode. Set by either
-	// --subagent-worker or the --swarm-agent compatibility alias.
+	// --subagent-worker.
-	SwarmAgent string
+	SubagentWorker string
 	// SubagentMaxTurns limits prompt-level turns in worker mode.
 	SubagentMaxTurns int
-	// Subagent selects a named markdown profile for a swarm child.
+	// Subagent selects a named markdown profile for a subagent child.
-	// It is intentionally an internal child flag; the parent swarm tool
+	// It is intentionally an internal child flag; the parent subagent tool
 	// passes only the profile name and the child discovers the definition
 	// locally.
 	Subagent string
 				return a, err
 			}
 			a.CWD = v
-		case "--subagent-worker", "--swarm-agent":
+		case "--subagent-worker":
 			v, err := want(&i, arg)
 			if err != nil {
 				return a, err
 			}
-			a.SwarmAgent = v
+			a.SubagentWorker = v
 			a.Mode = ModeSubagentWorker
 		case "--subagent":
 			v, err := want(&i, arg)

M packages/agent/args_test.go +2 -2


@@ -3,11 +3,11 @@ package agent
3		import "testing"	3		import "testing"
4			4
5		func TestParseArgsSubagentAndReasoning(t *testing.T) {	5		func TestParseArgsSubagentAndReasoning(t *testing.T) {
6	-	args, err := ParseArgs([]string{"--swarm-agent", "/tmp/in.sock", "--subagent", "reviewer", "--reasoning", "high", "task"})	6	+	args, err := ParseArgs([]string{"--subagent-worker", "/tmp/in.sock", "--subagent", "reviewer", "--reasoning", "high", "task"})
7		if err != nil {	7		if err != nil {
8		t.Fatal(err)	8		t.Fatal(err)
9		}	9		}
10	-	if args.Mode != ModeSwarmAgent \|\| args.Subagent != "reviewer" \|\| args.Reasoning != "high" \|\| args.Prompt != "task" {	10	+	if args.Mode != ModeSubagentWorker \|\| args.Subagent != "reviewer" \|\| args.Reasoning != "high" \|\| args.Prompt != "task" {
11		t.Fatalf("parsed args = mode=%q subagent=%q reasoning=%q prompt=%q", args.Mode, args.Subagent, args.Reasoning, args.Prompt)	11		t.Fatalf("parsed args = mode=%q subagent=%q reasoning=%q prompt=%q", args.Mode, args.Subagent, args.Reasoning, args.Prompt)
12		}	12		}
13		}	13		}

M packages/agent/build.go +5 -5


@@ -691,7 +691,7 @@ func Resolve(args Args, requireCred bool) (Resolved, error) {
691		if args.PermissionSet != nil {	691		if args.PermissionSet != nil {
692		sandbox.SetPermissions(args.PermissionSet)	692		sandbox.SetPermissions(args.PermissionSet)
693		}	693		}
694	-	subagentSession := args.Mode == ModeSwarmAgent \|\| strings.TrimSpace(args.Subagent) != ""	694	+	subagentSession := args.Mode == ModeSubagentWorker \|\| strings.TrimSpace(args.Subagent) != ""
695		lspEnabled := !args.NoLSP && cfg.LSPEnabledFor(subagentSession)	695		lspEnabled := !args.NoLSP && cfg.LSPEnabledFor(subagentSession)
696		reg := buildToolRegistry(args, args.CWD, sandbox, lspEnabled, cfg.LSPDiagnosticsOnWriteEnabled(subagentSession), cfg.LSPDiagnosticsOnEditEnabled(subagentSession))	696		reg := buildToolRegistry(args, args.CWD, sandbox, lspEnabled, cfg.LSPDiagnosticsOnWriteEnabled(subagentSession), cfg.LSPDiagnosticsOnEditEnabled(subagentSession))
697			697

@@ -737,13 +737,13 @@ func Resolve(args Args, requireCred bool) (Resolved, error) {
737		append_ = append(append_, skillAddendum)	737		append_ = append(append_, skillAddendum)
738		}	738		}
739		interactiveMode := args.Mode == "" \|\| args.Mode == ModeInteractive	739		interactiveMode := args.Mode == "" \|\| args.Mode == ModeInteractive
740	-	if selectedProfile == nil && interactiveMode && autoSwarmToolAllowed(args) && cfg.AutoSwarmEnabled != nil && *cfg.AutoSwarmEnabled {	740	+	if selectedProfile == nil && interactiveMode && autoSubagentsToolAllowed(args) && cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {
741		homeDir, _ := os.UserHomeDir()	741		homeDir, _ := os.UserHomeDir()
742		profiles, _ := subagents.Discover(args.CWD, homeDir)	742		profiles, _ := subagents.Discover(args.CWD, homeDir)
743		if subagentsAddendum := subagents.SystemPromptAddendum(profiles); subagentsAddendum != "" {	743		if subagentsAddendum := subagents.SystemPromptAddendum(profiles); subagentsAddendum != "" {
744		append_ = append(append_, subagentsAddendum)	744		append_ = append(append_, subagentsAddendum)
745		}	745		}
746	-	append_ = append(append_, AutoSwarmSystemAddendum)	746	+	append_ = append(append_, AutoSubagentsSystemAddendum)
747		}	747		}
748		if selectedProfile != nil && selectedProfile.SystemPromptMode != "replace" && selectedProfile.SystemPrompt != "" {	748		if selectedProfile != nil && selectedProfile.SystemPromptMode != "replace" && selectedProfile.SystemPrompt != "" {
749		append_ = append(append_, selectedProfile.SystemPrompt)	749		append_ = append(append_, selectedProfile.SystemPrompt)

@@ -1188,7 +1188,7 @@ func lspManagerNeeded(args Args, diagnosticsOnWrite, diagnosticsOnEdit bool) boo
1188		return false	1188		return false
1189		}	1189		}
1190			1190
1191	-	func autoSwarmToolAllowed(args Args) bool {	1191	+	func autoSubagentsToolAllowed(args Args) bool {
1192		if args.NoTools \|\| args.PermissionSet != nil {	1192		if args.NoTools \|\| args.PermissionSet != nil {
1193		return false	1193		return false
1194		}	1194		}

@@ -1196,7 +1196,7 @@ func autoSwarmToolAllowed(args Args) bool {
1196		return true	1196		return true
1197		}	1197		}
1198		for _, name := range args.Tools {	1198		for _, name := range args.Tools {
1199	-	if name == "subagent_spawn" \|\| name == "swarm_spawn" {	1199	+	if name == "subagent_spawn" {
1200		return true	1200		return true
1201		}	1201		}
1202		}	1202		}

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


@@ -156,7 +156,7 @@ func TestFindSubagentProfileReportsDiscoveryFailure(t *testing.T) {
156		}	156		}
157		}	157		}
158			158
159	-	func TestResolveIncludesNamedSubagentsListWhenAutoSwarmIsEnabled(t *testing.T) {	159	+	func TestResolveIncludesNamedSubagentsListWhenAutoSubagentsIsEnabled(t *testing.T) {
160		root := t.TempDir()	160		root := t.TempDir()
161		home := filepath.Join(root, "home")	161		home := filepath.Join(root, "home")
162		zotHome := filepath.Join(root, "zot-home")	162		zotHome := filepath.Join(root, "zot-home")

@@ -171,7 +171,7 @@ func TestResolveIncludesNamedSubagentsListWhenAutoSwarmIsEnabled(t *testing.T) {
171		t.Setenv("ZOT_HOME", zotHome)	171		t.Setenv("ZOT_HOME", zotHome)
172		t.Setenv("ZOT_AGENT_PROFILES", filepath.Join(home, ".agents", "agents"))	172		t.Setenv("ZOT_AGENT_PROFILES", filepath.Join(home, ".agents", "agents"))
173		enabled := true	173		enabled := true
174	-	if err := SaveConfig(Config{Provider: "openai", Model: "gpt-5", AutoSwarmEnabled: &enabled}); err != nil {	174	+	if err := SaveConfig(Config{Provider: "openai", Model: "gpt-5", AutoSubagentsEnabled: &enabled}); err != nil {
175		t.Fatal(err)	175		t.Fatal(err)
176		}	176		}
177		profile := `---	177		profile := `---

@@ -510,7 +510,7 @@ func TestResolveOllamaUsesModelBaseURLBeforeDefault(t *testing.T) {
510		}	510		}
511		}	511		}
512			512
513	-	func TestResolveUsesInheritedSwarmCredential(t *testing.T) {	513	+	func TestResolveUsesInheritedSupervisorCredential(t *testing.T) {
514		t.Setenv("ZOT_HOME", t.TempDir())	514		t.Setenv("ZOT_HOME", t.TempDir())
515		t.Setenv("OPENAI_API_KEY", "")	515		t.Setenv("OPENAI_API_KEY", "")
516			516

M packages/agent/cli.go +122 -127

 	"github.com/patriceckhart/zot/packages/agent/modes"
 	"github.com/patriceckhart/zot/packages/agent/skills"
 	"github.com/patriceckhart/zot/packages/agent/subagents"
-	"github.com/patriceckhart/zot/packages/agent/swarm"
 	"github.com/patriceckhart/zot/packages/agent/tools"
 	"github.com/patriceckhart/zot/packages/core"
 	"github.com/patriceckhart/zot/packages/provider"
 		return runJSONMode(ctx, args, version)
 	case ModeRPC:
 		return runRPCMode(ctx, args, version)
-	case ModeSwarmAgent:
+	case ModeSubagentWorker:
-		return runSwarmAgentMode(ctx, args, version)
+		return runSubagentWorkerMode(ctx, args, version)
 	default:
 		return runInteractive(ctx, args, version)
 	}
 // skills and currently loaded extension tools) and updates the live
 // agent's registry and system prompt. Used after /reload-ext and after
 // zotfile entry.pre installs new skills or extensions.
-// mutateRegistry, if non-nil, can inject session-specific tools (e.g. swarm_spawn).
+// mutateRegistry, if non-nil, can inject session-specific tools (e.g. subagent_spawn).
 func refreshAgentToolsAndPrompt(args Args, sharedSandbox *tools.Sandbox, extToolAdapter ExtensionToolSource, ag *core.Agent, mutateRegistry func(core.Registry) core.Registry) {
 	if ag == nil {
 		return
 // ---- interactive mode: opens the TUI even without credentials ----
-func subagentPolicyFromConfig(cfg SubagentsConfig) swarm.SubagentPolicy {
+func subagentPolicyFromConfig(cfg SubagentsConfig) subagents.SubagentPolicy {
 	parseDuration := func(value string) time.Duration {
 		if strings.TrimSpace(value) == "" {
 			return 0
 		}
 		return parsed
 	}
-	return swarm.SubagentPolicy{
+	return subagents.SubagentPolicy{
 		MaxConcurrent:          cfg.MaxConcurrent,
 		MaxConcurrentPerParent: cfg.MaxConcurrentPerParent,
 		MaxTotalSpawned:        cfg.MaxTotalSpawned,
 	// persistMu guards the active session and selection across the agent
 	// loop, TUI callbacks, and session swaps. Declare it before tool
-	// construction because swarm defaults must read the live selection too.
+	// construction because subagent defaults must read the live selection too.
 	var persistMu sync.Mutex
 	// Serialize session transitions with persistence callbacks so a candidate
 	// is read only after the old agent is flushed and cannot be overwritten by
 	extToolAdapter := &extToolAdapter{mgr: extMgr}
 	r.MergeExtensionTools(extToolAdapter)
-	// Build the swarm supervisor BEFORE the agent so the auto-swarm
+	// Build the subagent supervisor BEFORE the agent so the auto-subagents
 	// tool can reference it during tool-registry construction. State
-	// lives under ZotHome/swarm so per-agent meta/events survive
+	// lives under ZotHome/subagents so per-agent meta/events survive
 	// restarts; the user can hunt orphaned agents down with
 	// `git worktree list` if anything misbehaves.
 	//
-	// swarmMgr is also captured by loadSession / changeCWD closures
+	// subagentsMgr is also captured by loadSession / changeCWD closures
 	// further down the function, which is why we keep the variable
 	// in this outer scope rather than scoping it tighter.
-	var swarmMgr *swarm.Swarm
+	var subagentsMgr *subagents.Supervisor
-	swarmMgr = swarm.New(swarm.Config{
+	subagentsMgr = subagents.New(subagents.Config{
 		Context:     ctx,
-		Root:        filepath.Join(ZotHome(), "swarm"),
+		Root:        filepath.Join(ZotHome(), "subagents"),
 		RepoRoot:    r.CWD,
 		Provider:    r.Provider,
 		FastMode:    r.FastMode,
 		BaseURL:     r.BaseURL,
 		InsecureTLS: r.InsecureTLS,
 		Policy:      subagentPolicyFromConfig(initialCfg.Subagents),
-		// Keep an explicit launch key in this callback only. Swarm persists
+		// Keep an explicit launch key in this callback only. Supervisor persists
 		// connection settings, but never stores credentials in Agent metadata
 		// or puts them in the worker's argv/environment.
-		ResolveCredential: func(ctx context.Context, providerID string) (swarm.Credential, error) {
+		ResolveCredential: func(ctx context.Context, providerID string) (subagents.Credential, error) {
 			childProvider := canonicalProvider(providerID)
 			persistMu.Lock()
 			hostProvider := canonicalProvider(activeProvider)
 				explicit = args.APIKey
 			}
 			if childProvider == "ollama" && explicit == "" {
-				return swarm.Credential{Value: "ollama", Method: "apikey"}, nil
+				return subagents.Credential{Value: "ollama", Method: "apikey"}, nil
 			}
 			credential, method, accountID, err := ResolveCredentialFullContext(ctx, childProvider, explicit)
 			if err != nil {
 				// Providers backed only by a local endpoint do not need a key.
 				// Leave stdin untouched and let the child resolve that endpoint.
 				if !CredentialAvailable(childProvider) {
-					return swarm.Credential{}, nil
+					return subagents.Credential{}, nil
 				}
-				return swarm.Credential{}, err
+				return subagents.Credential{}, err
 			}
-			return swarm.Credential{Value: credential, Method: method, AccountID: accountID}, nil
+			return subagents.Credential{Value: credential, Method: method, AccountID: accountID}, nil
 		},
 	})
 	// Pull any previously-spawned agents off disk so the dashboard
 	// shows them as detached and the user can resume / remove them.
-	_, _ = swarmMgr.Reload()
+	_, _ = subagentsMgr.Reload()
 	if args.PermissionSet != nil {
 		// Packaged zotfile agents have an explicit capability ceiling. A
 		// child process would otherwise rebuild a fresh unrestricted sandbox,
 		// so do not expose either slash or tool-based delegation from this
 		// restricted host until worker capability propagation exists.
-		swarmMgr = nil
+		subagentsMgr = nil
 	}
-	// onSpawnedSwarm is the OnSpawned callback the swarm_spawn tool
+	// onSpawnedSupervisor is the OnSpawned callback the subagent_spawn tool
 	// fires after every successful spawn. It hands the agent off to
 	// the running Interactive so the watcher can flush a summary back
 	// into chat when all sub-agents finish. Reads `iv` lazily because
 	// the Interactive is constructed after the agent.
-	onSpawnedSwarm := func(a *swarm.Agent, task string) {
+	onSpawnedSupervisor := func(a *subagents.Agent, task string) {
 		if iv != nil {
-			iv.TrackSwarmAgent(a, task)
+			iv.TrackSubagentWorker(a, task)
 		}
 	}
 	resolveSubagent := func(name string) (*subagents.Profile, error) {
 		return findSubagentProfile(r.CWD, name)
 	}
-	// Inject the swarm_spawn auto-swarm tool only when /settings ->
+	// Inject the subagent_spawn auto-subagents tool only when /settings ->
-	// auto-swarm is currently enabled. Registering it unconditionally
+	// auto-subagents is currently enabled. Registering it unconditionally
 	// leaves the model trying to call it (and getting a polite error)
 	// even when the user has switched the feature off. The /settings
 	// toggle live-mutates the running agent's registry separately so
 	// flipping the flag mid-session takes effect on the next turn.
-	injectSwarmSpawn := func(reg core.Registry) core.Registry {
+	injectSubagentSpawn := func(reg core.Registry) core.Registry {
-		if reg == nil || swarmMgr == nil || !autoSwarmToolAllowed(args) {
+		if reg == nil || subagentsMgr == nil || !autoSubagentsToolAllowed(args) {
 			return reg
 		}
-		if !AutoSwarmEnabled() {
+		if !AutoSubagentsEnabled() {
 			return reg
 		}
-		canonical := &tools.SwarmSpawnTool{
+		canonical := &tools.SubagentSpawnTool{
-			ToolName: "subagent_spawn",
+			Supervisor: subagentsMgr,
-			Swarm:    swarmMgr,
+			Enabled:    AutoSubagentsEnabled,
-			Enabled:  AutoSwarmEnabled,
 			DefaultModel: func() string {
 				persistMu.Lock()
 				defer persistMu.Unlock()
 			},
 			DefaultReasoning: func() string { return r.Reasoning },
 			ResolveSubagent:  resolveSubagent,
-			OnSpawned:        onSpawnedSwarm,
+			OnSpawned:        onSpawnedSupervisor,
 		}
 		reg[canonical.Name()] = canonical
-		legacy := *canonical
-		legacy.ToolName = "swarm_spawn"
-		reg[legacy.Name()] = &legacy
 		return reg
 	}
-	injectSwarmSpawn(r.ToolRegistry)
+	injectSubagentSpawn(r.ToolRegistry)
 	// Confirmation gate: when --no-yolo is on, the agent must ask
 	// the user before every tool call. In interactive mode the TUI
 			return nil, "", "", err
 		}
 		resolved.UseSandbox(sharedSandbox)
-		if swarmMgr != nil {
+		if subagentsMgr != nil {
-			swarmMgr.SetProvider(resolved.Provider)
+			subagentsMgr.SetProvider(resolved.Provider)
-			swarmMgr.SetProviderSettings(resolved.BaseURL, resolved.InsecureTLS)
+			subagentsMgr.SetProviderSettings(resolved.BaseURL, resolved.InsecureTLS)
 		}
 		resolved.MergeExtensionTools(extToolAdapter)
-		injectSwarmSpawn(resolved.ToolRegistry)
+		injectSubagentSpawn(resolved.ToolRegistry)
 		return wireAgentExt(resolved.NewAgent()), resolved.Provider, resolved.Model, nil
 	}
 			return nil, "", "", err
 		}
 		resolved.UseSandbox(sharedSandbox)
-		if swarmMgr != nil {
+		if subagentsMgr != nil {
-			swarmMgr.SetProvider(resolved.Provider)
+			subagentsMgr.SetProvider(resolved.Provider)
-			swarmMgr.SetProviderSettings(resolved.BaseURL, resolved.InsecureTLS)
+			subagentsMgr.SetProviderSettings(resolved.BaseURL, resolved.InsecureTLS)
 		}
 		resolved.MergeExtensionTools(extToolAdapter)
-		injectSwarmSpawn(resolved.ToolRegistry)
+		injectSubagentSpawn(resolved.ToolRegistry)
 		return wireAgentExt(resolved.NewAgent()), resolved.Provider, resolved.Model, nil
 	}
 			return nil, "", "", err
 		}
 		resolved.UseSandbox(sharedSandbox)
-		if swarmMgr != nil {
+		if subagentsMgr != nil {
-			swarmMgr.SetProvider(resolved.Provider)
+			subagentsMgr.SetProvider(resolved.Provider)
-			swarmMgr.SetProviderSettings(resolved.BaseURL, resolved.InsecureTLS)
+			subagentsMgr.SetProviderSettings(resolved.BaseURL, resolved.InsecureTLS)
 		}
 		resolved.MergeExtensionTools(extToolAdapter)
-		injectSwarmSpawn(resolved.ToolRegistry)
+		injectSubagentSpawn(resolved.ToolRegistry)
 		return wireAgentExt(resolved.NewAgent()), resolved.Provider, resolved.Model, nil
 	}
 		if current == nil {
 			return
 		}
-		refreshAgentToolsAndPrompt(args, sharedSandbox, extToolAdapter, current, injectSwarmSpawn)
+		refreshAgentToolsAndPrompt(args, sharedSandbox, extToolAdapter, current, injectSubagentSpawn)
 	})
 	var sess *core.Session
 		}
 		activeProvider = candidate.provider
 		activeModel = candidate.model
-		if swarmMgr != nil && candidate.session != nil {
+		if subagentsMgr != nil && candidate.session != nil {
 			// Keep the dashboard scope in the same commit as the session,
 			// agent, usage, and persistence baseline.
-			swarmMgr.SetActiveSession(candidate.session.ID)
+			subagentsMgr.SetActiveSession(candidate.session.ID)
 		}
 		committed = true
 		persistMu.Unlock()
 	//
 	// Steps, in order:
 	//   1. resolve + validate the new path (~ expansion, abs/rel)
-	//   2. stage the candidate cwd, sandbox, and swarm state
+	//   2. stage the candidate cwd, sandbox, and subagent state
 	//   3. rebuild the agent and allocate its new session
 	//   4. commit all new state together, closing the old session last
 	//   5. push the committed state into the running Interactive
 		// Stage the candidate state while retaining a complete rollback
 		// snapshot. A failed rebuild or session allocation must leave the
-		// current agent, session, sandbox, and swarm root usable.
+		// current agent, session, sandbox, and subagent root usable.
 		oldCWD := args.CWD
 		oldResolvedCWD := r.CWD
 		oldPermissionSet := args.PermissionSet
 		oldActiveProvider := activeProvider
 		oldActiveModel := activeModel
 		persistMu.Unlock()
-		oldSwarmRoot := ""
+		oldSupervisorRoot := ""
-		if swarmMgr != nil {
+		if subagentsMgr != nil {
-			oldSwarmRoot = swarmMgr.RepoRoot()
+			oldSupervisorRoot = subagentsMgr.RepoRoot()
 		}
 		oldSandboxRoot := ""
 		oldSandboxLocked := false
 			activeProvider = oldActiveProvider
 			activeModel = oldActiveModel
 			persistMu.Unlock()
-			if swarmMgr != nil {
+			if subagentsMgr != nil {
-				swarmMgr.SetRepoRoot(oldSwarmRoot)
+				subagentsMgr.SetRepoRoot(oldSupervisorRoot)
 			}
 			if sharedSandbox != nil {
 				sharedSandbox.Root = oldSandboxRoot
 		args.CWD = absPath
 		r.CWD = absPath
-		if swarmMgr != nil {
+		if subagentsMgr != nil {
-			swarmMgr.SetRepoRoot(absPath)
+			subagentsMgr.SetRepoRoot(absPath)
 		}
 		if args.PermissionSet != nil {
 			expanded := args.PermissionSet.Expand(absPath, args.AgentDataDir)
 			iv.ApplyChangedCWDWithStartupContext(newAg, newProvider, newModel, absPath, startupPaths)
 		}
-		// Re-scope the swarm dashboard to the new session.
+		// Re-scope the subagent dashboard to the new session.
-		if swarmMgr != nil && newSess != nil {
+		if subagentsMgr != nil && newSess != nil {
-			swarmMgr.SetActiveSession(newSess.ID)
+			subagentsMgr.SetActiveSession(newSess.ID)
 		}
 		if newSess != nil {
 			extMgr.EmitSessionEvent("session_opened", sessionContext(newSess), newStates)
 		}
 	}
-	// swarmMgr was constructed and reloaded earlier (before the agent
+	// subagentsMgr was constructed and reloaded earlier (before the agent
-	// build, so the auto-swarm tool could capture it). Here we just
+	// build, so the auto-subagents tool could capture it). Here we just
-	// scope the dashboard to the active host session so /swarm only
+	// scope the dashboard to the active host session so /subagents only
 	// shows agents this session spawned (and any pre-upgrade unscoped
 	// agents — see SnapshotAll docs). Updated again whenever the
 	// user swaps sessions via loadSession below.
-	if sess != nil && swarmMgr != nil {
+	if sess != nil && subagentsMgr != nil {
-		swarmMgr.SetActiveSession(sess.ID)
+		subagentsMgr.SetActiveSession(sess.ID)
 	}
 	// Best-effort shutdown on interactive exit: stop all running
 	// agents so they don't outlive their parent zot.
-	if swarmMgr != nil {
+	if subagentsMgr != nil {
-		defer swarmMgr.StopAll()
+		defer subagentsMgr.StopAll()
 	}
 	var startupSkills []*skills.Skill
 	homeDir, _ := os.UserHomeDir()
 	discoveredSubagents, _ := subagents.Discover(r.CWD, homeDir)
 	subagentsAddendum := subagents.SystemPromptAddendum(discoveredSubagents)
-	autoSwarmToolAllowedForSession := autoSwarmToolAllowed(args)
+	autoSubagentsToolAllowedForSession := autoSubagentsToolAllowed(args)
 	iv = modes.NewInteractive(modes.InteractiveConfig{
-		Terminal:                  term,
+		Terminal:                    term,
-		Theme:                     theme,
+		Theme:                       theme,
-		InlineImagesEnabled:       initialCfg.InlineImagesEnabled,
+		InlineImagesEnabled:         initialCfg.InlineImagesEnabled,
-		TerminalAlertsEnabled:     initialCfg.TerminalAlertsEnabled,
+		TerminalAlertsEnabled:       initialCfg.TerminalAlertsEnabled,
-		TerminalTitleEnabled:      initialCfg.TerminalTitleEnabled,
+		TerminalTitleEnabled:        initialCfg.TerminalTitleEnabled,
-		AutoSwarmEnabled:          initialCfg.AutoSwarmEnabled,
+		AutoSubagentsEnabled:        initialCfg.AutoSubagentsEnabled,
-		AutoSwarmToolAllowed:      &autoSwarmToolAllowedForSession,
+		AutoSubagentsToolAllowed:    &autoSubagentsToolAllowedForSession,
-		FastMode:                  &fastMode,
+		FastMode:                    &fastMode,
-		LSPEnabled:                initialCfg.LSPEnabled,
+		LSPEnabled:                  initialCfg.LSPEnabled,
-		SubagentLSPEnabled:        initialCfg.SubagentLSPEnabled,
+		SubagentLSPEnabled:          initialCfg.SubagentLSPEnabled,
-		AutoCompactThreshold:      initialCfg.AutoCompactThreshold,
+		AutoCompactThreshold:        initialCfg.AutoCompactThreshold,
-		JailByDefault:             initialCfg.JailByDefault,
+		JailByDefault:               initialCfg.JailByDefault,
-		QuickModelShortcuts:       quickModelShortcuts,
+		QuickModelShortcuts:         quickModelShortcuts,
-		RecursiveFileSuggest:      initialCfg.RecursiveFileSuggest,
+		RecursiveFileSuggest:        initialCfg.RecursiveFileSuggest,
-		RespectGitignore:          initialCfg.RespectGitignore,
+		RespectGitignore:            initialCfg.RespectGitignore,
-		CompactMode:               initialCfg.CompactMode,
+		CompactMode:                 initialCfg.CompactMode,
-		TUIInputStyle:             initialCfg.TUIInputStyle,
+		TUIInputStyle:               initialCfg.TUIInputStyle,
-		TUIStatusPosition:         initialCfg.TUIStatusPosition,
+		TUIStatusPosition:           initialCfg.TUIStatusPosition,
-		TUIWorkingPosition:        initialCfg.TUIWorkingPosition,
+		TUIWorkingPosition:          initialCfg.TUIWorkingPosition,
-		ThemeName:                 initialCfg.Theme,
+		ThemeName:                   initialCfg.Theme,
-		FlatTools:                 initialCfg.FlatToolRender(),
+		FlatTools:                   initialCfg.FlatToolRender(),
-		CompactUser:               initialCfg.CompactUserInput(),
+		CompactUser:                 initialCfg.CompactUserInput(),
-		ExtensionThemes:           extMgr.ThemeOptions,
+		ExtensionThemes:             extMgr.ThemeOptions,
-		AutoSwarmSystemAddendum:   AutoSwarmSystemAddendum,
+		AutoSubagentsSystemAddendum: AutoSubagentsSystemAddendum,
-		SubagentsSystemAddendum:   subagentsAddendum,
+		SubagentsSystemAddendum:     subagentsAddendum,
-		SettingsStore:             configSettingsStore{},
+		SettingsStore:               configSettingsStore{},
-		Model:                     r.Model,
+		Model:                       r.Model,
-		Provider:                  r.Provider,
+		Provider:                    r.Provider,
-		AuthMethod:                r.AuthMethod,
+		AuthMethod:                  r.AuthMethod,
-		BaseURL:                   r.BaseURL,
+		BaseURL:                     r.BaseURL,
-		Reasoning:                 r.Reasoning,
+		Reasoning:                   r.Reasoning,
-		SystemPrompt:              r.SystemPrompt,
+		SystemPrompt:                r.SystemPrompt,
-		Tools:                     r.ToolRegistry,
+		Tools:                       r.ToolRegistry,
-		MaxSteps:                  r.MaxSteps,
+		MaxSteps:                    r.MaxSteps,
-		CWD:                       r.CWD,
+		CWD:                         r.CWD,
-		StartupAgentName:          args.AgentName,
+		StartupAgentName:            args.AgentName,
-		StartupContextPaths:       instructionContextPaths(r.ContextFiles),
+		StartupContextPaths:         instructionContextPaths(r.ContextFiles),
-		StartupExtensionNames:     startupExtensionNames(extMgr.All()),
+		StartupExtensionNames:       startupExtensionNames(extMgr.All()),
-		StartupExtensionErrors:    startupExtensionErrors,
+		StartupExtensionErrors:      startupExtensionErrors,
-		StartupSkillNames:         startupSkillNames(startupSkills),
+		StartupSkillNames:           startupSkillNames(startupSkills),
-		ShowInstructionsAtStartup: initialCfg.ShowInstructionsAtStartup,
+		ShowInstructionsAtStartup:   initialCfg.ShowInstructionsAtStartup,
-		ZotHome:                   ZotHome(),
+		ZotHome:                     ZotHome(),
-		SessionsRoot:              agentSessionsRoot(ZotHome(), args),
+		SessionsRoot:                agentSessionsRoot(ZotHome(), args),
-		Version:                   version,
+		Version:                     version,
-		UpdateInfoChan:            updateCh,
+		UpdateInfoChan:              updateCh,
-		Sandbox:                   sharedSandbox,
+		Sandbox:                     sharedSandbox,
-		Agent:                     ag,
+		Agent:                       ag,
 		InitialSessionTitle: func() string {
 			if sess == nil || sessionTitlePending {
 				return ""
 				_ = extMgr.Reload(context.Background(), 2*time.Second)
 			}
 			if current != nil {
-				refreshAgentToolsAndPrompt(args, sharedSandbox, extToolAdapter, current, injectSwarmSpawn)
+				refreshAgentToolsAndPrompt(args, sharedSandbox, extToolAdapter, current, injectSubagentSpawn)
 			}
 		},
 		RefreshTools: func() {
 			current := liveInteractiveAgent(iv, ag)
-			refreshAgentToolsAndPrompt(args, sharedSandbox, extToolAdapter, current, injectSwarmSpawn)
+			refreshAgentToolsAndPrompt(args, sharedSandbox, extToolAdapter, current, injectSubagentSpawn)
 		},
 		AuthManager:                mgr,
 		LlamaCPPConfig:             ResolveLlamaCPPConfig,
 		},
 		SessionTransition: newSessionTransition(&sessionTransitionMu),
 		Extensions:        extMgr,
-		Swarm:             swarmMgr,
+		Supervisor:        subagentsMgr,
 		ResolveSubagent:   resolveSubagent,
 		ChangelogChan:     changelogCh,
 		OnChangelogDismiss: func() {
 		// cleanup, so relying only on the normal runInteractive defer would
 		// leave child daemons (and their descendants) alive after a TERM or
 		// HUP delivered to the host.
-		if swarmMgr != nil {
+		if subagentsMgr != nil {
-			swarmMgr.StopAll()
+			subagentsMgr.StopAll()
 		}
 		// Exit cleanly. Re-raising the signal would skip os.Exit's
 		// at-exit hooks; explicit exit is fine because we've already
 	switch {
 	case args.Session != "":
 		s, msgs, err = core.OpenSession(args.Session)
-		// The swarm-agent child passes a fixed --session path that
+		// The subagent-worker child passes a fixed --session path that
 		// may not exist yet on first Spawn. Treat ENOENT as "create
 		// a fresh session AT THIS PATH" so the conversation actually
-		// gets persisted; without this fallback the swarm child runs
+		// gets persisted; without this fallback the subagent child runs
 		// with sess==nil and every Resume re-starts with no memory
 		// of the prior turns. Other openers (--continue / --resume /
 		// the picker) never see ENOENT here because they only choose

M packages/agent/config.go +5 -5


@@ -90,17 +90,17 @@ type Config struct {
90		// Subagents controls manager-owned child lifecycle and resource policy.	90		// Subagents controls manager-owned child lifecycle and resource policy.
91		Subagents SubagentsConfig `json:"subagents,omitempty"`	91		Subagents SubagentsConfig `json:"subagents,omitempty"`
92			92
93	-	// AutoSwarmEnabled lets the main agent spawn background sub-agents	93	+	// AutoSubagentsEnabled lets the main agent spawn background sub-agents
94	-	// for parallel sub-tasks via a built-in swarm_spawn tool. Off by	94	+	// for parallel sub-tasks via a built-in subagent_spawn tool. Off by
95		// default; nil/missing means disabled. Toggle from /settings.	95		// default; nil/missing means disabled. Toggle from /settings.
96	-	AutoSwarmEnabled *bool `json:"auto_swarm_enabled,omitempty"`	96	+	AutoSubagentsEnabled *bool `json:"auto_subagents_enabled,omitempty"`
97			97
98		// LSPEnabled controls the built-in lsp tool and write-time diagnostics	98		// LSPEnabled controls the built-in lsp tool and write-time diagnostics
99		// for the main session. nil/missing means enabled. Toggle from	99		// for the main session. nil/missing means enabled. Toggle from
100		// /settings.	100		// /settings.
101		LSPEnabled *bool `json:"lsp_enabled,omitempty"`	101		LSPEnabled *bool `json:"lsp_enabled,omitempty"`
102			102
103	-	// SubagentLSPEnabled controls LSP availability in swarm sub-agent	103	+	// SubagentLSPEnabled controls LSP availability in subagent worker
104		// processes. nil/missing means enabled. Toggle from /settings.	104		// processes. nil/missing means enabled. Toggle from /settings.
105		SubagentLSPEnabled *bool `json:"subagent_lsp_enabled,omitempty"`	105		SubagentLSPEnabled *bool `json:"subagent_lsp_enabled,omitempty"`
106			106

@@ -235,7 +235,7 @@ func (c Config) CompactUserInput() bool {
235		return c.CompactInput != nil && *c.CompactInput	235		return c.CompactInput != nil && *c.CompactInput
236		}	236		}
237			237
238	-	// LSPEnabledFor reports whether LSP is enabled for a main or swarm	238	+	// LSPEnabledFor reports whether LSP is enabled for a main or subagent
239		// sub-agent session. Both settings default to true so new installations	239		// sub-agent session. Both settings default to true so new installations
240		// get code intelligence without a migration or generated config file.	240		// get code intelligence without a migration or generated config file.
241		func (c Config) LSPEnabledFor(subagent bool) bool {	241		func (c Config) LSPEnabledFor(subagent bool) bool {

R packages/agent/modes/auto_swarm_test.go → packages/agent/modes/auto_subagents_test.go +40 -40 renamed, 58% similar


@@ -7,64 +7,64 @@ import (
7		"testing"	7		"testing"
8		"time"	8		"time"
9			9
10	-	"github.com/patriceckhart/zot/packages/agent/swarm"	10	+	"github.com/patriceckhart/zot/packages/agent/subagents"
11		"github.com/patriceckhart/zot/packages/core"	11		"github.com/patriceckhart/zot/packages/core"
12		)	12		)
13			13
14	-	func TestAutoSwarmSystemPromptTogglesProfileManifestWithDelegationGuidance(t *testing.T) {	14	+	func TestAutoSubagentsSystemPromptTogglesProfileManifestWithDelegationGuidance(t *testing.T) {
15		iv := &Interactive{	15		iv := &Interactive{
16		agent: &core.Agent{System: "base system"},	16		agent: &core.Agent{System: "base system"},
17		cfg: InteractiveConfig{	17		cfg: InteractiveConfig{
18	-	AutoSwarmSystemAddendum: "auto-swarm guidance",	18	+	AutoSubagentsSystemAddendum: "auto-subagents guidance",
19	-	SubagentsSystemAddendum: "[subagents_list]\n- reviewer\n[/subagents_list]",	19	+	SubagentsSystemAddendum: "[subagents_list]\n- reviewer\n[/subagents_list]",
20		},	20		},
21		}	21		}
22			22
23	-	iv.applyAutoSwarmSystemPrompt(true)	23	+	iv.applyAutoSubagentsSystemPrompt(true)
24	-	if !strings.Contains(iv.agent.System, "[subagents_list]") \|\| !strings.Contains(iv.agent.System, "auto-swarm guidance") {	24	+	if !strings.Contains(iv.agent.System, "[subagents_list]") \|\| !strings.Contains(iv.agent.System, "auto-subagents guidance") {
25	-	t.Fatalf("enabled system prompt missing swarm blocks: %q", iv.agent.System)	25	+	t.Fatalf("enabled system prompt missing subagent blocks: %q", iv.agent.System)
26		}	26		}
27		before := iv.agent.System	27		before := iv.agent.System
28	-	iv.applyAutoSwarmSystemPrompt(true)	28	+	iv.applyAutoSubagentsSystemPrompt(true)
29		if iv.agent.System != before {	29		if iv.agent.System != before {
30		t.Fatalf("enabling twice changed system prompt: %q -> %q", before, iv.agent.System)	30		t.Fatalf("enabling twice changed system prompt: %q -> %q", before, iv.agent.System)
31		}	31		}
32			32
33	-	iv.applyAutoSwarmSystemPrompt(false)	33	+	iv.applyAutoSubagentsSystemPrompt(false)
34	-	if strings.Contains(iv.agent.System, "[subagents_list]") \|\| strings.Contains(iv.agent.System, "auto-swarm guidance") {	34	+	if strings.Contains(iv.agent.System, "[subagents_list]") \|\| strings.Contains(iv.agent.System, "auto-subagents guidance") {
35	-	t.Fatalf("disabled system prompt retained swarm blocks: %q", iv.agent.System)	35	+	t.Fatalf("disabled system prompt retained subagent blocks: %q", iv.agent.System)
36		}	36		}
37		}	37		}
38			38
39	-	func TestAutoSwarmTogglePreservesMatchingBasePromptBlocks(t *testing.T) {	39	+	func TestAutoSubagentsTogglePreservesMatchingBasePromptBlocks(t *testing.T) {
40		manifest := "[subagents_list]\n- reviewer\n[/subagents_list]"	40		manifest := "[subagents_list]\n- reviewer\n[/subagents_list]"
41	-	guidance := "auto-swarm guidance"	41	+	guidance := "auto-subagents guidance"
42		base := "base system\n\n" + manifest + "\n\n" + guidance	42		base := "base system\n\n" + manifest + "\n\n" + guidance
43		iv := &Interactive{	43		iv := &Interactive{
44		agent: &core.Agent{System: base},	44		agent: &core.Agent{System: base},
45		cfg: InteractiveConfig{	45		cfg: InteractiveConfig{
46	-	AutoSwarmSystemAddendum: guidance,	46	+	AutoSubagentsSystemAddendum: guidance,
47	-	SubagentsSystemAddendum: manifest,	47	+	SubagentsSystemAddendum: manifest,
48		},	48		},
49		}	49		}
50			50
51	-	iv.applyAutoSwarmSystemPrompt(true)	51	+	iv.applyAutoSubagentsSystemPrompt(true)
52		if strings.Count(iv.agent.System, manifest) != 2 \|\| strings.Count(iv.agent.System, guidance) != 2 {	52		if strings.Count(iv.agent.System, manifest) != 2 \|\| strings.Count(iv.agent.System, guidance) != 2 {
53		t.Fatalf("enabling should append owned duplicate blocks: %q", iv.agent.System)	53		t.Fatalf("enabling should append owned duplicate blocks: %q", iv.agent.System)
54		}	54		}
55	-	iv.applyAutoSwarmSystemPrompt(false)	55	+	iv.applyAutoSubagentsSystemPrompt(false)
56		if got := strings.TrimSpace(iv.agent.System); got != base {	56		if got := strings.TrimSpace(iv.agent.System); got != base {
57		t.Fatalf("disabling changed matching base prompt: %q; want %q", got, base)	57		t.Fatalf("disabling changed matching base prompt: %q; want %q", got, base)
58		}	58		}
59		}	59		}
60			60
61	-	func TestAutoSwarmSummaryIncludesCompleteFinalResponseAfterLongTask(t *testing.T) {	61	+	func TestAutoSubagentsSummaryIncludesCompleteFinalResponseAfterLongTask(t *testing.T) {
62		response := "first response line\n" + strings.Repeat("result ", 150) + "final marker"	62		response := "first response line\n" + strings.Repeat("result ", 150) + "final marker"
63	-	mgr := swarm.New(swarm.Config{	63	+	mgr := subagents.New(subagents.Config{
64		Root: t.TempDir(),	64		Root: t.TempDir(),
65		RepoRoot: t.TempDir(),	65		RepoRoot: t.TempDir(),
66	-	NewRunner: func(*swarm.Agent) swarm.Runner {	66	+	NewRunner: func(*subagents.Agent) subagents.Runner {
67	-	return swarm.RunnerFunc(func(_ context.Context, sink swarm.Sink) error {	67	+	return subagents.RunnerFunc(func(_ context.Context, sink subagents.Sink) error {
68		sink.Transcript(response)	68		sink.Transcript(response)
69		return nil	69		return nil
70		})	70		})

@@ -75,20 +75,20 @@ func TestAutoSwarmSummaryIncludesCompleteFinalResponseAfterLongTask(t *testing.T
75		t.Fatal(err)	75		t.Fatal(err)
76		}	76		}
77			77
78	-	iv := newQueuedAutoSwarmInteractive()	78	+	iv := newQueuedAutoSubagentsInteractive()
79	-	iv.TrackSwarmAgent(a, a.Task)	79	+	iv.TrackSubagentWorker(a, a.Task)
80		update := waitForQueuedPrompt(t, iv)	80		update := waitForQueuedPrompt(t, iv)
81		if !strings.Contains(update, "final response:\n"+response) {	81		if !strings.Contains(update, "final response:\n"+response) {
82		t.Fatalf("update missing complete final response: %q", update)	82		t.Fatalf("update missing complete final response: %q", update)
83		}	83		}
84		}	84		}
85			85
86	-	func TestTrackSwarmAgentReportsStartupFailure(t *testing.T) {	86	+	func TestTrackSubagentWorkerReportsStartupFailure(t *testing.T) {
87	-	mgr := swarm.New(swarm.Config{	87	+	mgr := subagents.New(subagents.Config{
88		Root: t.TempDir(),	88		Root: t.TempDir(),
89		RepoRoot: t.TempDir(),	89		RepoRoot: t.TempDir(),
90	-	NewRunner: func(*swarm.Agent) swarm.Runner {	90	+	NewRunner: func(*subagents.Agent) subagents.Runner {
91	-	return swarm.RunnerFunc(func(context.Context, swarm.Sink) error {	91	+	return subagents.RunnerFunc(func(context.Context, subagents.Sink) error {
92		return errors.New("listener startup failed")	92		return errors.New("listener startup failed")
93		})	93		})
94		},	94		},

@@ -98,8 +98,8 @@ func TestTrackSwarmAgentReportsStartupFailure(t *testing.T) {
98		t.Fatal(err)	98		t.Fatal(err)
99		}	99		}
100			100
101	-	iv := newQueuedAutoSwarmInteractive()	101	+	iv := newQueuedAutoSubagentsInteractive()
102	-	iv.TrackSwarmAgent(a, a.Task)	102	+	iv.TrackSubagentWorker(a, a.Task)
103			103
104		update := waitForQueuedPrompt(t, iv)	104		update := waitForQueuedPrompt(t, iv)
105		if !strings.Contains(update, "status: failed") {	105		if !strings.Contains(update, "status: failed") {

@@ -110,13 +110,13 @@ func TestTrackSwarmAgentReportsStartupFailure(t *testing.T) {
110		}	110		}
111		}	111		}
112			112
113	-	func TestCompleteSwarmWatchReportsTurnOutcomeOnce(t *testing.T) {	113	+	func TestCompleteSupervisorWatchReportsTurnOutcomeOnce(t *testing.T) {
114		started := make(chan struct{})	114		started := make(chan struct{})
115	-	mgr := swarm.New(swarm.Config{	115	+	mgr := subagents.New(subagents.Config{
116		Root: t.TempDir(),	116		Root: t.TempDir(),
117		RepoRoot: t.TempDir(),	117		RepoRoot: t.TempDir(),
118	-	NewRunner: func(*swarm.Agent) swarm.Runner {	118	+	NewRunner: func(*subagents.Agent) subagents.Runner {
119	-	return swarm.RunnerFunc(func(ctx context.Context, _ swarm.Sink) error {	119	+	return subagents.RunnerFunc(func(ctx context.Context, _ subagents.Sink) error {
120		close(started)	120		close(started)
121		<-ctx.Done()	121		<-ctx.Done()
122		return ctx.Err()	122		return ctx.Err()

@@ -133,11 +133,11 @@ func TestCompleteSwarmWatchReportsTurnOutcomeOnce(t *testing.T) {
133		a.Wait()	133		a.Wait()
134		})	134		})
135			135
136	-	iv := newQueuedAutoSwarmInteractive()	136	+	iv := newQueuedAutoSubagentsInteractive()
137	-	entry := &swarmWatchEntry{agent: a, task: a.Task}	137	+	entry := &subagentWatchEntry{agent: a, task: a.Task}
138	-	iv.swarmWatch = []*swarmWatchEntry{entry}	138	+	iv.subagentWatch = []*subagentWatchEntry{entry}
139	-	iv.completeSwarmWatchEntry(entry, "completed", "")	139	+	iv.completeSupervisorWatchEntry(entry, "completed", "")
140	-	iv.completeSwarmWatchEntry(entry, "failed", "late error")	140	+	iv.completeSupervisorWatchEntry(entry, "failed", "late error")
141			141
142		update := waitForQueuedPrompt(t, iv)	142		update := waitForQueuedPrompt(t, iv)
143		if !strings.Contains(update, "status: completed") {	143		if !strings.Contains(update, "status: completed") {

@@ -151,7 +151,7 @@ func TestCompleteSwarmWatchReportsTurnOutcomeOnce(t *testing.T) {
151		}	151		}
152		}	152		}
153			153
154	-	func newQueuedAutoSwarmInteractive() *Interactive {	154	+	func newQueuedAutoSubagentsInteractive() *Interactive {
155		return &Interactive{	155		return &Interactive{
156		agent: &core.Agent{},	156		agent: &core.Agent{},
157		busy: true,	157		busy: true,

@@ -176,7 +176,7 @@ func waitForQueuedPrompt(t testing.T, iv Interactive) string {
176		iv.mu.Unlock()	176		iv.mu.Unlock()
177		select {	177		select {
178		case <-deadline.C:	178		case <-deadline.C:
179	-	t.Fatal("timed out waiting for auto-swarm update")	179	+	t.Fatal("timed out waiting for auto-subagents update")
180		case <-ticker.C:	180		case <-ticker.C:
181		}	181		}
182		}	182		}

M packages/agent/modes/dialog_text_test.go +7 -7


@@ -6,7 +6,7 @@ import (
6			6
7		"github.com/mattn/go-runewidth"	7		"github.com/mattn/go-runewidth"
8			8
9	-	"github.com/patriceckhart/zot/packages/agent/swarm"	9	+	"github.com/patriceckhart/zot/packages/agent/subagents"
10		"github.com/patriceckhart/zot/packages/tui"	10		"github.com/patriceckhart/zot/packages/tui"
11		)	11		)
12			12

@@ -47,10 +47,10 @@ func TestBtwDialogWrapsAssistantAndKeepsCursorAligned(t *testing.T) {
47		}	47		}
48		}	48		}
49			49
50	-	func TestSwarmTranscriptWrapsAssistantAndDiagnosticRows(t *testing.T) {	50	+	func TestSupervisorTranscriptWrapsAssistantAndDiagnosticRows(t *testing.T) {
51		const width = 80	51		const width = 80
52		long := strings.Repeat("long response text ", 8)	52		long := strings.Repeat("long response text ", 8)
53	-	rows := renderSwarmTranscriptBlocks([]string{	53	+	rows := renderSupervisorTranscriptBlocks([]string{
54		long,	54		long,
55		"stderr: " + long,	55		"stderr: " + long,
56		"error: " + long,	56		"error: " + long,

@@ -65,15 +65,15 @@ func TestSwarmTranscriptWrapsAssistantAndDiagnosticRows(t *testing.T) {
65		}	65		}
66		}	66		}
67			67
68	-	func TestSwarmDialogViewingWrapsSpawnedAgentResponse(t *testing.T) {	68	+	func TestSubagentsDialogViewingWrapsSpawnedAgentResponse(t *testing.T) {
69		const width = 80	69		const width = 80
70		response := strings.Repeat("spawned agent response ", 6)	70		response := strings.Repeat("spawned agent response ", 6)
71	-	rows := []swarm.AgentSnapshot{{	71	+	rows := []subagents.AgentSnapshot{{
72		ID: "agent-1",	72		ID: "agent-1",
73	-	Status: swarm.StatusDone,	73	+	Status: subagents.StatusDone,
74		Lines: []string{response},	74		Lines: []string{response},
75		}}	75		}}
76	-	d := newSwarmDialog()	76	+	d := newSubagentsDialog()
77		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")	77		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")
78		_ = d.Render(tui.Theme{}, width)	78		_ = d.Render(tui.Theme{}, width)
79		d.HandleKey(tui.Key{Kind: tui.KeyEnter})	79		d.HandleKey(tui.Key{Kind: tui.KeyEnter})

M packages/agent/modes/double_escape.go +1 -1


@@ -79,7 +79,7 @@ func (i *Interactive) sessionTreeEscapeBlocked() bool {
79		i.llamaDialog != nil && i.llamaDialog.Active() \|\|	79		i.llamaDialog != nil && i.llamaDialog.Active() \|\|
80		i.rescueDialog != nil && i.rescueDialog.Active() \|\|	80		i.rescueDialog != nil && i.rescueDialog.Active() \|\|
81		i.sessionDialog != nil && i.sessionDialog.Active() \|\|	81		i.sessionDialog != nil && i.sessionDialog.Active() \|\|
82	-	i.swarmDialog != nil && i.swarmDialog.Active() \|\|	82	+	i.subagentsDialog != nil && i.subagentsDialog.Active() \|\|
83		i.jumpDialog != nil && i.jumpDialog.Active() \|\|	83		i.jumpDialog != nil && i.jumpDialog.Active() \|\|
84		i.btwDialog != nil && i.btwDialog.Active() \|\|	84		i.btwDialog != nil && i.btwDialog.Active() \|\|
85		i.skillsDialog != nil && i.skillsDialog.Active() \|\|	85		i.skillsDialog != nil && i.skillsDialog.Active() \|\|

M packages/agent/modes/interactive.go +133 -138

 	"github.com/patriceckhart/zot/packages/agent/modes/telegram"
 	"github.com/patriceckhart/zot/packages/agent/skills"
 	"github.com/patriceckhart/zot/packages/agent/subagents"
-	"github.com/patriceckhart/zot/packages/agent/swarm"
 	"github.com/patriceckhart/zot/packages/agent/tools"
 	"github.com/patriceckhart/zot/packages/core"
 	"github.com/patriceckhart/zot/packages/provider"
 	// title updates. nil means enabled; false disables both.
 	TerminalTitleEnabled *bool
-	// AutoSwarmEnabled mirrors the persisted config flag at startup so
+	// AutoSubagentsEnabled mirrors the persisted config flag at startup so
 	// the /settings dialog can render the current state without
 	// re-reading config.json on every open.
-	AutoSwarmEnabled *bool
+	AutoSubagentsEnabled *bool
-	// AutoSwarmToolAllowed is nil for normal sessions and false when the
+	// AutoSubagentsToolAllowed is nil for normal sessions and false when the
 	// launch-time --no-tools/--tools policy excludes delegation.
-	AutoSwarmToolAllowed *bool
+	AutoSubagentsToolAllowed *bool
 	// FastMode mirrors the persisted OpenAI fast-mode flag at startup.
 	// nil/missing means disabled. Unsupported providers reject attempts
 	// enabled by default.
 	LSPEnabled *bool
-	// SubagentLSPEnabled controls whether newly spawned swarm children
+	// SubagentLSPEnabled controls whether newly spawned subagent children
 	// receive the lsp tool. nil means enabled by default.
 	SubagentLSPEnabled *bool
 	// ExtensionThemes returns themes bundled with loaded extensions.
 	ExtensionThemes func() []tui.ThemeOption
-	// AutoSwarmSystemAddendum is the system-prompt block that gets
+	// AutoSubagentsSystemAddendum is the system-prompt block that gets
-	// appended/stripped when the user toggles auto-swarm at runtime.
+	// appended/stripped when the user toggles auto-subagents at runtime.
 	// Plumbed in from the cli so this package doesn't have to import
 	// agent (cycle).
-	AutoSwarmSystemAddendum string
+	AutoSubagentsSystemAddendum string
 	// SubagentsSystemAddendum is the metadata-only [subagents_list]
-	// block that is added or removed together with auto-swarm.
+	// block that is added or removed together with auto-subagents.
 	SubagentsSystemAddendum string
 	SettingsStore           SettingsStore
 	// AFTER the built-in catalog so a built-in name always wins.
 	Extensions *extensions.Manager
-	// Swarm, if non-nil, enables the /swarm slash command and the
+	// Supervisor, if non-nil, enables the /subagents slash command and the
-	// dashboard dialog. The cli constructs the Swarm once per
+	// dashboard dialog. The cli constructs the Supervisor once per
 	// interactive run and tears it down on exit. nil disables the
 	// feature entirely (used by embedders / tests that don't want
 	// subprocesses).
-	Swarm *swarm.Swarm
+	Supervisor *subagents.Supervisor
 	// ResolveSubagent validates a named markdown profile for direct
-	// /swarm commands. Auto-swarm uses the equivalent callback on its
+	// /subagents commands. Auto-subagents uses the equivalent callback on its
 	// tool; keeping this optional preserves lightweight embedders.
 	ResolveSubagent func(name string) (*subagents.Profile, error)
 type SettingsStore interface {
 	SetQuickModelShortcut(slot int, providerName, model string) error
 	SetInlineImages(enabled bool) error
-	SetAutoSwarm(enabled bool) error
+	SetAutoSubagents(enabled bool) error
 	SetJailByDefault(enabled bool) error
 	SetRecursiveFileSuggest(enabled bool) error
 	SetRespectGitignore(enabled bool) error
 	mu    sync.Mutex
 	agent *core.Agent
-	// managedAutoSwarmAddenda records exact prompt blocks appended by
+	// managedAutoSubagentsAddenda records exact prompt blocks appended by
-	// auto-swarm. Disable only removes these owned occurrences, leaving
+	// auto-subagents. Disable only removes these owned occurrences, leaving
 	// identical text that came from the user's base prompt untouched.
-	managedAutoSwarmAddenda []string
+	managedAutoSubagentsAddenda []string
-	streaming               strings.Builder // what's currently painted on screen
+	streaming                   strings.Builder // what's currently painted on screen
-	streamOn                bool
+	streamOn                    bool
-	pendingAlert            *extproto.AlertRequest
+	pendingAlert                *extproto.AlertRequest
 	// streamPending is the runes buffered after each EvTextDelta that
 	// haven't yet been promoted into `streaming` for rendering. It
 	llamaDialog       *llamaDialog
 	rescueDialog      *rescueDialog
 	sessionDialog     *sessionDialog
-	swarmDialog       *swarmDialog
+	subagentsDialog   *subagentsDialog
 	jumpDialog        *jumpDialog
 	btwDialog         *btwDialog
 	skillsDialog      *skillsDialog
 	extPanel          *extPanelDialog
 	llamaConfigured   bool
-	// swarmWatch tracks auto-swarm sub-agents the main agent spawned
+	// subagentWatch tracks auto-subagents sub-agents the main agent spawned
-	// via swarm_spawn. Each entry holds the agent + the task text;
+	// via subagent_spawn. Each entry holds the agent + the task text;
 	// a per-entry goroutine waits on the agent's terminal state. When
 	// every tracked entry has finished, the watcher flushes a single
 	// summary turn into the main chat (queued if the main agent is
 	// busy, run immediately if idle).
-	swarmWatchMu sync.Mutex
+	subagentWatchMu sync.Mutex
-	swarmWatch   []*swarmWatchEntry
+	subagentWatch   []*subagentWatchEntry
 	// pendingFork is true when the user ran /session fork: the next
 	// jump-picker selection should branch off that message instead
 		llamaDialog:       newLlamaDialog(),
 		rescueDialog:      newRescueDialog(),
 		sessionDialog:     newSessionDialog(),
-		swarmDialog:       newSwarmDialog(),
+		subagentsDialog:   newSubagentsDialog(),
 		jumpDialog:        newJumpDialog(),
 		btwDialog:         newBtwDialog(),
 		skillsDialog:      newSkillsDialog(),
 		baseURL, _, err := cfg.LlamaCPPConfig()
 		i.llamaConfigured = err == nil && baseURL != ""
 	}
-	if cfg.AutoSwarmEnabled != nil && *cfg.AutoSwarmEnabled {
+	if cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {
-		i.managedAutoSwarmAddenda = autoSwarmAddenda(cfg)
+		i.managedAutoSubagentsAddenda = autoSubagentsAddenda(cfg)
 	}
 	if cfg.Agent != nil {
 		i.agent = cfg.Agent
 		i.titleRealPromptSeen = i.sessionTitle != "" || hasRealUserPrompt(i.view.Messages)
 		i.titleGenerationStarted = i.titleRealPromptSeen
 	}
-	if cfg.AutoSwarmEnabled != nil && *cfg.AutoSwarmEnabled {
+	if cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {
-		i.applyAutoSwarmTool(true)
+		i.applyAutoSubagentsTool(true)
 	}
 	return i
 }
 			// blink inside dialogs that host their own editor (btw),
 			// because each frame re-emits hide-cursor + show-cursor.
 			//
-			// The swarm dashboard is also animated: its rows reflect
+			// The subagent dashboard is also animated: its rows reflect
 			// background subprocesses whose activity / age change
 			// without any user input. Without the tick redraw the
 			// dashboard freezes on the snapshot taken when the user
 			// of its inline editors (spawn task or prompt composer)
 			// is active so the cursor blink in those editors works
 			// the same way it does inside btw.
-			if i.busy || i.btwDialog.Loading() || i.swarmDialog.NeedsTickRefresh() {
+			if i.busy || i.btwDialog.Loading() || i.subagentsDialog.NeedsTickRefresh() {
 				requestRedraw()
 			}
 		}
 		}
 		i.sessionDialog.MaxRows = avail
 		dialog = i.sessionDialog.Render(i.cfg.Theme, cols)
-	case i.swarmDialog.Active():
+	case i.subagentsDialog.Active():
-		dialog = i.swarmDialog.Render(i.cfg.Theme, cols)
+		dialog = i.subagentsDialog.Render(i.cfg.Theme, cols)
 	case i.jumpDialog.Active():
 		dialog = i.jumpDialog.Render(i.cfg.Theme, cols)
 	case i.extPanel.Active() && (!i.confirmDialog.Active() || !i.confirmDialog.Focused()):
 		bottom = append(bottom, "")
 	}
 	bottom = append(bottom, dialog...)
-	// The swarm dashboard owns the bottom of the screen while it's
+	// The subagent dashboard owns the bottom of the screen while it's
 	// active: it has its own inline editors for spawn (`n`) and
 	// prompt (`p`), so the main input would be a confusing second
 	// caret. The suggest popup, sliding-in queue, status block, and
 	// main editor are all hidden underneath it. Keystrokes still
-	// reach handleKey — it routes them to swarmDialog.HandleKey
+	// reach handleKey — it routes them to subagentsDialog.HandleKey
 	// before the editor ever sees them — so the only effect of this
 	// branch is visual.
-	if !i.swarmDialog.Active() {
+	if !i.subagentsDialog.Active() {
 		bottom = append(bottom, suggest...)
 		bottom = append(bottom, queue...)
 		lineInput := inputStyle == tui.InputStyleLines
 			cursorCol = c
 		}
 	}
-	if i.swarmDialog.Active() {
+	if i.subagentsDialog.Active() {
-		if r, c := i.swarmDialog.CursorPos(cols); r >= 0 {
+		if r, c := i.subagentsDialog.CursorPos(cols); r >= 0 {
 			cursorRow = dialogLead + r
 			cursorCol = c
 		} else {
 		i.llamaDialog.Active() ||
 		i.rescueDialog.Active() ||
 		i.sessionDialog.Active() ||
-		i.swarmDialog.Active() ||
+		i.subagentsDialog.Active() ||
 		i.jumpDialog.Active() ||
 		i.btwDialog.Active() ||
 		i.skillsDialog.Active() ||
 		i.invalidate()
 		return false
 	}
-	if i.swarmDialog.Active() {
+	if i.subagentsDialog.Active() {
 		if k.Kind == tui.KeyCtrlC {
-			i.swarmDialog.Close()
+			i.subagentsDialog.Close()
 			i.invalidate()
 			return false
 		}
-		_, msg, errMsg := i.swarmDialog.HandleKey(k)
+		_, msg, errMsg := i.subagentsDialog.HandleKey(k)
 		if msg != "" || errMsg != "" {
 			i.mu.Lock()
 			i.statusOK = msg
 	i.agent = ag
 	i.cfg.CWD = cwd
 	i.cfg.SubagentsSystemAddendum = subagentsAddendum
-	if i.autoSwarmEnabled() {
+	if i.autoSubagentsEnabled() {
-		i.managedAutoSwarmAddenda = autoSwarmAddenda(i.cfg)
+		i.managedAutoSubagentsAddenda = autoSubagentsAddenda(i.cfg)
 	} else {
-		i.managedAutoSwarmAddenda = nil
+		i.managedAutoSubagentsAddenda = nil
 	}
 	i.cfg.StartupContextPaths = append([]string(nil), startupContextPaths...)
 	i.view.StartupContextPaths = nil
 	terminalAlerts := terminalAlertsEnabled(i.cfg.TerminalAlertsEnabled)
 	terminalTitles := terminalTitleEnabled(i.cfg.TerminalTitleEnabled)
-	autoSwarm := false
+	autoSubagents := false
-	if i.cfg.AutoSwarmEnabled != nil {
+	if i.cfg.AutoSubagentsEnabled != nil {
-		autoSwarm = *i.cfg.AutoSwarmEnabled
+		autoSubagents = *i.cfg.AutoSubagentsEnabled
 	}
-	autoSwarmDisabled := i.cfg.Swarm == nil
+	autoSubagentsDisabled := i.cfg.Supervisor == nil
-	autoSwarmHint := ""
+	autoSubagentsHint := ""
-	if autoSwarmDisabled {
+	if autoSubagentsDisabled {
-		autoSwarm = false
+		autoSubagents = false
-		autoSwarmHint = "swarm supervisor not available in this mode"
+		autoSubagentsHint = "subagent supervisor not available in this mode"
 	}
 	fastMode := i.cfg.FastMode != nil && *i.cfg.FastMode
 			value: terminalTitles,
 		},
 		{
-			key:      "auto_swarm_enabled",
+			key:      "auto_subagents_enabled",
-			label:    "auto-swarm",
+			label:    "auto-subagents",
 			desc:     "let the agent spawn background sub-agents in parallel via the subagent_spawn tool",
-			value:    autoSwarm,
+			value:    autoSubagents,
-			disabled: autoSwarmDisabled,
+			disabled: autoSubagentsDisabled,
-			hint:     autoSwarmHint,
+			hint:     autoSubagentsHint,
 		},
 		{
 			key:   "fast_mode",
 		i.statusOK = "AI terminal titles " + onOff(value)
 		i.statusErr = ""
 		i.mu.Unlock()
-	case "auto_swarm_enabled":
+	case "auto_subagents_enabled":
 		val := value
-		i.cfg.AutoSwarmEnabled = &val
+		i.cfg.AutoSubagentsEnabled = &val
 		if i.cfg.SettingsStore != nil {
-			if err := i.cfg.SettingsStore.SetAutoSwarm(value); err != nil {
+			if err := i.cfg.SettingsStore.SetAutoSubagents(value); err != nil {
 				i.mu.Lock()
 				i.statusErr = "settings: " + err.Error()
 				i.mu.Unlock()
 				return
 			}
 		}
-		// Add/remove the swarm_spawn tool on the live agent so the
+		// Add/remove the subagent_spawn tool on the live agent so the
 		// model's tools[] list reflects the toggle on the next turn.
 		// Without this the tool stays advertised after a disable and
 		// the model keeps trying to call it.
-		i.applyAutoSwarmTool(value)
+		i.applyAutoSubagentsTool(value)
 		// Also swap the system-prompt addendum in/out so the model
 		// knows to use the tool proactively (or stops referencing it
 		// after a disable).
-		i.applyAutoSwarmSystemPrompt(value)
+		i.applyAutoSubagentsSystemPrompt(value)
 		i.mu.Lock()
-		i.statusOK = "auto-swarm " + onOff(value)
+		i.statusOK = "auto-subagents " + onOff(value)
 		i.statusErr = ""
 		i.mu.Unlock()
 	case "fast_mode":
 		if i.agent != nil {
 			i.agent.SetFastMode(value)
 		}
-		if i.cfg.Swarm != nil {
+		if i.cfg.Supervisor != nil {
-			i.cfg.Swarm.SetFastMode(value)
+			i.cfg.Supervisor.SetFastMode(value)
 		}
 		i.mu.Lock()
 		i.statusOK = "fast mode " + onOff(value)
 // keeps Tab as a literal no-op.
 //
 // Free function (not a method) so the same logic runs against the
-// editor instances owned by btwDialog and swarmDialog without each
+// editor instances owned by btwDialog and subagentsDialog without each
 // dialog needing its own copy.
 func tryPathTabCompleteEditor(ed *tui.Editor, cwd string) bool {
 	if ed == nil {
 			break
 		}
 		i.openSessionOpsDialog()
-	case "/subagents", "/swarm":
+	case "/subagents":
-		i.runSwarm(ctx, parts[1:])
+		i.runSubagents(ctx, parts[1:])
 	default:
 		// Last-resort fallback: try the extension manager. Built-in
 		// cases above always win; this branch only fires for slash
 	// dynamically-registered tools need to be reattached. The apply
 	// helpers are no-ops when their feature is inactive, so the
 	// cross-provider path still works on a vanilla setup.
-	i.applyAutoSwarmTool(i.autoSwarmEnabled())
+	i.applyAutoSubagentsTool(i.autoSubagentsEnabled())
 	i.applyTelegramTools(i.telegramBridge != nil && i.telegramBridge.Active())
 	if i.cfg.PersistModel != nil {
 		i.cfg.PersistModel(p, md)
 			if oldAgent != nil {
 				_ = tools.CloseLSPManagers(oldAgent.Tools)
 			}
-			i.applyAutoSwarmTool(i.autoSwarmEnabled())
+			i.applyAutoSubagentsTool(i.autoSubagentsEnabled())
 			i.applyTelegramTools(i.telegramBridge != nil && i.telegramBridge.Active())
 			// Authentication can change the provider used by the live
 			// agent. Persist it on the active session just like /model.
 	return a.bridge != nil && a.bridge.Active()
 }
-// swarmWatchEntry is one tracked auto-swarm sub-agent. It records the
+// subagentWatchEntry is one tracked auto-subagents sub-agent. It records the
 // delegated turn's outcome separately from the long-lived daemon status.
-type swarmWatchEntry struct {
+type subagentWatchEntry struct {
-	agent   *swarm.Agent
+	agent   *subagents.Agent
 	task    string
 	done    bool
 	outcome string
 	err     string
 }
-// TrackSwarmAgent is the exported entry point used by the cli to
+// TrackSubagentWorker is the exported entry point used by the cli to
-// hand a freshly-spawned auto-swarm agent off to the watcher.
+// hand a freshly-spawned auto-subagents agent off to the watcher.
-func (i *Interactive) TrackSwarmAgent(a *swarm.Agent, task string) {
+func (i *Interactive) TrackSubagentWorker(a *subagents.Agent, task string) {
-	i.trackSwarmAgent(a, task)
+	i.trackSubagentWorker(a, task)
 }
-// trackSwarmAgent records a freshly-spawned auto-swarm agent and
+// trackSubagentWorker records a freshly-spawned auto-subagents agent and
 // subscribes to both ways its delegated task can finish. Successful
 // long-lived agents report a prompt-level turn_end and keep listening;
 // startup failures and unexpected daemon exits only unblock Agent.Wait.
 // Whichever signal arrives first completes the entry exactly once.
 //
-// Wired in from cli.go via SwarmSpawnTool.OnSpawned only when auto-
+// Wired in from cli.go via SubagentSpawnTool.OnSpawned only when auto-
-// swarm is enabled, so this is a no-op when the feature is off.
+// subagent is enabled, so this is a no-op when the feature is off.
-func (i *Interactive) trackSwarmAgent(a *swarm.Agent, task string) {
+func (i *Interactive) trackSubagentWorker(a *subagents.Agent, task string) {
 	if i == nil || a == nil {
 		return
 	}
-	entry := &swarmWatchEntry{agent: a, task: task}
+	entry := &subagentWatchEntry{agent: a, task: task}
-	i.swarmWatchMu.Lock()
+	i.subagentWatchMu.Lock()
-	i.swarmWatch = append(i.swarmWatch, entry)
+	i.subagentWatch = append(i.subagentWatch, entry)
-	i.swarmWatchMu.Unlock()
+	i.subagentWatchMu.Unlock()
 	a.SetOnTurnEnd(func(step int, errMsg string) {
 		outcome := "completed"
 		if errMsg != "" {
 			outcome = "failed"
 		}
-		i.completeSwarmWatchEntry(entry, outcome, errMsg)
+		i.completeSupervisorWatchEntry(entry, outcome, errMsg)
 	})
 	go func() {
 		a.Wait()
 		snap := a.Snapshot()
 		outcome := string(snap.Status)
-		if snap.Status == swarm.StatusDone {
+		if snap.Status == subagents.StatusDone {
 			outcome = "completed"
 		}
-		i.completeSwarmWatchEntry(entry, outcome, snap.Err)
+		i.completeSupervisorWatchEntry(entry, outcome, snap.Err)
 	}()
 }
-func (i *Interactive) completeSwarmWatchEntry(entry *swarmWatchEntry, outcome, errMsg string) {
+func (i *Interactive) completeSupervisorWatchEntry(entry *subagentWatchEntry, outcome, errMsg string) {
-	i.swarmWatchMu.Lock()
+	i.subagentWatchMu.Lock()
 	if entry.done {
-		i.swarmWatchMu.Unlock()
+		i.subagentWatchMu.Unlock()
 		return
 	}
 	entry.done = true
 	entry.outcome = outcome
 	entry.err = errMsg
 	allDone := true
-	for _, e := range i.swarmWatch {
+	for _, e := range i.subagentWatch {
 		if !e.done {
 			allDone = false
 			break
 		}
 	}
-	var batch []*swarmWatchEntry
+	var batch []*subagentWatchEntry
 	if allDone {
-		batch = i.swarmWatch
+		batch = i.subagentWatch
-		i.swarmWatch = nil
+		i.subagentWatch = nil
 	}
-	i.swarmWatchMu.Unlock()
+	i.subagentWatchMu.Unlock()
 	if len(batch) != 0 {
-		i.flushSwarmSummary(batch)
+		i.flushSupervisorSummary(batch)
 	}
 }
-// flushSwarmSummary composes a synthetic user turn describing every
+// flushSupervisorSummary composes a synthetic user turn describing every
 // sub-agent's outcome and injects it via SubmitOrQueue so the main
 // agent picks it up at the next safe boundary. The summary is
-// phrased as a system update ("Auto-swarm finished: ...") so the
+// phrased as a system update ("Auto-subagents finished: ...") so the
 // model treats it as observed state, not as a fresh user request.
-func (i *Interactive) flushSwarmSummary(batch []*swarmWatchEntry) {
+func (i *Interactive) flushSupervisorSummary(batch []*subagentWatchEntry) {
 	if len(batch) == 0 {
 		return
 	}
 	var sb strings.Builder
-	fmt.Fprintf(&sb, "[auto-swarm update] %d sub-agent(s) finished:\n\n", len(batch))
+	fmt.Fprintf(&sb, "[auto-subagents update] %d sub-agent(s) finished:\n\n", len(batch))
 	for idx, e := range batch {
 		snap := e.agent.Snapshot()
 		status := e.outcome
 	return s[:n-3] + "..."
 }
-// autoSwarmAddenda returns the prompt blocks owned by the auto-swarm
+// autoSubagentsAddenda returns the prompt blocks owned by the auto-subagents
 // toggle, in the same order Resolve appends them to a new agent.
-func autoSwarmAddenda(cfg InteractiveConfig) []string {
+func autoSubagentsAddenda(cfg InteractiveConfig) []string {
 	addenda := make([]string, 0, 2)
 	if addendum := strings.TrimSpace(cfg.SubagentsSystemAddendum); addendum != "" {
 		addenda = append(addenda, addendum)
 	}
-	if addendum := strings.TrimSpace(cfg.AutoSwarmSystemAddendum); addendum != "" {
+	if addendum := strings.TrimSpace(cfg.AutoSubagentsSystemAddendum); addendum != "" {
 		addenda = append(addenda, addendum)
 	}
 	return addenda
 }
-func containsAutoSwarmAddendum(addenda []string, want string) bool {
+func containsAutoSubagentsAddendum(addenda []string, want string) bool {
 	for _, addendum := range addenda {
 		if addendum == want {
 			return true
 	return false
 }
-// removeLastAutoSwarmAddendum removes one occurrence of a block known to
+// removeLastAutoSubagentsAddendum removes one occurrence of a block known to
-// have been appended by auto-swarm. Resolve appends owned blocks at the
+// have been appended by auto-subagents. Resolve appends owned blocks at the
 // end, so removing the last occurrence preserves an identical base block.
-func removeLastAutoSwarmAddendum(system, addendum string) (string, bool) {
+func removeLastAutoSubagentsAddendum(system, addendum string) (string, bool) {
 	idx := strings.LastIndex(system, addendum)
 	if idx < 0 {
 		return system, false
 	return system[:idx] + system[idx+len(addendum):], true
 }
-// applyAutoSwarmSystemPrompt appends (active=true) or strips
+// applyAutoSubagentsSystemPrompt appends (active=true) or strips
-// (active=false) the auto-swarm prompt blocks on the running agent.
+// (active=false) the auto-subagents prompt blocks on the running agent.
 // The profile manifest and delegation guidance are managed together so
-// toggling auto-swarm never leaves the model with names but no tool.
+// toggling auto-subagents never leaves the model with names but no tool.
-func (i *Interactive) applyAutoSwarmSystemPrompt(active bool) {
+func (i *Interactive) applyAutoSubagentsSystemPrompt(active bool) {
 	if i.agent == nil {
 		return
 	}
-	addenda := autoSwarmAddenda(i.cfg)
+	addenda := autoSubagentsAddenda(i.cfg)
 	if active {
 		sys := i.agent.System
 		for _, addendum := range addenda {
-			if containsAutoSwarmAddendum(i.managedAutoSwarmAddenda, addendum) {
+			if containsAutoSubagentsAddendum(i.managedAutoSubagentsAddenda, addendum) {
 				continue
 			}
 			if sys != "" && !strings.HasSuffix(sys, "\n\n") {
 				sys += "\n\n"
 			}
 			sys += addendum
-			i.managedAutoSwarmAddenda = append(i.managedAutoSwarmAddenda, addendum)
+			i.managedAutoSubagentsAddenda = append(i.managedAutoSubagentsAddenda, addendum)
 		}
 		i.agent.System = sys
 		return
 	sys := i.agent.System
 	changed := false
-	for idx := len(i.managedAutoSwarmAddenda) - 1; idx >= 0; idx-- {
+	for idx := len(i.managedAutoSubagentsAddenda) - 1; idx >= 0; idx-- {
 		var removed bool
-		sys, removed = removeLastAutoSwarmAddendum(sys, i.managedAutoSwarmAddenda[idx])
+		sys, removed = removeLastAutoSubagentsAddendum(sys, i.managedAutoSubagentsAddenda[idx])
 		changed = changed || removed
 	}
-	i.managedAutoSwarmAddenda = nil
+	i.managedAutoSubagentsAddenda = nil
 	if changed {
 		i.agent.System = strings.TrimRight(sys, "\n") + "\n"
 	}
 }
-// applyAutoSwarmTool registers (active=true) or removes (active=false)
+// applyAutoSubagentsTool registers (active=true) or removes (active=false)
-// the swarm_spawn tool on the running agent so the model only sees it
+// the subagent_spawn tool on the running agent so the model only sees it
-// when /settings -> auto-swarm is enabled. Mirrors applyTelegramTools'
+// when /settings -> auto-subagents is enabled. Mirrors applyTelegramTools'
 // snapshot+mutate pattern so extension tools and /reload-ext additions
 // survive a toggle.
-func (i *Interactive) autoSwarmEnabled() bool {
+func (i *Interactive) autoSubagentsEnabled() bool {
-	return i.cfg.AutoSwarmEnabled != nil && *i.cfg.AutoSwarmEnabled
+	return i.cfg.AutoSubagentsEnabled != nil && *i.cfg.AutoSubagentsEnabled
 }
-func (i *Interactive) applyAutoSwarmTool(active bool) {
+func (i *Interactive) applyAutoSubagentsTool(active bool) {
 	if i.agent == nil {
 		return
 	}
 	current := i.agent.Tools
 	next := core.Registry{}
 	for name, t := range current {
-		if name == "swarm_spawn" || name == "subagent_spawn" {
+		if name == "subagent_spawn" {
 			continue
 		}
 		next[name] = t
 	}
-	toolAllowed := i.cfg.AutoSwarmToolAllowed == nil || *i.cfg.AutoSwarmToolAllowed
+	toolAllowed := i.cfg.AutoSubagentsToolAllowed == nil || *i.cfg.AutoSubagentsToolAllowed
-	if active && toolAllowed && i.cfg.Swarm != nil {
+	if active && toolAllowed && i.cfg.Supervisor != nil {
-		canonical := &tools.SwarmSpawnTool{
+		canonical := &tools.SubagentSpawnTool{
-			ToolName:         "subagent_spawn",
+			Supervisor:       i.cfg.Supervisor,
-			Swarm:            i.cfg.Swarm,
 			Enabled:          func() bool { return true },
 			DefaultModel:     func() string { return i.cfg.Model },
 			DefaultProvider:  func() string { return i.cfg.Provider },
 			DefaultReasoning: func() string { return i.cfg.Reasoning },
 			ResolveSubagent:  i.cfg.ResolveSubagent,
-			OnSpawned:        i.trackSwarmAgent,
+			OnSpawned:        i.trackSubagentWorker,
 		}
 		next[canonical.Name()] = canonical
-		legacy := *canonical
-		legacy.ToolName = "swarm_spawn"
-		next[legacy.Name()] = &legacy
 	}
 	i.agent.SetTools(next)
 }

M packages/agent/modes/slash_suggest.go +0 -1


@@ -63,7 +63,6 @@ var slashCatalog = []slashCommand{
63		{Name: "/unjail", Desc: "allow tools to touch paths outside this directory"},	63	{Name: "/unjail", Desc: "allow tools to touch paths outside this directory"},
64		{Name: "/skills", Desc: "list discovered skills (SKILL.md files)"},	64	{Name: "/skills", Desc: "list discovered skills (SKILL.md files)"},
65		{Name: "/subagents", Desc: "supervise background subagents with lifecycle, results, and optional worktrees"},	65	{Name: "/subagents", Desc: "supervise background subagents with lifecycle, results, and optional worktrees"},
66	-	{Name: "/swarm", Desc: "compatibility alias for /subagents"},
67		{Name: "/reload-ext", Desc: "hot-reload all extensions (re-read manifests and respawn)"},	66	{Name: "/reload-ext", Desc: "hot-reload all extensions (re-read manifests and respawn)"},
68		{Name: "/telegram", Desc: "connect, disconnect, or show status of the telegram bridge"},	67	{Name: "/telegram", Desc: "connect, disconnect, or show status of the telegram bridge"},
69		{Name: "/settings", Desc: "open settings"},	68	{Name: "/settings", Desc: "open settings"},

M packages/agent/modes/slash_suggest_test.go +3 -3


@@ -37,10 +37,10 @@ func TestSlashSuggesterShowsLlamaOnlyWhenConfigured(t *testing.T) {
37		}	37		}
38		}	38		}
39			39
40	-	func TestSlashSuggesterHasSwarm(t *testing.T) {	40	+	func TestSlashSuggesterHasSupervisor(t *testing.T) {
41		s := newSlashSuggester()	41		s := newSlashSuggester()
42	-	if got := commandNames(s.matches("/sw")); !contains(got, "/swarm") {	42	+	if got := commandNames(s.matches("/su")); !contains(got, "/subagents") {
43	-	t.Fatalf("/swarm missing from suggestions, got %v", got)	43	+	t.Fatalf("/subagents missing from suggestions, got %v", got)
44		}	44		}
45		}	45		}
46			46

R packages/agent/modes/swarm_dialog.go → packages/agent/modes/subagents_dialog.go +85 -85 renamed, 89% similar


@@ -6,13 +6,13 @@ import (
6		"strings"	6		"strings"
7		"time"	7		"time"
8			8
9	-	"github.com/patriceckhart/zot/packages/agent/swarm"	9	+	"github.com/patriceckhart/zot/packages/agent/subagents"
10		"github.com/patriceckhart/zot/packages/tui"	10		"github.com/patriceckhart/zot/packages/tui"
11		)	11		)
12			12
13	-	// swarmDialog is the dashboard shown by /swarm (no argument) and	13	+	// subagentsDialog is the dashboard shown by /subagents (no argument) and
14	-	// /swarm list. It's a read-only window onto a *swarm.Swarm; the	14	+	// /subagents list. It's a read-only window onto a *subagents.Supervisor; the
15	-	// caller passes a snapshotter so the dialog never holds the swarm	15	+	// caller passes a snapshotter so the dialog never holds the subagent
16		// pointer or its lock.	16		// pointer or its lock.
17		//	17		//
18		// Keys (list view):	18		// Keys (list view):

@@ -31,16 +31,16 @@ import (
31		// p send a follow-up prompt to this agent (inline editor)	31		// p send a follow-up prompt to this agent (inline editor)
32		// ↑/↓/PgUp/PgDn/Home/End scroll	32		// ↑/↓/PgUp/PgDn/Home/End scroll
33		// esc / q return to the list	33		// esc / q return to the list
34	-	type swarmDialog struct {	34	+	type subagentsDialog struct {
35		active bool	35		active bool
36		compactMode bool	36		compactMode bool
37		lineInput bool	37		lineInput bool
38	-	snapshot func() []swarm.AgentSnapshot	38	+	snapshot func() []subagents.AgentSnapshot
39		stop func(id string) error	39		stop func(id string) error
40		remove func(id string) error	40		remove func(id string) error
41		// spawn accepts an optional model + provider override (empty	41		// spawn accepts an optional model + provider override (empty
42		// strings mean "let the child resolve its own default"). The cli	42		// strings mean "let the child resolve its own default"). The cli
43	-	// adapter forwards these to swarm.Swarm.SpawnReq.	43	+	// adapter forwards these to subagents.Supervisor.SpawnReq.
44		spawn func(task, model, provider string) error	44		spawn func(task, model, provider string) error
45		// send delivers a follow-up user turn to a running agent's inbox.	45		// send delivers a follow-up user turn to a running agent's inbox.
46		// Wired by Open(); when nil the inline 'p' shortcut is disabled.	46		// Wired by Open(); when nil the inline 'p' shortcut is disabled.

@@ -50,7 +50,7 @@ type swarmDialog struct {
50		// disabled.	50		// disabled.
51		resume func(id string) error	51		resume func(id string) error
52			52
53	-	rows []swarm.AgentSnapshot	53	+	rows []subagents.AgentSnapshot
54		cursor int	54		cursor int
55		viewing bool // when true, show full transcript of the selected row	55		viewing bool // when true, show full transcript of the selected row
56			56

@@ -63,7 +63,7 @@ type swarmDialog struct {
63		transcriptSpin *spinner	63		transcriptSpin *spinner
64			64
65		// spawning toggles the inline "enter task" editor. While true the	65		// spawning toggles the inline "enter task" editor. While true the
66	-	// dialog captures keys into a real tui.Editor so swarm-new has the	66	+	// dialog captures keys into a real tui.Editor so subagent-new has the
67		// same editing, paste, drag-drop file chips, and visual style as	67		// same editing, paste, drag-drop file chips, and visual style as
68		// the default input and /btw input.	68		// the default input and /btw input.
69		spawning bool	69		spawning bool

@@ -74,7 +74,7 @@ type swarmDialog struct {
74		// pendingModel / pendingProvider are the model + provider every	74		// pendingModel / pendingProvider are the model + provider every
75		// freshly-spawned agent will be pinned to. They're seeded from	75		// freshly-spawned agent will be pinned to. They're seeded from
76		// the host's currently-active model (via SetCurrentModel) at the	76		// the host's currently-active model (via SetCurrentModel) at the
77	-	// moment the user opens the dashboard, so swarm agents inherit	77	+	// moment the user opens the dashboard, so subagent agents inherit
78		// whatever the user last picked via /model. Empty means "don't	78		// whatever the user last picked via /model. Empty means "don't
79		// pin a model; let the child resolve its own default".	79		// pin a model; let the child resolve its own default".
80		pendingModel string	80		pendingModel string

@@ -98,7 +98,7 @@ type swarmDialog struct {
98			98
99		// prompting toggles the inline "send prompt to selected agent"	99		// prompting toggles the inline "send prompt to selected agent"
100		// editor. Distinct from `spawning` so we don't accidentally	100		// editor. Distinct from `spawning` so we don't accidentally
101	-	// route a follow-up into Swarm.Spawn. The editor and its	101	+	// route a follow-up into Supervisor.Spawn. The editor and its
102		// file-suggest live in their own fields so opening the prompt	102		// file-suggest live in their own fields so opening the prompt
103		// editor while a spawn editor is half-typed doesn't clobber it	103		// editor while a spawn editor is half-typed doesn't clobber it
104		// (the dialog enforces one-at-a-time, but the separate state	104		// (the dialog enforces one-at-a-time, but the separate state

@@ -113,7 +113,7 @@ type swarmDialog struct {
113		promptTargetID string	113		promptTargetID string
114		}	114		}
115			115
116	-	func newSwarmDialog() *swarmDialog { return &swarmDialog{} }	116	+	func newSubagentsDialog() *subagentsDialog { return &subagentsDialog{} }
117			117
118		// SetCurrentModel pins the model + provider every fresh spawn will	118		// SetCurrentModel pins the model + provider every fresh spawn will
119		// inherit. The host wires this to the same Model / Provider the rest	119		// inherit. The host wires this to the same Model / Provider the rest

@@ -121,22 +121,22 @@ func newSwarmDialog() *swarmDialog { return &swarmDialog{} }
121		// run on whatever the user last picked via /model. Pass empty	121		// run on whatever the user last picked via /model. Pass empty
122		// strings to clear the override (the child then resolves its own	122		// strings to clear the override (the child then resolves its own
123		// default the same way a bare `zot` invocation does).	123		// default the same way a bare `zot` invocation does).
124	-	func (d *swarmDialog) SetCompactMode(enabled bool) {	124	+	func (d *subagentsDialog) SetCompactMode(enabled bool) {
125		d.compactMode = enabled	125		d.compactMode = enabled
126		}	126		}
127			127
128	-	func (d *swarmDialog) SetLineInput(enabled bool) {	128	+	func (d *subagentsDialog) SetLineInput(enabled bool) {
129		d.lineInput = enabled	129		d.lineInput = enabled
130		}	130		}
131			131
132	-	func (d *swarmDialog) editorPrompt(th tui.Theme) string {	132	+	func (d *subagentsDialog) editorPrompt(th tui.Theme) string {
133		if d.lineInput {	133		if d.lineInput {
134		return ""	134		return ""
135		}	135		}
136		return th.AccentBar(th.Accent)	136		return th.AccentBar(th.Accent)
137		}	137		}
138			138
139	-	func (d *swarmDialog) SetCurrentModel(model, providerID string) {	139	+	func (d *subagentsDialog) SetCurrentModel(model, providerID string) {
140		d.pendingModel = model	140		d.pendingModel = model
141		d.pendingProvider = providerID	141		d.pendingProvider = providerID
142		}	142		}

@@ -146,16 +146,16 @@ func (d *swarmDialog) SetCurrentModel(model, providerID string) {
146		// the user invokes /model inside the spawn editor so the picker can	146		// the user invokes /model inside the spawn editor so the picker can
147		// filter out unauthenticated providers, matching the global /model	147		// filter out unauthenticated providers, matching the global /model
148		// behaviour.	148		// behaviour.
149	-	func (d *swarmDialog) SetLoggedInProviders(provs []string) {	149	+	func (d *subagentsDialog) SetLoggedInProviders(provs []string) {
150		d.modelPickerLoggedIn = provs	150		d.modelPickerLoggedIn = provs
151		}	151		}
152			152
153	-	// Open binds the dialog to a swarm via the provided callbacks. The	153	+	// Open binds the dialog to a subagent via the provided callbacks. The
154		// dialog refreshes the snapshot every Render so the dashboard reads	154		// dialog refreshes the snapshot every Render so the dashboard reads
155		// live state without needing a goroutine. spawn / send are optional;	155		// live state without needing a goroutine. spawn / send are optional;
156		// when nil the corresponding inline shortcut ('n' / 'p') is disabled.	156		// when nil the corresponding inline shortcut ('n' / 'p') is disabled.
157	-	func (d *swarmDialog) Open(	157	+	func (d *subagentsDialog) Open(
158	-	snapshot func() []swarm.AgentSnapshot,	158	+	snapshot func() []subagents.AgentSnapshot,
159		stop func(id string) error,	159		stop func(id string) error,
160		remove func(id string) error,	160		remove func(id string) error,
161		spawn func(task, model, provider string) error,	161		spawn func(task, model, provider string) error,

@@ -194,7 +194,7 @@ func (d *swarmDialog) Open(
194		// CursorPos returns the row/col for the terminal cursor while an	194		// CursorPos returns the row/col for the terminal cursor while an
195		// inline editor (spawn or prompt) is active so the caret blinks in	195		// inline editor (spawn or prompt) is active so the caret blinks in
196		// the right spot. Returns -1, -1 when no input is being captured.	196		// the right spot. Returns -1, -1 when no input is being captured.
197	-	func (d *swarmDialog) CursorPos(width int) (row, col int) {	197	+	func (d *subagentsDialog) CursorPos(width int) (row, col int) {
198		if !d.Active() {	198		if !d.Active() {
199		return -1, -1	199		return -1, -1
200		}	200		}

@@ -264,7 +264,7 @@ func (d *swarmDialog) CursorPos(width int) (row, col int) {
264		// belongs on when the always-on editor sits at the bottom of the	264		// belongs on when the always-on editor sits at the bottom of the
265		// transcript view. Mirrors renderTranscript's row layout so the	265		// transcript view. Mirrors renderTranscript's row layout so the
266		// terminal cursor stays glued to the editor as the body grows.	266		// terminal cursor stays glued to the editor as the body grows.
267	-	func (d *swarmDialog) transcriptEditorCursorRow(width, popupRows, editorRowOffset int) int {	267	+	func (d *subagentsDialog) transcriptEditorCursorRow(width, popupRows, editorRowOffset int) int {
268		a := d.selected()	268		a := d.selected()
269		if a == nil {	269		if a == nil {
270		return -1	270		return -1

@@ -299,7 +299,7 @@ func (d *swarmDialog) transcriptEditorCursorRow(width, popupRows, editorRowOffse
299		// Full body, no scroll window — the host's outer scrollback	299		// Full body, no scroll window — the host's outer scrollback
300		// owns overflow now. Cursor row math just counts every	300		// owns overflow now. Cursor row math just counts every
301		// rendered line.	301		// rendered line.
302	-	body := renderSwarmTranscriptBlocks(raw, tui.Theme{}, width, d.compactMode)	302	+	body := renderSupervisorTranscriptBlocks(raw, tui.Theme{}, width, d.compactMode)
303		row += len(body)	303		row += len(body)
304		}	304		}
305			305

@@ -311,8 +311,8 @@ func (d *swarmDialog) transcriptEditorCursorRow(width, popupRows, editorRowOffse
311		return row + editorRowOffset	311		return row + editorRowOffset
312		}	312		}
313			313
314	-	func (d *swarmDialog) Active() bool { return d != nil && d.active }	314	+	func (d *subagentsDialog) Active() bool { return d != nil && d.active }
315	-	func (d *swarmDialog) Close() { d.active = false }	315	+	func (d *subagentsDialog) Close() { d.active = false }
316			316
317		// NeedsTickRefresh reports whether the host's animation tick should	317		// NeedsTickRefresh reports whether the host's animation tick should
318		// repaint the screen while this dialog is open. True when the	318		// repaint the screen while this dialog is open. True when the

@@ -327,7 +327,7 @@ func (d *swarmDialog) Close() { d.active = false }
327		// tick refresh. The cursor blink still works because the tick rate	327		// tick refresh. The cursor blink still works because the tick rate
328		// is well below the terminal's blink rate, and we need the redraws	328		// is well below the terminal's blink rate, and we need the redraws
329		// for streaming output. /btw makes the same trade-off.	329		// for streaming output. /btw makes the same trade-off.
330	-	func (d *swarmDialog) NeedsTickRefresh() bool {	330	+	func (d *subagentsDialog) NeedsTickRefresh() bool {
331		if d == nil \|\| !d.active {	331		if d == nil \|\| !d.active {
332		return false	332		return false
333		}	333		}

@@ -345,12 +345,12 @@ func (d *swarmDialog) NeedsTickRefresh() bool {
345		}	345		}
346			346
347		// OpenViewing opens the dashboard and jumps straight to the	347		// OpenViewing opens the dashboard and jumps straight to the
348	-	// transcript view for the agent with id agentID. Used by /swarm logs	348	+	// transcript view for the agent with id agentID. Used by /subagents logs
349		// <id>. If no such agent is found the dashboard opens normally so	349		// <id>. If no such agent is found the dashboard opens normally so
350		// the user can see why (and pick from the list).	350		// the user can see why (and pick from the list).
351	-	func (d *swarmDialog) OpenViewing(	351	+	func (d *subagentsDialog) OpenViewing(
352		agentID string,	352		agentID string,
353	-	snapshot func() []swarm.AgentSnapshot,	353	+	snapshot func() []subagents.AgentSnapshot,
354		stop func(id string) error,	354		stop func(id string) error,
355		remove func(id string) error,	355		remove func(id string) error,
356		spawn func(task, model, provider string) error,	356		spawn func(task, model, provider string) error,

@@ -365,9 +365,9 @@ func (d *swarmDialog) OpenViewing(
365		d.cursor = i	365		d.cursor = i
366		d.viewing = true	366		d.viewing = true
367		// Auto-open the inline editor for running agents so	367		// Auto-open the inline editor for running agents so
368	-	// /swarm logs <id> drops the user straight into a	368	+	// /subagents logs <id> drops the user straight into a
369		// /btw-style send-ready prompt.	369		// /btw-style send-ready prompt.
370	-	if r.Status == swarm.StatusRunning && d.send != nil {	370	+	if r.Status == subagents.StatusRunning && d.send != nil {
371		d.openPromptEditor(tui.Theme{}, r.ID)	371		d.openPromptEditor(tui.Theme{}, r.ID)
372		}	372		}
373		return true	373		return true

@@ -386,8 +386,8 @@ func (d *swarmDialog) OpenViewing(
386		// so the user has context: pressing ↑/↓ they can still walk through	386		// so the user has context: pressing ↑/↓ they can still walk through
387		// running agents, and the R key is a no-op there (Resume rejects	387		// running agents, and the R key is a no-op there (Resume rejects
388		// non-terminal agents with a clear error).	388		// non-terminal agents with a clear error).
389	-	func (d *swarmDialog) OpenForResume(	389	+	func (d *subagentsDialog) OpenForResume(
390	-	snapshot func() []swarm.AgentSnapshot,	390	+	snapshot func() []subagents.AgentSnapshot,
391		stop func(id string) error,	391		stop func(id string) error,
392		remove func(id string) error,	392		remove func(id string) error,
393		spawn func(task, model, provider string) error,	393		spawn func(task, model, provider string) error,

@@ -410,14 +410,14 @@ func (d *swarmDialog) OpenForResume(
410		}	410		}
411			411
412		// isResumable reports whether a Status is eligible for Resume. Mirror	412		// isResumable reports whether a Status is eligible for Resume. Mirror
413	-	// of the precondition inside Swarm.Resume; centralised so the dialog	413	+	// of the precondition inside Supervisor.Resume; centralised so the dialog
414		// and the slash handler agree on what "resumable" means.	414		// and the slash handler agree on what "resumable" means.
415	-	func isResumable(s swarm.Status) bool {	415	+	func isResumable(s subagents.Status) bool {
416		switch s {	416		switch s {
417	-	case swarm.StatusDetached,	417	+	case subagents.StatusDetached,
418	-	swarm.StatusDone,	418	+	subagents.StatusDone,
419	-	swarm.StatusFailed,	419	+	subagents.StatusFailed,
420	-	swarm.StatusKilled:	420	+	subagents.StatusKilled:
421		return true	421		return true
422		}	422		}
423		return false	423		return false

@@ -426,8 +426,8 @@ func isResumable(s swarm.Status) bool {
426		// promptDisabledHint returns the status-bar message shown when the	426		// promptDisabledHint returns the status-bar message shown when the
427		// user presses 'p' on an agent that can't receive input. We branch on	427		// user presses 'p' on an agent that can't receive input. We branch on
428		// status so the hint points at the right next step: resume for the	428		// status so the hint points at the right next step: resume for the
429	-	// states Swarm.Resume accepts; nothing useful otherwise.	429	+	// states Supervisor.Resume accepts; nothing useful otherwise.
430	-	func promptDisabledHint(s swarm.Status) string {	430	+	func promptDisabledHint(s subagents.Status) string {
431		if isResumable(s) {	431		if isResumable(s) {
432		return "prompt: agent is " + string(s) + "; press R to resume first"	432		return "prompt: agent is " + string(s) + "; press R to resume first"
433		}	433		}

@@ -438,24 +438,24 @@ func promptDisabledHint(s swarm.Status) string {
438		// Kill only makes sense on running / pending agents; on detached and	438		// Kill only makes sense on running / pending agents; on detached and
439		// terminal ones it's a no-op and the user usually wants 'r' (remove)	439		// terminal ones it's a no-op and the user usually wants 'r' (remove)
440		// to clear out the agent's state instead.	440		// to clear out the agent's state instead.
441	-	func killDisabledHint(s swarm.Status) string {	441	+	func killDisabledHint(s subagents.Status) string {
442		return "kill: agent is " + string(s) + "; nothing to stop (press r to remove)"	442		return "kill: agent is " + string(s) + "; nothing to stop (press r to remove)"
443		}	443		}
444			444
445		// friendlySendErr turns a raw send error into a status-bar message	445		// friendlySendErr turns a raw send error into a status-bar message
446		// the user can act on. The most common failure mode — dialling an	446		// the user can act on. The most common failure mode — dialling an
447		// agent whose previous subprocess exited — surfaces as	447		// agent whose previous subprocess exited — surfaces as
448	-	// swarm.ErrNotReady; we rewrite it to mention resume instead of	448	+	// subagents.ErrNotReady; we rewrite it to mention resume instead of
449		// leaking the unix-socket path. Other errors fall through verbatim	449		// leaking the unix-socket path. Other errors fall through verbatim
450		// because they're rare and almost always indicate a real bug.	450		// because they're rare and almost always indicate a real bug.
451		func friendlySendErr(id string, err error) string {	451		func friendlySendErr(id string, err error) string {
452	-	if errors.Is(err, swarm.ErrNotReady) {	452	+	if errors.Is(err, subagents.ErrNotReady) {
453		return "send: agent " + id + " isn't accepting input (press R to resume)"	453		return "send: agent " + id + " isn't accepting input (press R to resume)"
454		}	454		}
455		return "send: " + err.Error()	455		return "send: " + err.Error()
456		}	456		}
457			457
458	-	func (d *swarmDialog) refresh() {	458	+	func (d *subagentsDialog) refresh() {
459		if d.snapshot == nil {	459		if d.snapshot == nil {
460		d.rows = nil	460		d.rows = nil
461		return	461		return

@@ -472,7 +472,7 @@ func (d *swarmDialog) refresh() {
472		// HandleKey advances state. Returns (closed, statusMsg, statusErr).	472		// HandleKey advances state. Returns (closed, statusMsg, statusErr).
473		// statusMsg / statusErr surface in the host's status bar so the user	473		// statusMsg / statusErr surface in the host's status bar so the user
474		// gets feedback on kill/remove without writing to the chat.	474		// gets feedback on kill/remove without writing to the chat.
475	-	func (d *swarmDialog) HandleKey(k tui.Key) (closed bool, msg, errMsg string) {	475	+	func (d *subagentsDialog) HandleKey(k tui.Key) (closed bool, msg, errMsg string) {
476		if !d.Active() {	476		if !d.Active() {
477		return false, "", ""	477		return false, "", ""
478		}	478		}

@@ -519,7 +519,7 @@ func (d *swarmDialog) HandleKey(k tui.Key) (closed bool, msg, errMsg string) {
519		// can start typing immediately. Skipped for non-running	519		// can start typing immediately. Skipped for non-running
520		// agents; their inbox isn't listening, so an editor	520		// agents; their inbox isn't listening, so an editor
521		// would just frustrate them with bounced sends.	521		// would just frustrate them with bounced sends.
522	-	if a := d.selected(); a != nil && a.Status == swarm.StatusRunning && d.send != nil {	522	+	if a := d.selected(); a != nil && a.Status == subagents.StatusRunning && d.send != nil {
523		d.openPromptEditor(tui.Theme{}, a.ID)	523		d.openPromptEditor(tui.Theme{}, a.ID)
524		}	524		}
525		}	525		}

@@ -534,7 +534,7 @@ func (d *swarmDialog) HandleKey(k tui.Key) (closed bool, msg, errMsg string) {
534		// agent will run against was already captured via	534		// agent will run against was already captured via
535		// SetCurrentModel from the host's /model selection;	535		// SetCurrentModel from the host's /model selection;
536		// the user changes models the normal way (/model)	536		// the user changes models the normal way (/model)
537	-	// before opening /swarm.	537	+	// before opening /subagents.
538		d.openSpawnEditor(tui.Theme{})	538		d.openSpawnEditor(tui.Theme{})
539		}	539		}
540		case 'p':	540		case 'p':

@@ -544,7 +544,7 @@ func (d *swarmDialog) HandleKey(k tui.Key) (closed bool, msg, errMsg string) {
544		// failed / killed agent fails with a long ECONNREFUSED	544		// failed / killed agent fails with a long ECONNREFUSED
545		// or ENOENT trail that's not actionable. Tell the user	545		// or ENOENT trail that's not actionable. Tell the user
546		// what to do instead.	546		// what to do instead.
547	-	if a.Status != swarm.StatusRunning {	547	+	if a.Status != subagents.StatusRunning {
548		return false, "", promptDisabledHint(a.Status)	548		return false, "", promptDisabledHint(a.Status)
549		}	549		}
550		d.openPromptEditor(tui.Theme{}, a.ID)	550		d.openPromptEditor(tui.Theme{}, a.ID)

@@ -565,10 +565,10 @@ func (d *swarmDialog) HandleKey(k tui.Key) (closed bool, msg, errMsg string) {
565		if a := d.selected(); a != nil && d.stop != nil {	565		if a := d.selected(); a != nil && d.stop != nil {
566		// Only running / pending agents have something to	566		// Only running / pending agents have something to
567		// cancel. Detached and already-terminal agents would	567		// cancel. Detached and already-terminal agents would
568	-	// be silent no-ops at the Swarm layer; surface a hint	568	+	// be silent no-ops at the Supervisor layer; surface a hint
569		// so the user knows kill did nothing and what to do	569		// so the user knows kill did nothing and what to do
570		// instead (remove via 'r').	570		// instead (remove via 'r').
571	-	if a.Status != swarm.StatusRunning && a.Status != swarm.StatusPending {	571	+	if a.Status != subagents.StatusRunning && a.Status != subagents.StatusPending {
572		return false, "", killDisabledHint(a.Status)	572		return false, "", killDisabledHint(a.Status)
573		}	573		}
574		if err := d.stop(a.ID); err != nil {	574		if err := d.stop(a.ID); err != nil {

@@ -603,14 +603,14 @@ func (d *swarmDialog) HandleKey(k tui.Key) (closed bool, msg, errMsg string) {
603		// suggest, arrow keys for caret movement, etc.). Submits stay in	603		// suggest, arrow keys for caret movement, etc.). Submits stay in
604		// the view and clear the editor for the next message instead of	604		// the view and clear the editor for the next message instead of
605		// closing it — see handlePromptKey for the always-on behaviour.	605		// closing it — see handlePromptKey for the always-on behaviour.
606	-	func (d *swarmDialog) handleViewingKey(k tui.Key) (closed bool, msg, errMsg string) {	606	+	func (d *subagentsDialog) handleViewingKey(k tui.Key) (closed bool, msg, errMsg string) {
607		a := d.selected()	607		a := d.selected()
608			608
609		// Lazy-open the editor on first key into the transcript view, so	609		// Lazy-open the editor on first key into the transcript view, so
610		// re-entering an agent after switching away picks up cleanly.	610		// re-entering an agent after switching away picks up cleanly.
611		// Skipped for non-running agents (their inbox isn't listening;	611		// Skipped for non-running agents (their inbox isn't listening;
612		// sending would just bounce).	612		// sending would just bounce).
613	-	if a != nil && a.Status == swarm.StatusRunning && d.send != nil && !d.prompting {	613	+	if a != nil && a.Status == subagents.StatusRunning && d.send != nil && !d.prompting {
614		d.openPromptEditor(tui.Theme{}, a.ID)	614		d.openPromptEditor(tui.Theme{}, a.ID)
615		}	615		}
616			616

@@ -634,7 +634,7 @@ func (d *swarmDialog) handleViewingKey(k tui.Key) (closed bool, msg, errMsg stri
634		// Everything else — typed runes, Enter, Backspace, arrow keys	634		// Everything else — typed runes, Enter, Backspace, arrow keys
635		// for caret movement, @-file picker — is editor input. If the	635		// for caret movement, @-file picker — is editor input. If the
636		// agent isn't running there's no live editor; surface a hint.	636		// agent isn't running there's no live editor; surface a hint.
637	-	if a == nil \|\| a.Status != swarm.StatusRunning \|\| d.send == nil {	637	+	if a == nil \|\| a.Status != subagents.StatusRunning \|\| d.send == nil {
638		if k.Kind == tui.KeyRune && a != nil {	638		if k.Kind == tui.KeyRune && a != nil {
639		return false, "", promptDisabledHint(a.Status)	639		return false, "", promptDisabledHint(a.Status)
640		}	640		}

@@ -644,10 +644,10 @@ func (d *swarmDialog) handleViewingKey(k tui.Key) (closed bool, msg, errMsg stri
644		}	644		}
645			645
646		// openSpawnEditor enters the inline new-agent prompt. It deliberately	646		// openSpawnEditor enters the inline new-agent prompt. It deliberately
647	-	// uses tui.Editor (not a one-line string) so swarm-new supports the same	647	+	// uses tui.Editor (not a one-line string) so subagent-new supports the same
648		// editing model as the normal input: multiline paste collapse, drag-drop	648		// editing model as the normal input: multiline paste collapse, drag-drop
649		// file/dir chips, cursor movement, and the same accent-bar prompt style.	649		// file/dir chips, cursor movement, and the same accent-bar prompt style.
650	-	func (d *swarmDialog) openSpawnEditor(th tui.Theme) {	650	+	func (d *subagentsDialog) openSpawnEditor(th tui.Theme) {
651		d.spawning = true	651		d.spawning = true
652		d.newTaskEd = tui.NewEditor(d.editorPrompt(th))	652		d.newTaskEd = tui.NewEditor(d.editorPrompt(th))
653		d.fileSuggest = newFileSuggester()	653		d.fileSuggest = newFileSuggester()

@@ -662,7 +662,7 @@ func (d *swarmDialog) openSpawnEditor(th tui.Theme) {
662		// submits "/model" from inside the spawn editor; on select we	662		// submits "/model" from inside the spawn editor; on select we
663		// capture the new pendingModel/Provider and reopen the spawn	663		// capture the new pendingModel/Provider and reopen the spawn
664		// editor with the previously-typed task buffer restored.	664		// editor with the previously-typed task buffer restored.
665	-	func (d *swarmDialog) openModelPicker() {	665	+	func (d *subagentsDialog) openModelPicker() {
666		d.spawning = false	666		d.spawning = false
667		d.newTaskEd = nil	667		d.newTaskEd = nil
668		d.fileSuggest = nil	668		d.fileSuggest = nil

@@ -677,7 +677,7 @@ func (d *swarmDialog) openModelPicker() {
677		// pendingModel + pendingProvider; Esc leaves them unchanged (the	677		// pendingModel + pendingProvider; Esc leaves them unchanged (the
678		// user gets to keep whatever was inherited before they invoked	678		// user gets to keep whatever was inherited before they invoked
679		// /model).	679		// /model).
680	-	func (d *swarmDialog) handleModelPickerKey(k tui.Key) (closed bool, msg, errMsg string) {	680	+	func (d *subagentsDialog) handleModelPickerKey(k tui.Key) (closed bool, msg, errMsg string) {
681		if d.modelPicker == nil {	681		if d.modelPicker == nil {
682		d.openModelPicker()	682		d.openModelPicker()
683		}	683		}

@@ -738,7 +738,7 @@ func stripSlashModelLine(buf string) string {
738		// openPromptEditor enters the inline "send a follow-up prompt" editor	738		// openPromptEditor enters the inline "send a follow-up prompt" editor
739		// for the agent with id targetID. Mirrors openSpawnEditor so the	739		// for the agent with id targetID. Mirrors openSpawnEditor so the
740		// editing experience (paste, @-picker, drop chips) is identical.	740		// editing experience (paste, @-picker, drop chips) is identical.
741	-	func (d *swarmDialog) openPromptEditor(th tui.Theme, targetID string) {	741	+	func (d *subagentsDialog) openPromptEditor(th tui.Theme, targetID string) {
742		d.prompting = true	742		d.prompting = true
743		d.promptEd = tui.NewEditor(d.editorPrompt(th))	743		d.promptEd = tui.NewEditor(d.editorPrompt(th))
744		d.promptSuggest = newFileSuggester()	744		d.promptSuggest = newFileSuggester()

@@ -751,7 +751,7 @@ func (d *swarmDialog) openPromptEditor(th tui.Theme, targetID string) {
751		// with the captured target id instead of d.spawn. Esc cancels and	751		// with the captured target id instead of d.spawn. Esc cancels and
752		// returns the user to whichever view (list or transcript) was active	752		// returns the user to whichever view (list or transcript) was active
753		// when 'p' was pressed.	753		// when 'p' was pressed.
754	-	func (d *swarmDialog) handlePromptKey(k tui.Key) (closed bool, msg, errMsg string) {	754	+	func (d *subagentsDialog) handlePromptKey(k tui.Key) (closed bool, msg, errMsg string) {
755		if d.promptEd == nil {	755		if d.promptEd == nil {
756		d.openPromptEditor(tui.Theme{}, d.promptTargetID)	756		d.openPromptEditor(tui.Theme{}, d.promptTargetID)
757		}	757		}

@@ -868,7 +868,7 @@ func (d *swarmDialog) handlePromptKey(k tui.Key) (closed bool, msg, errMsg strin
868			868
869		// closePromptEditor resets all prompt-editor state. Called on Esc and	869		// closePromptEditor resets all prompt-editor state. Called on Esc and
870		// after submit so a subsequent 'p' starts from a clean slate.	870		// after submit so a subsequent 'p' starts from a clean slate.
871	-	func (d *swarmDialog) closePromptEditor() {	871	+	func (d *subagentsDialog) closePromptEditor() {
872		d.prompting = false	872		d.prompting = false
873		d.promptEd = nil	873		d.promptEd = nil
874		d.promptSuggest = nil	874		d.promptSuggest = nil

@@ -878,7 +878,7 @@ func (d *swarmDialog) closePromptEditor() {
878		// handleSpawnKey owns the keystrokes while the inline new-agent editor	878		// handleSpawnKey owns the keystrokes while the inline new-agent editor
879		// is open. It mirrors the normal input's @ file-picker path and submit	879		// is open. It mirrors the normal input's @ file-picker path and submit
880		// expansion, then asks the host to spawn.	880		// expansion, then asks the host to spawn.
881	-	func (d *swarmDialog) handleSpawnKey(k tui.Key) (closed bool, msg, errMsg string) {	881	+	func (d *subagentsDialog) handleSpawnKey(k tui.Key) (closed bool, msg, errMsg string) {
882		if d.newTaskEd == nil {	882		if d.newTaskEd == nil {
883		d.openSpawnEditor(tui.Theme{})	883		d.openSpawnEditor(tui.Theme{})
884		}	884		}

@@ -986,7 +986,7 @@ func (d *swarmDialog) handleSpawnKey(k tui.Key) (closed bool, msg, errMsg string
986		return false, "", ""	986		return false, "", ""
987		}	987		}
988			988
989	-	func (d swarmDialog) selected() swarm.AgentSnapshot {	989	+	func (d subagentsDialog) selected() subagents.AgentSnapshot {
990		if d.cursor < 0 \|\| d.cursor >= len(d.rows) {	990		if d.cursor < 0 \|\| d.cursor >= len(d.rows) {
991		return nil	991		return nil
992		}	992		}

@@ -996,7 +996,7 @@ func (d swarmDialog) selected() swarm.AgentSnapshot {
996			996
997		// Render returns the dialog lines. Re-reads the snapshot each call so	997		// Render returns the dialog lines. Re-reads the snapshot each call so
998		// the dashboard updates as agents make progress.	998		// the dashboard updates as agents make progress.
999	-	func (d *swarmDialog) Render(th tui.Theme, width int) []string {	999	+	func (d *subagentsDialog) Render(th tui.Theme, width int) []string {
1000		if !d.Active() {	1000		if !d.Active() {
1001		return nil	1001		return nil
1002		}	1002		}

@@ -1061,7 +1061,7 @@ func (d *swarmDialog) Render(th tui.Theme, width int) []string {
1061		return out	1061		return out
1062		}	1062		}
1063		if len(d.rows) == 0 {	1063		if len(d.rows) == 0 {
1064	-	out = append(out, " "+th.FG256(th.Muted, "no agents — press n to spawn one (or /swarm new <task>)"))	1064	+	out = append(out, " "+th.FG256(th.Muted, "no agents — press n to spawn one (or /subagents new <task>)"))
1065		out = append(out, frameRule(th, width))	1065		out = append(out, frameRule(th, width))
1066		return out	1066		return out
1067		}	1067		}

@@ -1071,7 +1071,7 @@ func (d *swarmDialog) Render(th tui.Theme, width int) []string {
1071		out = append(out, th.FG256(th.Muted, header))	1071		out = append(out, th.FG256(th.Muted, header))
1072			1072
1073		for i, r := range d.rows {	1073		for i, r := range d.rows {
1074	-	row := formatSwarmRow(r, width-2)	1074	+	row := formatSupervisorRow(r, width-2)
1075		if i == d.cursor {	1075		if i == d.cursor {
1076		out = append(out, th.PadHighlight(" "+row, width))	1076		out = append(out, th.PadHighlight(" "+row, width))
1077		} else {	1077		} else {

@@ -1082,14 +1082,14 @@ func (d *swarmDialog) Render(th tui.Theme, width int) []string {
1082		return out	1082		return out
1083		}	1083		}
1084			1084
1085	-	func (d *swarmDialog) renderTranscript(th tui.Theme, width int) []string {	1085	+	func (d *subagentsDialog) renderTranscript(th tui.Theme, width int) []string {
1086		a := d.selected()	1086		a := d.selected()
1087		if a == nil {	1087		if a == nil {
1088		d.viewing = false	1088		d.viewing = false
1089		return d.Render(th, width)	1089		return d.Render(th, width)
1090		}	1090		}
1091		header := []string{	1091		header := []string{
1092	-	frameHeader(th, "swarm: "+a.ID+" (type to send, esc back)", width),	1092	+	frameHeader(th, "subagent: "+a.ID+" (type to send, esc back)", width),
1093		" " + th.FG256(th.Muted, "task: "+a.Task),	1093		" " + th.FG256(th.Muted, "task: "+a.Task),
1094		" " + th.FG256(th.Muted, "dir: "+a.Dir),	1094		" " + th.FG256(th.Muted, "dir: "+a.Dir),
1095		" " + th.FG256(th.Muted, fmt.Sprintf("status: %s, %s", a.Status, a.Activity)),	1095		" " + th.FG256(th.Muted, fmt.Sprintf("status: %s, %s", a.Status, a.Activity)),

@@ -1141,7 +1141,7 @@ func (d *swarmDialog) renderTranscript(th tui.Theme, width int) []string {
1141		// That gives the user the chat UX they expect (transcript grows	1141		// That gives the user the chat UX they expect (transcript grows
1142		// with the window, arrow keys belong to the editor, no "↑ N	1142		// with the window, arrow keys belong to the editor, no "↑ N
1143		// more above" cliff).	1143		// more above" cliff).
1144	-	body := renderSwarmTranscriptBlocks(raw, th, width, d.compactMode)	1144	+	body := renderSupervisorTranscriptBlocks(raw, th, width, d.compactMode)
1145			1145
1146		out := header	1146		out := header
1147		out = append(out, body...)	1147		out = append(out, body...)

@@ -1161,11 +1161,11 @@ func (d *swarmDialog) renderTranscript(th tui.Theme, width int) []string {
1161		// row, the editor itself, another breathing row, and a single muted	1161		// row, the editor itself, another breathing row, and a single muted
1162		// hint. For non-running agents we render a short "can't send while	1162		// hint. For non-running agents we render a short "can't send while
1163		// X" note instead so the user knows why typing is disabled.	1163		// X" note instead so the user knows why typing is disabled.
1164	-	func (d swarmDialog) appendTranscriptEditor(out []string, th tui.Theme, width int, a swarm.AgentSnapshot) []string {	1164	+	func (d subagentsDialog) appendTranscriptEditor(out []string, th tui.Theme, width int, a subagents.AgentSnapshot) []string {
1165		if a == nil {	1165		if a == nil {
1166		return out	1166		return out
1167		}	1167		}
1168	-	if a.Status != swarm.StatusRunning \|\| d.send == nil {	1168	+	if a.Status != subagents.StatusRunning \|\| d.send == nil {
1169		out = append(out, "")	1169		out = append(out, "")
1170		out = append(out, " "+th.FG256(th.Muted, promptDisabledHint(a.Status)))	1170		out = append(out, " "+th.FG256(th.Muted, promptDisabledHint(a.Status)))
1171		return out	1171		return out

@@ -1227,11 +1227,11 @@ func (d *swarmDialog) appendTranscriptEditor(out []string, th tui.Theme, width i
1227		// suppress the spinner so transient / unfamiliar activity strings	1227		// suppress the spinner so transient / unfamiliar activity strings
1228		// still animate. Detached / done / failed / killed never animate —	1228		// still animate. Detached / done / failed / killed never animate —
1229		// they aren't actively producing output.	1229		// they aren't actively producing output.
1230	-	func agentIsBusy(a *swarm.AgentSnapshot) bool {	1230	+	func agentIsBusy(a *subagents.AgentSnapshot) bool {
1231		if a == nil {	1231		if a == nil {
1232		return false	1232		return false
1233		}	1233		}
1234	-	if a.Status != swarm.StatusRunning && a.Status != swarm.StatusPending {	1234	+	if a.Status != subagents.StatusRunning && a.Status != subagents.StatusPending {
1235		return false	1235		return false
1236		}	1236		}
1237		switch strings.TrimSpace(a.Activity) {	1237		switch strings.TrimSpace(a.Activity) {

@@ -1241,7 +1241,7 @@ func agentIsBusy(a *swarm.AgentSnapshot) bool {
1241		return true	1241		return true
1242		}	1242		}
1243			1243
1244	-	// renderSwarmTranscriptBlocks converts the agent's flat transcript	1244	+	// renderSupervisorTranscriptBlocks converts the agent's flat transcript
1245		// log into a slice of display rows styled like the main chat: user	1245		// log into a slice of display rows styled like the main chat: user
1246		// echoes in bubble rows, assistant prose through tui.RenderMarkdown,	1246		// echoes in bubble rows, assistant prose through tui.RenderMarkdown,
1247		// stderr / error chatter tinted. Each output row is fully indented	1247		// stderr / error chatter tinted. Each output row is fully indented

@@ -1252,7 +1252,7 @@ func agentIsBusy(a *swarm.AgentSnapshot) bool {
1252		// whole block together — essential for markdown, which needs the	1252		// whole block together — essential for markdown, which needs the
1253		// full message body in one piece to detect fenced code spans,	1253		// full message body in one piece to detect fenced code spans,
1254		// bullet lists, and so on.	1254		// bullet lists, and so on.
1255	-	func renderSwarmTranscriptBlocks(lines []string, th tui.Theme, width int, compactMode bool) []string {	1255	+	func renderSupervisorTranscriptBlocks(lines []string, th tui.Theme, width int, compactMode bool) []string {
1256		type blockKind int	1256		type blockKind int
1257		const (	1257		const (
1258		kindAssistant blockKind = iota	1258		kindAssistant blockKind = iota

@@ -1342,7 +1342,7 @@ func renderSwarmTranscriptBlocks(lines []string, th tui.Theme, width int, compac
1342		// the pre-built header (frame header for list view, or the agent	1342		// the pre-built header (frame header for list view, or the agent
1343		// metadata block for transcript view); we append onto it and close	1343		// metadata block for transcript view); we append onto it and close
1344		// with the standard frame rule.	1344		// with the standard frame rule.
1345	-	func (d *swarmDialog) renderPromptEditor(th tui.Theme, width int, out []string) []string {	1345	+	func (d *subagentsDialog) renderPromptEditor(th tui.Theme, width int, out []string) []string {
1346		if d.promptEd == nil {	1346		if d.promptEd == nil {
1347		d.openPromptEditor(th, d.promptTargetID)	1347		d.openPromptEditor(th, d.promptTargetID)
1348		}	1348		}

@@ -1375,14 +1375,14 @@ func (d *swarmDialog) renderPromptEditor(th tui.Theme, width int, out []string)
1375		return out	1375		return out
1376		}	1376		}
1377			1377
1378	-	// formatSwarmRow is the one-line summary shown per agent.	1378	+	// formatSupervisorRow is the one-line summary shown per agent.
1379		//	1379		//
1380		// Layout (fixed-width columns, then free-form activity):	1380		// Layout (fixed-width columns, then free-form activity):
1381		//	1381		//
1382		// STATUS ID AGE ACTIVITY	1382		// STATUS ID AGE ACTIVITY
1383		// ● run fix-login-12345 3m editing main.go	1383		// ● run fix-login-12345 3m editing main.go
1384		// ✓ done write-tests-67890 1h done	1384		// ✓ done write-tests-67890 1h done
1385	-	func formatSwarmRow(r swarm.AgentSnapshot, maxWidth int) string {	1385	+	func formatSupervisorRow(r subagents.AgentSnapshot, maxWidth int) string {
1386		status := statusLabel(r.Status)	1386		status := statusLabel(r.Status)
1387		if r.ProcessState != "" && r.TurnState != "" {	1387		if r.ProcessState != "" && r.TurnState != "" {
1388		status = truncateLineSafe(status+" "+string(r.ProcessState)+"/"+string(r.TurnState), 18)	1388		status = truncateLineSafe(status+" "+string(r.ProcessState)+"/"+string(r.TurnState), 18)

@@ -1414,19 +1414,19 @@ func formatSwarmRow(r swarm.AgentSnapshot, maxWidth int) string {
1414			1414
1415		// statusLabel returns a short, padded status badge. Kept stable across	1415		// statusLabel returns a short, padded status badge. Kept stable across
1416		// runs (no colours embedded) so tests can match it deterministically.	1416		// runs (no colours embedded) so tests can match it deterministically.
1417	-	func statusLabel(s swarm.Status) string {	1417	+	func statusLabel(s subagents.Status) string {
1418		switch s {	1418		switch s {
1419	-	case swarm.StatusPending:	1419	+	case subagents.StatusPending:
1420		return "● pend"	1420		return "● pend"
1421	-	case swarm.StatusRunning:	1421	+	case subagents.StatusRunning:
1422		return "● run"	1422		return "● run"
1423	-	case swarm.StatusDone:	1423	+	case subagents.StatusDone:
1424		return "✓ done"	1424		return "✓ done"
1425	-	case swarm.StatusFailed:	1425	+	case subagents.StatusFailed:
1426		return "✗ fail"	1426		return "✗ fail"
1427	-	case swarm.StatusKilled:	1427	+	case subagents.StatusKilled:
1428		return "■ kill"	1428		return "■ kill"
1429	-	case swarm.StatusDetached:	1429	+	case subagents.StatusDetached:
1430		return "○ detach"	1430		return "○ detach"
1431		}	1431		}
1432		return string(s)	1432		return string(s)

R packages/agent/modes/swarm_dialog_test.go → packages/agent/modes/subagents_dialog_test.go +170 -170 renamed, 79% similar


@@ -9,23 +9,23 @@ import (
9		"testing"	9		"testing"
10		"time"	10		"time"
11			11
12	-	"github.com/patriceckhart/zot/packages/agent/swarm"	12	+	"github.com/patriceckhart/zot/packages/agent/subagents"
13		"github.com/patriceckhart/zot/packages/provider"	13		"github.com/patriceckhart/zot/packages/provider"
14		"github.com/patriceckhart/zot/packages/tui"	14		"github.com/patriceckhart/zot/packages/tui"
15		)	15		)
16			16
17		// staticSnapshots returns a deterministic snapshot slice for the	17		// staticSnapshots returns a deterministic snapshot slice for the
18		// dialog to render.	18		// dialog to render.
19	-	func staticSnapshots(rows ...swarm.AgentSnapshot) func() []swarm.AgentSnapshot {	19	+	func staticSnapshots(rows ...subagents.AgentSnapshot) func() []subagents.AgentSnapshot {
20	-	return func() []swarm.AgentSnapshot {	20	+	return func() []subagents.AgentSnapshot {
21	-	out := make([]swarm.AgentSnapshot, len(rows))	21	+	out := make([]subagents.AgentSnapshot, len(rows))
22		copy(out, rows)	22		copy(out, rows)
23		return out	23		return out
24		}	24		}
25		}	25		}
26			26
27	-	func TestSwarmDialogEmptyState(t *testing.T) {	27	+	func TestSubagentsDialogEmptyState(t *testing.T) {
28	-	d := newSwarmDialog()	28	+	d := newSubagentsDialog()
29		d.Open(staticSnapshots(), nil, nil, nil, nil, nil, "")	29		d.Open(staticSnapshots(), nil, nil, nil, nil, nil, "")
30		lines := d.Render(tui.Theme{}, 80)	30		lines := d.Render(tui.Theme{}, 80)
31		joined := strings.Join(lines, "\n")	31		joined := strings.Join(lines, "\n")

@@ -37,13 +37,13 @@ func TestSwarmDialogEmptyState(t *testing.T) {
37		}	37		}
38		}	38		}
39			39
40	-	func TestSwarmDialogRendersRows(t *testing.T) {	40	+	func TestSubagentsDialogRendersRows(t *testing.T) {
41		now := time.Now()	41		now := time.Now()
42	-	rows := []swarm.AgentSnapshot{	42	+	rows := []subagents.AgentSnapshot{
43	-	{ID: "alpha-1", Task: "fix login", Status: swarm.StatusRunning, Activity: "editing file", Started: now},	43	+	{ID: "alpha-1", Task: "fix login", Status: subagents.StatusRunning, Activity: "editing file", Started: now},
44	-	{ID: "beta-2", Task: "write tests", Status: swarm.StatusDone, Activity: "done", Started: now},	44	+	{ID: "beta-2", Task: "write tests", Status: subagents.StatusDone, Activity: "done", Started: now},
45		}	45		}
46	-	d := newSwarmDialog()	46	+	d := newSubagentsDialog()
47		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")	47		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")
48		out := strings.Join(d.Render(tui.Theme{}, 100), "\n")	48		out := strings.Join(d.Render(tui.Theme{}, 100), "\n")
49		for _, want := range []string{"alpha-1", "beta-2", "editing file", "done", "STATUS", "ACTIVITY"} {	49		for _, want := range []string{"alpha-1", "beta-2", "editing file", "done", "STATUS", "ACTIVITY"} {

@@ -53,14 +53,14 @@ func TestSwarmDialogRendersRows(t *testing.T) {
53		}	53		}
54		}	54		}
55			55
56	-	func TestSwarmDialogStopAndRemoveCallbacks(t *testing.T) {	56	+	func TestSubagentsDialogStopAndRemoveCallbacks(t *testing.T) {
57		now := time.Now()	57		now := time.Now()
58	-	rows := []swarm.AgentSnapshot{	58	+	rows := []subagents.AgentSnapshot{
59	-	{ID: "alpha-1", Status: swarm.StatusRunning, Started: now},	59	+	{ID: "alpha-1", Status: subagents.StatusRunning, Started: now},
60		}	60		}
61		stops := 0	61		stops := 0
62		removes := 0	62		removes := 0
63	-	d := newSwarmDialog()	63	+	d := newSubagentsDialog()
64		d.Open(	64		d.Open(
65		staticSnapshots(rows...),	65		staticSnapshots(rows...),
66		func(id string) error { stops++; return nil },	66		func(id string) error { stops++; return nil },

@@ -90,12 +90,12 @@ func TestSwarmDialogStopAndRemoveCallbacks(t *testing.T) {
90		}	90		}
91		}	91		}
92			92
93	-	func TestSwarmDialogEnterShowsTranscript(t *testing.T) {	93	+	func TestSubagentsDialogEnterShowsTranscript(t *testing.T) {
94		now := time.Now()	94		now := time.Now()
95	-	rows := []swarm.AgentSnapshot{	95	+	rows := []subagents.AgentSnapshot{
96	-	{ID: "alpha-1", Task: "do stuff", Status: swarm.StatusDone, Tail: "line a\nline b", Started: now},	96	+	{ID: "alpha-1", Task: "do stuff", Status: subagents.StatusDone, Tail: "line a\nline b", Started: now},
97		}	97		}
98	-	d := newSwarmDialog()	98	+	d := newSubagentsDialog()
99		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")	99		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")
100		_ = d.Render(tui.Theme{}, 80)	100		_ = d.Render(tui.Theme{}, 80)
101		d.HandleKey(tui.Key{Kind: tui.KeyEnter})	101		d.HandleKey(tui.Key{Kind: tui.KeyEnter})

@@ -113,8 +113,8 @@ func TestSwarmDialogEnterShowsTranscript(t *testing.T) {
113		}	113		}
114		}	114		}
115			115
116	-	func TestSwarmDialogEscClosesList(t *testing.T) {	116	+	func TestSubagentsDialogEscClosesList(t *testing.T) {
117	-	d := newSwarmDialog()	117	+	d := newSubagentsDialog()
118		d.Open(staticSnapshots(), nil, nil, nil, nil, nil, "")	118		d.Open(staticSnapshots(), nil, nil, nil, nil, nil, "")
119		closed, _, _ := d.HandleKey(tui.Key{Kind: tui.KeyEsc})	119		closed, _, _ := d.HandleKey(tui.Key{Kind: tui.KeyEsc})
120		if !closed {	120		if !closed {

@@ -125,12 +125,12 @@ func TestSwarmDialogEscClosesList(t *testing.T) {
125		}	125		}
126		}	126		}
127			127
128	-	// TestSwarmDialogSpawnFlow drives the inline n-prompt end-to-end:	128	+	// TestSubagentsDialogSpawnFlow drives the inline n-prompt end-to-end:
129		// press n, type a task, press enter, observe the spawn callback	129		// press n, type a task, press enter, observe the spawn callback
130		// fires with the right text and the prompt closes.	130		// fires with the right text and the prompt closes.
131	-	func TestSwarmDialogSpawnFlow(t *testing.T) {	131	+	func TestSubagentsDialogSpawnFlow(t *testing.T) {
132		var spawned string	132		var spawned string
133	-	d := newSwarmDialog()	133	+	d := newSubagentsDialog()
134		d.Open(	134		d.Open(
135		staticSnapshots(),	135		staticSnapshots(),
136		nil, nil,	136		nil, nil,

@@ -173,13 +173,13 @@ func TestSwarmDialogSpawnFlow(t *testing.T) {
173		}	173		}
174		}	174		}
175			175
176	-	func TestSwarmDialogSpawnFilePickerFlow(t *testing.T) {	176	+	func TestSubagentsDialogSpawnFilePickerFlow(t *testing.T) {
177		cwd := t.TempDir()	177		cwd := t.TempDir()
178		if err := os.WriteFile(filepath.Join(cwd, "README.md"), []byte("hi"), 0o644); err != nil {	178		if err := os.WriteFile(filepath.Join(cwd, "README.md"), []byte("hi"), 0o644); err != nil {
179		t.Fatal(err)	179		t.Fatal(err)
180		}	180		}
181		var spawned string	181		var spawned string
182	-	d := newSwarmDialog()	182	+	d := newSubagentsDialog()
183		d.Open(staticSnapshots(), nil, nil, func(task, _, _ string) error { spawned = task; return nil }, nil, nil, cwd)	183		d.Open(staticSnapshots(), nil, nil, func(task, _, _ string) error { spawned = task; return nil }, nil, nil, cwd)
184		_ = d.Render(tui.Theme{}, 80)	184		_ = d.Render(tui.Theme{}, 80)
185			185

@@ -200,7 +200,7 @@ func TestSwarmDialogSpawnFilePickerFlow(t *testing.T) {
200		}	200		}
201			201
202		// A second Enter submits. The chip should expand to the absolute	202		// A second Enter submits. The chip should expand to the absolute
203	-	// path before the task reaches Swarm.Spawn.	203	+	// path before the task reaches Supervisor.Spawn.
204		_, msg, errMsg := d.HandleKey(tui.Key{Kind: tui.KeyEnter})	204		_, msg, errMsg := d.HandleKey(tui.Key{Kind: tui.KeyEnter})
205		if errMsg != "" {	205		if errMsg != "" {
206		t.Fatalf("unexpected err: %s", errMsg)	206		t.Fatalf("unexpected err: %s", errMsg)

@@ -214,9 +214,9 @@ func TestSwarmDialogSpawnFilePickerFlow(t *testing.T) {
214		}	214		}
215		}	215		}
216			216
217	-	func TestSwarmDialogSpawnEscCancels(t *testing.T) {	217	+	func TestSubagentsDialogSpawnEscCancels(t *testing.T) {
218		called := false	218		called := false
219	-	d := newSwarmDialog()	219	+	d := newSubagentsDialog()
220		d.Open(staticSnapshots(), nil, nil, func(string, string, string) error { called = true; return nil }, nil, nil, "")	220		d.Open(staticSnapshots(), nil, nil, func(string, string, string) error { called = true; return nil }, nil, nil, "")
221		_ = d.Render(tui.Theme{}, 80)	221		_ = d.Render(tui.Theme{}, 80)
222			222

@@ -236,8 +236,8 @@ func TestSwarmDialogSpawnEscCancels(t *testing.T) {
236		}	236		}
237		}	237		}
238			238
239	-	func TestSwarmDialogNoNWithoutSpawnCallback(t *testing.T) {	239	+	func TestSubagentsDialogNoNWithoutSpawnCallback(t *testing.T) {
240	-	d := newSwarmDialog()	240	+	d := newSubagentsDialog()
241		d.Open(staticSnapshots(), nil, nil, nil, nil, nil, "") // spawn callback nil	241		d.Open(staticSnapshots(), nil, nil, nil, nil, nil, "") // spawn callback nil
242		_ = d.Render(tui.Theme{}, 80)	242		_ = d.Render(tui.Theme{}, 80)
243		d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 'n'})	243		d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 'n'})

@@ -246,23 +246,23 @@ func TestSwarmDialogNoNWithoutSpawnCallback(t *testing.T) {
246		}	246		}
247		}	247		}
248			248
249	-	// TestSwarmDialogFullTranscriptRendersEverything pins the /btw-style	249	+	// TestSubagentsDialogFullTranscriptRendersEverything pins the /btw-style
250		// rendering: the dialog NEVER clips the transcript into a fixed	250		// rendering: the dialog NEVER clips the transcript into a fixed
251		// window with internal scroll. Every line goes into the rendered	251		// window with internal scroll. Every line goes into the rendered
252		// output and the host's outer scrollback owns overflow. This is	252		// output and the host's outer scrollback owns overflow. This is
253		// what makes the transcript grow with the window and with the	253		// what makes the transcript grow with the window and with the
254		// content, instead of cutting off at row 16 with a "↑ N more above"	254		// content, instead of cutting off at row 16 with a "↑ N more above"
255		// indicator.	255		// indicator.
256	-	func TestSwarmDialogFullTranscriptRendersEverything(t *testing.T) {	256	+	func TestSubagentsDialogFullTranscriptRendersEverything(t *testing.T) {
257		lines := make([]string, 60)	257		lines := make([]string, 60)
258		for i := range lines {	258		for i := range lines {
259		lines[i] = fmt.Sprintf("line %d", i)	259		lines[i] = fmt.Sprintf("line %d", i)
260		}	260		}
261	-	rows := []swarm.AgentSnapshot{{	261	+	rows := []subagents.AgentSnapshot{{
262	-	ID: "alpha-1", Task: "x", Status: swarm.StatusDone,	262	+	ID: "alpha-1", Task: "x", Status: subagents.StatusDone,
263		Lines: lines, Started: time.Now(),	263		Lines: lines, Started: time.Now(),
264		}}	264		}}
265	-	d := newSwarmDialog()	265	+	d := newSubagentsDialog()
266		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")	266		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")
267		_ = d.Render(tui.Theme{}, 80)	267		_ = d.Render(tui.Theme{}, 80)
268		d.HandleKey(tui.Key{Kind: tui.KeyEnter}) // open viewer	268		d.HandleKey(tui.Key{Kind: tui.KeyEnter}) // open viewer

@@ -289,16 +289,16 @@ func TestSwarmDialogFullTranscriptRendersEverything(t *testing.T) {
289		}	289		}
290		}	290		}
291			291
292	-	// TestSwarmDialogOpenViewingJumpsToAgent regression-tests /swarm logs	292	+	// TestSubagentsDialogOpenViewingJumpsToAgent regression-tests /subagents logs
293		// <id>: OpenViewing should select the row whose id matches the	293		// <id>: OpenViewing should select the row whose id matches the
294		// (possibly truncated) argument and enter the transcript view	294		// (possibly truncated) argument and enter the transcript view
295		// directly without showing the list first.	295		// directly without showing the list first.
296	-	func TestSwarmDialogOpenViewingJumpsToAgent(t *testing.T) {	296	+	func TestSubagentsDialogOpenViewingJumpsToAgent(t *testing.T) {
297	-	rows := []swarm.AgentSnapshot{	297	+	rows := []subagents.AgentSnapshot{
298		{ID: "alpha-1", Lines: []string{"hi from alpha"}, Started: time.Now()},	298		{ID: "alpha-1", Lines: []string{"hi from alpha"}, Started: time.Now()},
299		{ID: "beta-2", Lines: []string{"hi from beta"}, Started: time.Now()},	299		{ID: "beta-2", Lines: []string{"hi from beta"}, Started: time.Now()},
300		}	300		}
301	-	d := newSwarmDialog()	301	+	d := newSubagentsDialog()
302		ok := d.OpenViewing("beta", staticSnapshots(rows...), nil, nil, nil, nil, nil, "")	302		ok := d.OpenViewing("beta", staticSnapshots(rows...), nil, nil, nil, nil, nil, "")
303		if !ok {	303		if !ok {
304		t.Fatal("prefix match did not resolve")	304		t.Fatal("prefix match did not resolve")

@@ -312,24 +312,24 @@ func TestSwarmDialogOpenViewingJumpsToAgent(t *testing.T) {
312		}	312		}
313		}	313		}
314			314
315	-	func TestSwarmDialogOpenViewingUnknownIDReturnsFalse(t *testing.T) {	315	+	func TestSubagentsDialogOpenViewingUnknownIDReturnsFalse(t *testing.T) {
316	-	d := newSwarmDialog()	316	+	d := newSubagentsDialog()
317		ok := d.OpenViewing("nope", staticSnapshots(), nil, nil, nil, nil, nil, "")	317		ok := d.OpenViewing("nope", staticSnapshots(), nil, nil, nil, nil, nil, "")
318		if ok {	318		if ok {
319		t.Fatal("expected miss for unknown id")	319		t.Fatal("expected miss for unknown id")
320		}	320		}
321		}	321		}
322			322
323	-	// TestSwarmDialogPromptFlowFromList drives the inline p-prompt:	323	+	// TestSubagentsDialogPromptFlowFromList drives the inline p-prompt:
324		// press p on the selected agent, type a message, press enter,	324		// press p on the selected agent, type a message, press enter,
325		// and assert the send callback fired with the right id+text.	325		// and assert the send callback fired with the right id+text.
326	-	func TestSwarmDialogPromptFlowFromList(t *testing.T) {	326	+	func TestSubagentsDialogPromptFlowFromList(t *testing.T) {
327	-	rows := []swarm.AgentSnapshot{	327	+	rows := []subagents.AgentSnapshot{
328	-	{ID: "alpha-1", Status: swarm.StatusRunning, Started: time.Now()},	328	+	{ID: "alpha-1", Status: subagents.StatusRunning, Started: time.Now()},
329		}	329		}
330		var gotID, gotText string	330		var gotID, gotText string
331		sends := 0	331		sends := 0
332	-	d := newSwarmDialog()	332	+	d := newSubagentsDialog()
333		d.Open(	333		d.Open(
334		staticSnapshots(rows...),	334		staticSnapshots(rows...),
335		nil, nil, nil,	335		nil, nil, nil,

@@ -371,18 +371,18 @@ func TestSwarmDialogPromptFlowFromList(t *testing.T) {
371		}	371		}
372		}	372		}
373			373
374	-	// TestSwarmDialogPromptFromTranscriptView pins the always-on editor	374	+	// TestSubagentsDialogPromptFromTranscriptView pins the always-on editor
375		// behaviour for the transcript view: entering an agent immediately	375		// behaviour for the transcript view: entering an agent immediately
376		// auto-opens the inline composer (no `p` needed), typing flows	376		// auto-opens the inline composer (no `p` needed), typing flows
377		// straight into it, Enter sends, and the metadata stays visible.	377		// straight into it, Enter sends, and the metadata stays visible.
378		// The transcript view is /btw-style now — you never leave the	378		// The transcript view is /btw-style now — you never leave the
379		// view to send a follow-up.	379		// view to send a follow-up.
380	-	func TestSwarmDialogPromptFromTranscriptView(t *testing.T) {	380	+	func TestSubagentsDialogPromptFromTranscriptView(t *testing.T) {
381	-	rows := []swarm.AgentSnapshot{	381	+	rows := []subagents.AgentSnapshot{
382	-	{ID: "beta-2", Task: "do thing", Status: swarm.StatusRunning, Started: time.Now(), Tail: "hi from beta"},	382	+	{ID: "beta-2", Task: "do thing", Status: subagents.StatusRunning, Started: time.Now(), Tail: "hi from beta"},
383		}	383		}
384		var gotID, gotText string	384		var gotID, gotText string
385	-	d := newSwarmDialog()	385	+	d := newSubagentsDialog()
386		d.Open(	386		d.Open(
387		staticSnapshots(rows...),	387		staticSnapshots(rows...),
388		nil, nil, nil,	388		nil, nil, nil,

@@ -404,7 +404,7 @@ func TestSwarmDialogPromptFromTranscriptView(t *testing.T) {
404		if !strings.Contains(out, "task: do thing") {	404		if !strings.Contains(out, "task: do thing") {
405		t.Fatalf("transcript metadata not visible:\n%s", out)	405		t.Fatalf("transcript metadata not visible:\n%s", out)
406		}	406		}
407	-	if !strings.Contains(out, "swarm: beta-2") {	407	+	if !strings.Contains(out, "subagent: beta-2") {
408		t.Fatalf("frame header missing agent id:\n%s", out)	408		t.Fatalf("frame header missing agent id:\n%s", out)
409		}	409		}
410			410

@@ -430,12 +430,12 @@ func TestSwarmDialogPromptFromTranscriptView(t *testing.T) {
430		}	430		}
431		}	431		}
432			432
433	-	// TestSwarmDialogPromptEscCancels makes sure Esc inside the prompt	433	+	// TestSubagentsDialogPromptEscCancels makes sure Esc inside the prompt
434		// editor aborts without invoking the send callback.	434		// editor aborts without invoking the send callback.
435	-	func TestSwarmDialogPromptEscCancels(t *testing.T) {	435	+	func TestSubagentsDialogPromptEscCancels(t *testing.T) {
436	-	rows := []swarm.AgentSnapshot{{ID: "gamma-3", Status: swarm.StatusRunning, Started: time.Now()}}	436	+	rows := []subagents.AgentSnapshot{{ID: "gamma-3", Status: subagents.StatusRunning, Started: time.Now()}}
437		sends := 0	437		sends := 0
438	-	d := newSwarmDialog()	438	+	d := newSubagentsDialog()
439		d.Open(	439		d.Open(
440		staticSnapshots(rows...),	440		staticSnapshots(rows...),
441		nil, nil, nil,	441		nil, nil, nil,

@@ -457,12 +457,12 @@ func TestSwarmDialogPromptEscCancels(t *testing.T) {
457		}	457		}
458		}	458		}
459			459
460	-	// TestSwarmDialogPWithoutSendCallback verifies that pressing 'p'	460	+	// TestSubagentsDialogPWithoutSendCallback verifies that pressing 'p'
461		// when no send callback is wired is a silent no-op (mirrors the	461		// when no send callback is wired is a silent no-op (mirrors the
462		// existing 'n' / no-spawn-callback contract).	462		// existing 'n' / no-spawn-callback contract).
463	-	func TestSwarmDialogPWithoutSendCallback(t *testing.T) {	463	+	func TestSubagentsDialogPWithoutSendCallback(t *testing.T) {
464	-	rows := []swarm.AgentSnapshot{{ID: "delta-4", Status: swarm.StatusRunning, Started: time.Now()}}	464	+	rows := []subagents.AgentSnapshot{{ID: "delta-4", Status: subagents.StatusRunning, Started: time.Now()}}
465	-	d := newSwarmDialog()	465	+	d := newSubagentsDialog()
466		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")	466		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")
467		_ = d.Render(tui.Theme{}, 80)	467		_ = d.Render(tui.Theme{}, 80)
468		d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 'p'})	468		d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 'p'})

@@ -476,13 +476,13 @@ func TestSwarmDialogPWithoutSendCallback(t *testing.T) {
476		// dialog opens with the cursor on the first detached row (skipping	476		// dialog opens with the cursor on the first detached row (skipping
477		// any leading running ones) so the user can press R immediately.	477		// any leading running ones) so the user can press R immediately.
478		func TestOpenForResumeParksCursorOnFirstResumable(t *testing.T) {	478		func TestOpenForResumeParksCursorOnFirstResumable(t *testing.T) {
479	-	rows := []swarm.AgentSnapshot{	479	+	rows := []subagents.AgentSnapshot{
480	-	{ID: "live-1", Status: swarm.StatusRunning, Started: time.Now()},	480	+	{ID: "live-1", Status: subagents.StatusRunning, Started: time.Now()},
481	-	{ID: "live-2", Status: swarm.StatusRunning, Started: time.Now()},	481	+	{ID: "live-2", Status: subagents.StatusRunning, Started: time.Now()},
482	-	{ID: "detached-1", Status: swarm.StatusDetached, Started: time.Now()},	482	+	{ID: "detached-1", Status: subagents.StatusDetached, Started: time.Now()},
483	-	{ID: "detached-2", Status: swarm.StatusKilled, Started: time.Now()},	483	+	{ID: "detached-2", Status: subagents.StatusKilled, Started: time.Now()},
484		}	484		}
485	-	d := newSwarmDialog()	485	+	d := newSubagentsDialog()
486		count := d.OpenForResume(	486		count := d.OpenForResume(
487		staticSnapshots(rows...),	487		staticSnapshots(rows...),
488		nil, nil, nil, nil,	488		nil, nil, nil, nil,

@@ -506,10 +506,10 @@ func TestOpenForResumeParksCursorOnFirstResumable(t *testing.T) {
506		// slash handler is responsible for surfacing the "no resumable	506		// slash handler is responsible for surfacing the "no resumable
507		// agents" status string — the dialog itself just opens.	507		// agents" status string — the dialog itself just opens.
508		func TestOpenForResumeWithNoResumableLeavesDialogActive(t *testing.T) {	508		func TestOpenForResumeWithNoResumableLeavesDialogActive(t *testing.T) {
509	-	rows := []swarm.AgentSnapshot{	509	+	rows := []subagents.AgentSnapshot{
510	-	{ID: "live-1", Status: swarm.StatusRunning, Started: time.Now()},	510	+	{ID: "live-1", Status: subagents.StatusRunning, Started: time.Now()},
511		}	511		}
512	-	d := newSwarmDialog()	512	+	d := newSubagentsDialog()
513		count := d.OpenForResume(	513		count := d.OpenForResume(
514		staticSnapshots(rows...),	514		staticSnapshots(rows...),
515		nil, nil, nil, nil,	515		nil, nil, nil, nil,

@@ -528,15 +528,15 @@ func TestOpenForResumeWithNoResumableLeavesDialogActive(t *testing.T) {
528		}	528		}
529			529
530		// TestOpenForResumeREnterTriggersResume drives the full picker UX:	530		// TestOpenForResumeREnterTriggersResume drives the full picker UX:
531	-	// /swarm resume → dialog opens parked on a resumable row → user	531	+	// /subagents resume → dialog opens parked on a resumable row → user
532		// presses R → the resume callback fires for that exact id.	532		// presses R → the resume callback fires for that exact id.
533		func TestOpenForResumeREnterTriggersResume(t *testing.T) {	533		func TestOpenForResumeREnterTriggersResume(t *testing.T) {
534	-	rows := []swarm.AgentSnapshot{	534	+	rows := []subagents.AgentSnapshot{
535	-	{ID: "live-1", Status: swarm.StatusRunning, Started: time.Now()},	535	+	{ID: "live-1", Status: subagents.StatusRunning, Started: time.Now()},
536	-	{ID: "detached-1", Status: swarm.StatusDetached, Started: time.Now()},	536	+	{ID: "detached-1", Status: subagents.StatusDetached, Started: time.Now()},
537		}	537		}
538		var resumed string	538		var resumed string
539	-	d := newSwarmDialog()	539	+	d := newSubagentsDialog()
540		d.OpenForResume(	540		d.OpenForResume(
541		staticSnapshots(rows...),	541		staticSnapshots(rows...),
542		nil, nil, nil, nil,	542		nil, nil, nil, nil,

@@ -561,7 +561,7 @@ func TestOpenForResumeREnterTriggersResume(t *testing.T) {
561		// the way of the inline editors (which need the cursor blink).	561		// the way of the inline editors (which need the cursor blink).
562		func TestNeedsTickRefresh(t *testing.T) {	562		func TestNeedsTickRefresh(t *testing.T) {
563		// Closed.	563		// Closed.
564	-	d := newSwarmDialog()	564	+	d := newSubagentsDialog()
565		if d.NeedsTickRefresh() {	565		if d.NeedsTickRefresh() {
566		t.Fatal("closed dialog should not request tick refresh")	566		t.Fatal("closed dialog should not request tick refresh")
567		}	567		}

@@ -573,7 +573,7 @@ func TestNeedsTickRefresh(t *testing.T) {
573		}	573		}
574			574
575		// Transcript view: still background-driven; tick should refresh.	575		// Transcript view: still background-driven; tick should refresh.
576	-	rows := []swarm.AgentSnapshot{{ID: "a", Status: swarm.StatusRunning, Started: time.Now()}}	576	+	rows := []subagents.AgentSnapshot{{ID: "a", Status: subagents.StatusRunning, Started: time.Now()}}
577		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")	577		d.Open(staticSnapshots(rows...), nil, nil, nil, nil, nil, "")
578		_ = d.Render(tui.Theme{}, 80)	578		_ = d.Render(tui.Theme{}, 80)
579		d.HandleKey(tui.Key{Kind: tui.KeyEnter})	579		d.HandleKey(tui.Key{Kind: tui.KeyEnter})

@@ -585,7 +585,7 @@ func TestNeedsTickRefresh(t *testing.T) {
585		}	585		}
586			586
587		// Spawn editor open: tick should NOT refresh (cursor blink).	587		// Spawn editor open: tick should NOT refresh (cursor blink).
588	-	d = newSwarmDialog()	588	+	d = newSubagentsDialog()
589		d.Open(staticSnapshots(), nil, nil, func(string, string, string) error { return nil }, nil, nil, "")	589		d.Open(staticSnapshots(), nil, nil, func(string, string, string) error { return nil }, nil, nil, "")
590		_ = d.Render(tui.Theme{}, 80)	590		_ = d.Render(tui.Theme{}, 80)
591		d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 'n'})	591		d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 'n'})

@@ -597,8 +597,8 @@ func TestNeedsTickRefresh(t *testing.T) {
597		}	597		}
598			598
599		// Prompt editor open: same suppression.	599		// Prompt editor open: same suppression.
600	-	d = newSwarmDialog()	600	+	d = newSubagentsDialog()
601	-	rows = []swarm.AgentSnapshot{{ID: "a", Status: swarm.StatusRunning, Started: time.Now()}}	601	+	rows = []subagents.AgentSnapshot{{ID: "a", Status: subagents.StatusRunning, Started: time.Now()}}
602		d.Open(staticSnapshots(rows...), nil, nil, nil, func(string, string) error { return nil }, nil, "")	602		d.Open(staticSnapshots(rows...), nil, nil, nil, func(string, string) error { return nil }, nil, "")
603		_ = d.Render(tui.Theme{}, 80)	603		_ = d.Render(tui.Theme{}, 80)
604		d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 'p'})	604		d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 'p'})

@@ -616,12 +616,12 @@ func TestNeedsTickRefresh(t *testing.T) {
616		// stayed at the (now-hidden) main editor row when the user	616		// stayed at the (now-hidden) main editor row when the user
617		// pressed 'p', so the visible caret looked wrong.	617		// pressed 'p', so the visible caret looked wrong.
618		func TestCursorPosPromptEditor(t *testing.T) {	618		func TestCursorPosPromptEditor(t *testing.T) {
619	-	rows := []swarm.AgentSnapshot{	619	+	rows := []subagents.AgentSnapshot{
620	-	{ID: "a", Task: "t", Status: swarm.StatusRunning, Started: time.Now()},	620	+	{ID: "a", Task: "t", Status: subagents.StatusRunning, Started: time.Now()},
621		}	621		}
622			622
623		// From the list view.	623		// From the list view.
624	-	d := newSwarmDialog()	624	+	d := newSubagentsDialog()
625		d.Open(staticSnapshots(rows...), nil, nil, nil,	625		d.Open(staticSnapshots(rows...), nil, nil, nil,
626		func(string, string) error { return nil }, nil, "")	626		func(string, string) error { return nil }, nil, "")
627		_ = d.Render(tui.Theme{}, 80)	627		_ = d.Render(tui.Theme{}, 80)

@@ -635,7 +635,7 @@ func TestCursorPosPromptEditor(t *testing.T) {
635		}	635		}
636			636
637		// From the transcript view (deeper offset due to metadata block).	637		// From the transcript view (deeper offset due to metadata block).
638	-	d = newSwarmDialog()	638	+	d = newSubagentsDialog()
639		d.Open(staticSnapshots(rows...), nil, nil, nil,	639		d.Open(staticSnapshots(rows...), nil, nil, nil,
640		func(string, string) error { return nil }, nil, "")	640		func(string, string) error { return nil }, nil, "")
641		_ = d.Render(tui.Theme{}, 80)	641		_ = d.Render(tui.Theme{}, 80)

@@ -651,7 +651,7 @@ func TestCursorPosPromptEditor(t *testing.T) {
651		}	651		}
652			652
653		func TestCursorPosSpawnEditorWithInheritedModelMatchesPaddedRender(t *testing.T) {	653		func TestCursorPosSpawnEditorWithInheritedModelMatchesPaddedRender(t *testing.T) {
654	-	d := newSwarmDialog()	654	+	d := newSubagentsDialog()
655		d.SetCurrentModel("claude-sonnet-4-5", "anthropic")	655		d.SetCurrentModel("claude-sonnet-4-5", "anthropic")
656		d.Open(staticSnapshots(), nil, nil, func(task, model, provider string) error { return nil }, nil, nil, "")	656		d.Open(staticSnapshots(), nil, nil, func(task, model, provider string) error { return nil }, nil, nil, "")
657		_ = d.Render(tui.Theme{}, 80)	657		_ = d.Render(tui.Theme{}, 80)

@@ -670,19 +670,19 @@ func TestCursorPosSpawnEditorWithInheritedModelMatchesPaddedRender(t *testing.T)
670		}	670		}
671		}	671		}
672			672
673	-	// TestSwarmDialogPOnNonRunningAgentShowsHint covers the regression	673	+	// TestSubagentsDialogPOnNonRunningAgentShowsHint covers the regression
674		// caught by the user's screenshot: pressing 'p' on a detached agent	674		// caught by the user's screenshot: pressing 'p' on a detached agent
675		// dialled a dead unix socket and printed the raw path as an error.	675		// dialled a dead unix socket and printed the raw path as an error.
676		// We now block the prompt editor for any non-running status and	676		// We now block the prompt editor for any non-running status and
677		// surface a clear status-bar hint instead.	677		// surface a clear status-bar hint instead.
678	-	func TestSwarmDialogPOnNonRunningAgentShowsHint(t *testing.T) {	678	+	func TestSubagentsDialogPOnNonRunningAgentShowsHint(t *testing.T) {
679	-	for _, st := range []swarm.Status{	679	+	for _, st := range []subagents.Status{
680	-	swarm.StatusDetached, swarm.StatusDone, swarm.StatusFailed, swarm.StatusKilled,	680	+	subagents.StatusDetached, subagents.StatusDone, subagents.StatusFailed, subagents.StatusKilled,
681		} {	681		} {
682		t.Run(string(st), func(t *testing.T) {	682		t.Run(string(st), func(t *testing.T) {
683	-	rows := []swarm.AgentSnapshot{{ID: "a", Status: st, Started: time.Now()}}	683	+	rows := []subagents.AgentSnapshot{{ID: "a", Status: st, Started: time.Now()}}
684		sends := 0	684		sends := 0
685	-	d := newSwarmDialog()	685	+	d := newSubagentsDialog()
686		d.Open(staticSnapshots(rows...), nil, nil, nil,	686		d.Open(staticSnapshots(rows...), nil, nil, nil,
687		func(string, string) error { sends++; return nil }, nil, "")	687		func(string, string) error { sends++; return nil }, nil, "")
688		_ = d.Render(tui.Theme{}, 80)	688		_ = d.Render(tui.Theme{}, 80)

@@ -700,19 +700,19 @@ func TestSwarmDialogPOnNonRunningAgentShowsHint(t *testing.T) {
700		if !strings.Contains(errMsg, string(st)) {	700		if !strings.Contains(errMsg, string(st)) {
701		t.Errorf("hint = %q; should mention status %q", errMsg, st)	701		t.Errorf("hint = %q; should mention status %q", errMsg, st)
702		}	702		}
703	-	if !strings.Contains(errMsg, "resume") && st != swarm.StatusPending && st != swarm.StatusRunning {	703	+	if !strings.Contains(errMsg, "resume") && st != subagents.StatusPending && st != subagents.StatusRunning {
704		t.Errorf("hint = %q; should mention resume for resumable state", errMsg)	704		t.Errorf("hint = %q; should mention resume for resumable state", errMsg)
705		}	705		}
706		})	706		})
707		}	707		}
708		}	708		}
709			709
710	-	// TestSwarmDialogPOnRunningAgentOpensEditor is the positive	710	+	// TestSubagentsDialogPOnRunningAgentOpensEditor is the positive
711		// complement of the previous test: running agents still open the	711		// complement of the previous test: running agents still open the
712		// editor normally.	712		// editor normally.
713	-	func TestSwarmDialogPOnRunningAgentOpensEditor(t *testing.T) {	713	+	func TestSubagentsDialogPOnRunningAgentOpensEditor(t *testing.T) {
714	-	rows := []swarm.AgentSnapshot{{ID: "a", Status: swarm.StatusRunning, Started: time.Now()}}	714	+	rows := []subagents.AgentSnapshot{{ID: "a", Status: subagents.StatusRunning, Started: time.Now()}}
715	-	d := newSwarmDialog()	715	+	d := newSubagentsDialog()
716		d.Open(staticSnapshots(rows...), nil, nil, nil,	716		d.Open(staticSnapshots(rows...), nil, nil, nil,
717		func(string, string) error { return nil }, nil, "")	717		func(string, string) error { return nil }, nil, "")
718		_ = d.Render(tui.Theme{}, 80)	718		_ = d.Render(tui.Theme{}, 80)

@@ -726,11 +726,11 @@ func TestSwarmDialogPOnRunningAgentOpensEditor(t *testing.T) {
726		// user-friendly "isn't accepting input" hint, and unknown errors	726		// user-friendly "isn't accepting input" hint, and unknown errors
727		// fall through verbatim.	727		// fall through verbatim.
728		func TestFriendlySendErrRewritesNotReady(t *testing.T) {	728		func TestFriendlySendErrRewritesNotReady(t *testing.T) {
729	-	hint := friendlySendErr("alpha-1", swarm.ErrNotReady)	729	+	hint := friendlySendErr("alpha-1", subagents.ErrNotReady)
730		if !strings.Contains(hint, "alpha-1") \|\| !strings.Contains(hint, "resume") {	730		if !strings.Contains(hint, "alpha-1") \|\| !strings.Contains(hint, "resume") {
731		t.Errorf("friendlySendErr(ErrNotReady) = %q", hint)	731		t.Errorf("friendlySendErr(ErrNotReady) = %q", hint)
732		}	732		}
733	-	if strings.Contains(hint, "swarm:") {	733	+	if strings.Contains(hint, "subagent:") {
734		t.Errorf("friendlySendErr leaked raw error text: %q", hint)	734		t.Errorf("friendlySendErr leaked raw error text: %q", hint)
735		}	735		}
736			736

@@ -741,11 +741,11 @@ func TestFriendlySendErrRewritesNotReady(t *testing.T) {
741		}	741		}
742		}	742		}
743			743
744	-	// TestRenderSwarmTranscriptBlocks_GroupsByRole asserts the flat	744	+	// TestRenderSupervisorTranscriptBlocks_GroupsByRole asserts the flat
745		// transcript log is regrouped into user / assistant / stderr /	745		// transcript log is regrouped into user / assistant / stderr /
746		// error blocks before rendering. Each output row should be styled	746		// error blocks before rendering. Each output row should be styled
747		// for its role rather than printed verbatim.	747		// for its role rather than printed verbatim.
748	-	func TestRenderSwarmTranscriptBlocks_GroupsByRole(t *testing.T) {	748	+	func TestRenderSupervisorTranscriptBlocks_GroupsByRole(t *testing.T) {
749		lines := []string{	749		lines := []string{
750		"user: hello",	750		"user: hello",
751		"hi there",	751		"hi there",

@@ -753,7 +753,7 @@ func TestRenderSwarmTranscriptBlocks_GroupsByRole(t *testing.T) {
753		"stderr: warning thing",	753		"stderr: warning thing",
754		"error: boom",	754		"error: boom",
755		}	755		}
756	-	out := renderSwarmTranscriptBlocks(lines, tui.Theme{}, 80, false)	756	+	out := renderSupervisorTranscriptBlocks(lines, tui.Theme{}, 80, false)
757		joined := strings.Join(out, "\n")	757		joined := strings.Join(out, "\n")
758			758
759		// The user echo should appear as a bubble row, which contains	759		// The user echo should appear as a bubble row, which contains

@@ -780,17 +780,17 @@ func TestRenderSwarmTranscriptBlocks_GroupsByRole(t *testing.T) {
780		}	780		}
781		}	781		}
782			782
783	-	// TestRenderSwarmTranscriptBlocks_MarkdownStyling proves the	783	+	// TestRenderSupervisorTranscriptBlocks_MarkdownStyling proves the
784		// assistant text goes through tui.RenderMarkdown: a literal bold	784		// assistant text goes through tui.RenderMarkdown: a literal bold
785		// pair should become an ANSI bold sequence and bullet "-" should	785		// pair should become an ANSI bold sequence and bullet "-" should
786		// become "•".	786		// become "•".
787	-	func TestRenderSwarmTranscriptBlocks_MarkdownStyling(t *testing.T) {	787	+	func TestRenderSupervisorTranscriptBlocks_MarkdownStyling(t *testing.T) {
788		lines := []string{	788		lines := []string{
789		"Here is a list:",	789		"Here is a list:",
790		"- bold item",	790		"- bold item",
791		"- plain item",	791		"- plain item",
792		}	792		}
793	-	out := renderSwarmTranscriptBlocks(lines, tui.Theme{}, 80, false)	793	+	out := renderSupervisorTranscriptBlocks(lines, tui.Theme{}, 80, false)
794		joined := strings.Join(out, "\n")	794		joined := strings.Join(out, "\n")
795			795
796		// ANSI bold on/off. Markdown rendering uses CSI 1 / 22.	796		// ANSI bold on/off. Markdown rendering uses CSI 1 / 22.

@@ -807,11 +807,11 @@ func TestRenderSwarmTranscriptBlocks_MarkdownStyling(t *testing.T) {
807		}	807		}
808		}	808		}
809			809
810	-	// TestRenderSwarmTranscriptBlocks_GroupsAdjacentAssistantLines	810	+	// TestRenderSupervisorTranscriptBlocks_GroupsAdjacentAssistantLines
811		// guards the contract that consecutive assistant lines form one	811		// guards the contract that consecutive assistant lines form one
812		// markdown block. If we render each line in isolation, fenced code	812		// markdown block. If we render each line in isolation, fenced code
813		// (and other multi-line constructs) would never close.	813		// (and other multi-line constructs) would never close.
814	-	func TestRenderSwarmTranscriptBlocks_GroupsAdjacentAssistantLines(t *testing.T) {	814	+	func TestRenderSupervisorTranscriptBlocks_GroupsAdjacentAssistantLines(t *testing.T) {
815		lines := []string{	815		lines := []string{
816		"Some prose.",	816		"Some prose.",
817		"```go",	817		"```go",

@@ -821,7 +821,7 @@ func TestRenderSwarmTranscriptBlocks_GroupsAdjacentAssistantLines(t *testing.T)
821		"```",	821		"```",
822		"Done.",	822		"Done.",
823		}	823		}
824	-	out := renderSwarmTranscriptBlocks(lines, tui.Theme{}, 80, false)	824	+	out := renderSupervisorTranscriptBlocks(lines, tui.Theme{}, 80, false)
825		joined := strings.Join(out, "\n")	825		joined := strings.Join(out, "\n")
826			826
827		// The literal fence markers should be consumed by the markdown	827		// The literal fence markers should be consumed by the markdown

@@ -838,19 +838,19 @@ func TestRenderSwarmTranscriptBlocks_GroupsAdjacentAssistantLines(t *testing.T)
838		}	838		}
839		}	839		}
840			840
841	-	// TestSwarmDialogKOnNonRunningAgentShowsHint mirrors the prompt-	841	+	// TestSubagentsDialogKOnNonRunningAgentShowsHint mirrors the prompt-
842		// disabled test: pressing 'k' on an already-terminal or detached	842		// disabled test: pressing 'k' on an already-terminal or detached
843	-	// agent now surfaces a hint instead of routing to Swarm.Stop, which	843	+	// agent now surfaces a hint instead of routing to Supervisor.Stop, which
844		// is a no-op for those states (and used to segfault for detached	844		// is a no-op for those states (and used to segfault for detached
845		// agents before the cancel-nil guard).	845		// agents before the cancel-nil guard).
846	-	func TestSwarmDialogKOnNonRunningAgentShowsHint(t *testing.T) {	846	+	func TestSubagentsDialogKOnNonRunningAgentShowsHint(t *testing.T) {
847	-	for _, st := range []swarm.Status{	847	+	for _, st := range []subagents.Status{
848	-	swarm.StatusDetached, swarm.StatusDone, swarm.StatusFailed, swarm.StatusKilled,	848	+	subagents.StatusDetached, subagents.StatusDone, subagents.StatusFailed, subagents.StatusKilled,
849		} {	849		} {
850		t.Run(string(st), func(t *testing.T) {	850		t.Run(string(st), func(t *testing.T) {
851	-	rows := []swarm.AgentSnapshot{{ID: "a", Status: st, Started: time.Now()}}	851	+	rows := []subagents.AgentSnapshot{{ID: "a", Status: st, Started: time.Now()}}
852		stops := 0	852		stops := 0
853	-	d := newSwarmDialog()	853	+	d := newSubagentsDialog()
854		d.Open(staticSnapshots(rows...),	854		d.Open(staticSnapshots(rows...),
855		func(string) error { stops++; return nil },	855		func(string) error { stops++; return nil },
856		nil, nil, nil, nil, "")	856		nil, nil, nil, nil, "")

@@ -866,14 +866,14 @@ func TestSwarmDialogKOnNonRunningAgentShowsHint(t *testing.T) {
866		}	866		}
867		}	867		}
868			868
869	-	// TestSwarmDialogSpawnFlow_CurrentModelInherited proves the spawn	869	+	// TestSubagentsDialogSpawnFlow_CurrentModelInherited proves the spawn
870		// callback receives whatever model the host pinned via	870		// callback receives whatever model the host pinned via
871		// SetCurrentModel before opening the dialog. This is how /model is	871		// SetCurrentModel before opening the dialog. This is how /model is
872	-	// surfaced to swarm agents: the user picks via /model first, then	872	+	// surfaced to subagent agents: the user picks via /model first, then
873	-	// /swarm n, and the new agent inherits.	873	+	// /subagents n, and the new agent inherits.
874	-	func TestSwarmDialogSpawnFlow_CurrentModelInherited(t *testing.T) {	874	+	func TestSubagentsDialogSpawnFlow_CurrentModelInherited(t *testing.T) {
875		var gotTask, gotModel, gotProv string	875		var gotTask, gotModel, gotProv string
876	-	d := newSwarmDialog()	876	+	d := newSubagentsDialog()
877		d.SetCurrentModel("claude-sonnet-4-5", "anthropic")	877		d.SetCurrentModel("claude-sonnet-4-5", "anthropic")
878		d.Open(staticSnapshots(), nil, nil,	878		d.Open(staticSnapshots(), nil, nil,
879		func(task, model, prov string) error {	879		func(task, model, prov string) error {

@@ -909,14 +909,14 @@ func TestSwarmDialogSpawnFlow_CurrentModelInherited(t *testing.T) {
909		}	909		}
910		}	910		}
911			911
912	-	// TestSwarmDialogSpawnEditor_SlashModelOpensPicker proves the in-	912	+	// TestSubagentsDialogSpawnEditor_SlashModelOpensPicker proves the in-
913		// editor /model command pops the same model dialog the global	913		// editor /model command pops the same model dialog the global
914		// /model uses, that picking a model captures it as the pending	914		// /model uses, that picking a model captures it as the pending
915		// override, and that the spawn editor reopens with any previously-	915		// override, and that the spawn editor reopens with any previously-
916		// typed task text intact so the user doesn't lose work.	916		// typed task text intact so the user doesn't lose work.
917	-	func TestSwarmDialogSpawnEditor_SlashModelOpensPicker(t *testing.T) {	917	+	func TestSubagentsDialogSpawnEditor_SlashModelOpensPicker(t *testing.T) {
918		var gotTask, gotModel, gotProv string	918		var gotTask, gotModel, gotProv string
919	-	d := newSwarmDialog()	919	+	d := newSubagentsDialog()
920		d.SetCurrentModel("old-model", "old-prov")	920		d.SetCurrentModel("old-model", "old-prov")
921		d.Open(staticSnapshots(), nil, nil,	921		d.Open(staticSnapshots(), nil, nil,
922		func(task, model, prov string) error {	922		func(task, model, prov string) error {

@@ -984,12 +984,12 @@ func TestSwarmDialogSpawnEditor_SlashModelOpensPicker(t *testing.T) {
984		}	984		}
985		}	985		}
986			986
987	-	// TestSwarmDialogSpawnEditor_SlashModelEscRestoresDraft confirms	987	+	// TestSubagentsDialogSpawnEditor_SlashModelEscRestoresDraft confirms
988		// pressing Esc inside the picker (no selection) reopens the spawn	988		// pressing Esc inside the picker (no selection) reopens the spawn
989		// editor with the previously-typed text intact AND leaves the	989		// editor with the previously-typed text intact AND leaves the
990		// pending model untouched, so the user can bail out cleanly.	990		// pending model untouched, so the user can bail out cleanly.
991	-	func TestSwarmDialogSpawnEditor_SlashModelEscRestoresDraft(t *testing.T) {	991	+	func TestSubagentsDialogSpawnEditor_SlashModelEscRestoresDraft(t *testing.T) {
992	-	d := newSwarmDialog()	992	+	d := newSubagentsDialog()
993		d.SetCurrentModel("keep-me", "keep-prov")	993		d.SetCurrentModel("keep-me", "keep-prov")
994		d.Open(staticSnapshots(), nil, nil,	994		d.Open(staticSnapshots(), nil, nil,
995		func(string, string, string) error { return nil },	995		func(string, string, string) error { return nil },

@@ -1041,13 +1041,13 @@ func TestStripSlashModelLine(t *testing.T) {
1041		}	1041		}
1042		}	1042		}
1043			1043
1044	-	// TestSwarmDialogSpawnFlow_NoModelInheritsChildDefault confirms that	1044	+	// TestSubagentsDialogSpawnFlow_NoModelInheritsChildDefault confirms that
1045		// when the host doesn't pin a model (SetCurrentModel never called or	1045		// when the host doesn't pin a model (SetCurrentModel never called or
1046		// called with empty strings), the spawn callback receives empty	1046		// called with empty strings), the spawn callback receives empty
1047		// model/provider and the child subprocess resolves its own default.	1047		// model/provider and the child subprocess resolves its own default.
1048	-	func TestSwarmDialogSpawnFlow_NoModelInheritsChildDefault(t *testing.T) {	1048	+	func TestSubagentsDialogSpawnFlow_NoModelInheritsChildDefault(t *testing.T) {
1049		var gotModel, gotProv string	1049		var gotModel, gotProv string
1050	-	d := newSwarmDialog()	1050	+	d := newSubagentsDialog()
1051		d.Open(staticSnapshots(), nil, nil,	1051		d.Open(staticSnapshots(), nil, nil,
1052		func(_, model, prov string) error {	1052		func(_, model, prov string) error {
1053		gotModel, gotProv = model, prov	1053		gotModel, gotProv = model, prov

@@ -1066,20 +1066,20 @@ func TestSwarmDialogSpawnFlow_NoModelInheritsChildDefault(t *testing.T) {
1066		}	1066		}
1067		}	1067		}
1068			1068
1069	-	// TestSwarmTranscriptGrowsWithNewMessages confirms the /btw-style	1069	+	// TestSupervisorTranscriptGrowsWithNewMessages confirms the /btw-style
1070		// "the transcript grows with the content" property: when the agent	1070		// "the transcript grows with the content" property: when the agent
1071		// reply lands in the snapshot, the next render includes it in full,	1071		// reply lands in the snapshot, the next render includes it in full,
1072		// alongside everything that was already there. Replaces the old	1072		// alongside everything that was already there. Replaces the old
1073		// followTail/scroll tests that pinned a viewport mechanic we no	1073		// followTail/scroll tests that pinned a viewport mechanic we no
1074		// longer have.	1074		// longer have.
1075	-	func TestSwarmTranscriptGrowsWithNewMessages(t *testing.T) {	1075	+	func TestSupervisorTranscriptGrowsWithNewMessages(t *testing.T) {
1076	-	cur := []swarm.AgentSnapshot{{	1076	+	cur := []subagents.AgentSnapshot{{
1077	-	ID: "agent-1", Task: "x", Status: swarm.StatusRunning,	1077	+	ID: "agent-1", Task: "x", Status: subagents.StatusRunning,
1078		Lines: []string{"old line 1", "old line 2"}, Started: time.Now(),	1078		Lines: []string{"old line 1", "old line 2"}, Started: time.Now(),
1079		}}	1079		}}
1080	-	snap := func() []swarm.AgentSnapshot { return cur }	1080	+	snap := func() []subagents.AgentSnapshot { return cur }
1081			1081
1082	-	d := newSwarmDialog()	1082	+	d := newSubagentsDialog()
1083		d.Open(snap, nil, nil, nil,	1083		d.Open(snap, nil, nil, nil,
1084		func(string, string) error { return nil },	1084		func(string, string) error { return nil },
1085		nil, "")	1085		nil, "")

@@ -1093,8 +1093,8 @@ func TestSwarmTranscriptGrowsWithNewMessages(t *testing.T) {
1093			1093
1094		// Agent appends a fresh reply: the very next render must show	1094		// Agent appends a fresh reply: the very next render must show
1095		// both the new content AND keep the old content (no clipping).	1095		// both the new content AND keep the old content (no clipping).
1096	-	cur = []swarm.AgentSnapshot{{	1096	+	cur = []subagents.AgentSnapshot{{
1097	-	ID: "agent-1", Task: "x", Status: swarm.StatusRunning,	1097	+	ID: "agent-1", Task: "x", Status: subagents.StatusRunning,
1098		Lines: []string{"old line 1", "old line 2", "new reply A", "new reply B"},	1098		Lines: []string{"old line 1", "old line 2", "new reply A", "new reply B"},
1099		Started: cur[0].Started,	1099		Started: cur[0].Started,
1100		}}	1100		}}

@@ -1106,19 +1106,19 @@ func TestSwarmTranscriptGrowsWithNewMessages(t *testing.T) {
1106		}	1106		}
1107		}	1107		}
1108			1108
1109	-	// TestSwarmTranscriptBtwStyleMultipleSends pins the /btw-style flow	1109	+	// TestSupervisorTranscriptBtwStyleMultipleSends pins the /btw-style flow
1110		// for the transcript view: after one Enter-submit the editor stays	1110		// for the transcript view: after one Enter-submit the editor stays
1111		// mounted and clears, and a second message can be composed and sent	1111		// mounted and clears, and a second message can be composed and sent
1112		// without any modal toggle. Regresses the previous design where	1112		// without any modal toggle. Regresses the previous design where
1113		// every send closed the prompt and forced the user to press `p`	1113		// every send closed the prompt and forced the user to press `p`
1114		// again.	1114		// again.
1115	-	func TestSwarmTranscriptBtwStyleMultipleSends(t *testing.T) {	1115	+	func TestSupervisorTranscriptBtwStyleMultipleSends(t *testing.T) {
1116	-	rows := []swarm.AgentSnapshot{{	1116	+	rows := []subagents.AgentSnapshot{{
1117	-	ID: "agent-1", Task: "x", Status: swarm.StatusRunning, Started: time.Now(),	1117	+	ID: "agent-1", Task: "x", Status: subagents.StatusRunning, Started: time.Now(),
1118		Lines: []string{"warm-up"},	1118		Lines: []string{"warm-up"},
1119		}}	1119		}}
1120		var sent []string	1120		var sent []string
1121	-	d := newSwarmDialog()	1121	+	d := newSubagentsDialog()
1122		d.Open(staticSnapshots(rows...), nil, nil, nil,	1122		d.Open(staticSnapshots(rows...), nil, nil, nil,
1123		func(_, text string) error { sent = append(sent, text); return nil },	1123		func(_, text string) error { sent = append(sent, text); return nil },
1124		nil, "")	1124		nil, "")

@@ -1145,18 +1145,18 @@ func TestSwarmTranscriptBtwStyleMultipleSends(t *testing.T) {
1145		}	1145		}
1146		}	1146		}
1147			1147
1148	-	// TestSwarmTranscriptEscClosesView pins the Esc semantics for the	1148	+	// TestSupervisorTranscriptEscClosesView pins the Esc semantics for the
1149		// /btw-style transcript view: a single Esc closes the whole view	1149		// /btw-style transcript view: a single Esc closes the whole view
1150		// (back to the dashboard list), regardless of whether the editor	1150		// (back to the dashboard list), regardless of whether the editor
1151		// is currently composing. Without this routing the editor's own	1151		// is currently composing. Without this routing the editor's own
1152		// Esc handler would just clear the modal and leave the user stuck	1152		// Esc handler would just clear the modal and leave the user stuck
1153		// inside an empty transcript view.	1153		// inside an empty transcript view.
1154	-	func TestSwarmTranscriptEscClosesView(t *testing.T) {	1154	+	func TestSupervisorTranscriptEscClosesView(t *testing.T) {
1155	-	rows := []swarm.AgentSnapshot{{	1155	+	rows := []subagents.AgentSnapshot{{
1156	-	ID: "agent-1", Task: "x", Status: swarm.StatusRunning, Started: time.Now(),	1156	+	ID: "agent-1", Task: "x", Status: subagents.StatusRunning, Started: time.Now(),
1157		Lines: []string{"hi"},	1157		Lines: []string{"hi"},
1158		}}	1158		}}
1159	-	d := newSwarmDialog()	1159	+	d := newSubagentsDialog()
1160		d.Open(staticSnapshots(rows...), nil, nil, nil,	1160		d.Open(staticSnapshots(rows...), nil, nil, nil,
1161		func(string, string) error { return nil },	1161		func(string, string) error { return nil },
1162		nil, "")	1162		nil, "")

@@ -1175,17 +1175,17 @@ func TestSwarmTranscriptEscClosesView(t *testing.T) {
1175		}	1175		}
1176		}	1176		}
1177			1177
1178	-	// TestSwarmTranscriptNonRunningAgentNoEditor pins the safety net:	1178	+	// TestSupervisorTranscriptNonRunningAgentNoEditor pins the safety net:
1179		// transcripts for done / failed / killed agents must NOT auto-open	1179		// transcripts for done / failed / killed agents must NOT auto-open
1180		// an editor (the agent's inbox isn't listening, so a send would	1180		// an editor (the agent's inbox isn't listening, so a send would
1181		// just bounce). The view shows the transcript plus a hint about	1181		// just bounce). The view shows the transcript plus a hint about
1182		// resuming instead.	1182		// resuming instead.
1183	-	func TestSwarmTranscriptNonRunningAgentNoEditor(t *testing.T) {	1183	+	func TestSupervisorTranscriptNonRunningAgentNoEditor(t *testing.T) {
1184	-	rows := []swarm.AgentSnapshot{{	1184	+	rows := []subagents.AgentSnapshot{{
1185	-	ID: "agent-1", Task: "x", Status: swarm.StatusDone, Started: time.Now(),	1185	+	ID: "agent-1", Task: "x", Status: subagents.StatusDone, Started: time.Now(),
1186		Lines: []string{"all done"},	1186		Lines: []string{"all done"},
1187		}}	1187		}}
1188	-	d := newSwarmDialog()	1188	+	d := newSubagentsDialog()
1189		d.Open(staticSnapshots(rows...), nil, nil, nil,	1189		d.Open(staticSnapshots(rows...), nil, nil, nil,
1190		func(string, string) error { return nil },	1190		func(string, string) error { return nil },
1191		nil, "")	1191		nil, "")

@@ -1200,19 +1200,19 @@ func TestSwarmTranscriptNonRunningAgentNoEditor(t *testing.T) {
1200		}	1200		}
1201		}	1201		}
1202			1202
1203	-	// TestSwarmTranscriptTickRefreshWhileEditing pins the streaming	1203	+	// TestSupervisorTranscriptTickRefreshWhileEditing pins the streaming
1204		// fix: with the always-on editor in transcript view, the host's	1204		// fix: with the always-on editor in transcript view, the host's
1205		// animation tick MUST still call us so streaming agent output	1205		// animation tick MUST still call us so streaming agent output
1206		// renders. Without this, sending a message and watching the reply	1206		// renders. Without this, sending a message and watching the reply
1207		// land silently failed because the prompting=true branch was	1207		// land silently failed because the prompting=true branch was
1208		// suppressing redraws (like the modal editors do).	1208		// suppressing redraws (like the modal editors do).
1209	-	func TestSwarmTranscriptTickRefreshWhileEditing(t *testing.T) {	1209	+	func TestSupervisorTranscriptTickRefreshWhileEditing(t *testing.T) {
1210	-	rows := []swarm.AgentSnapshot{{	1210	+	rows := []subagents.AgentSnapshot{{
1211	-	ID: "agent-1", Task: "x", Status: swarm.StatusRunning,	1211	+	ID: "agent-1", Task: "x", Status: subagents.StatusRunning,
1212		Activity: "thinking", Started: time.Now(),	1212		Activity: "thinking", Started: time.Now(),
1213		Lines: []string{"hello"},	1213		Lines: []string{"hello"},
1214		}}	1214		}}
1215	-	d := newSwarmDialog()	1215	+	d := newSubagentsDialog()
1216		d.Open(staticSnapshots(rows...), nil, nil, nil,	1216		d.Open(staticSnapshots(rows...), nil, nil, nil,
1217		func(string, string) error { return nil },	1217		func(string, string) error { return nil },
1218		nil, "")	1218		nil, "")

@@ -1227,15 +1227,15 @@ func TestSwarmTranscriptTickRefreshWhileEditing(t *testing.T) {
1227		}	1227		}
1228		}	1228		}
1229			1229
1230	-	// TestSwarmTranscriptTickRefreshModalSuppressed pins the inverse:	1230	+	// TestSupervisorTranscriptTickRefreshModalSuppressed pins the inverse:
1231		// the list-view `p` modal (prompting without viewing) still	1231		// the list-view `p` modal (prompting without viewing) still
1232		// suppresses tick like the other modal editors, so the cursor	1232		// suppresses tick like the other modal editors, so the cursor
1233		// blink works cleanly while composing a one-off prompt.	1233		// blink works cleanly while composing a one-off prompt.
1234	-	func TestSwarmTranscriptTickRefreshModalSuppressed(t *testing.T) {	1234	+	func TestSupervisorTranscriptTickRefreshModalSuppressed(t *testing.T) {
1235	-	rows := []swarm.AgentSnapshot{{	1235	+	rows := []subagents.AgentSnapshot{{
1236	-	ID: "agent-1", Status: swarm.StatusRunning, Started: time.Now(),	1236	+	ID: "agent-1", Status: subagents.StatusRunning, Started: time.Now(),
1237		}}	1237		}}
1238	-	d := newSwarmDialog()	1238	+	d := newSubagentsDialog()
1239		d.Open(staticSnapshots(rows...), nil, nil, nil,	1239		d.Open(staticSnapshots(rows...), nil, nil, nil,
1240		func(string, string) error { return nil },	1240		func(string, string) error { return nil },
1241		nil, "")	1241		nil, "")

@@ -1250,18 +1250,18 @@ func TestSwarmTranscriptTickRefreshModalSuppressed(t *testing.T) {
1250		}	1250		}
1251		}	1251		}
1252			1252
1253	-	// TestSwarmTranscriptBusySpinnerRenders proves the inline spinner	1253	+	// TestSupervisorTranscriptBusySpinnerRenders proves the inline spinner
1254		// appears above the always-on editor while the agent is busy and	1254		// appears above the always-on editor while the agent is busy and
1255		// disappears when it goes idle. This is the /btw-style "something	1255		// disappears when it goes idle. This is the /btw-style "something
1256		// is happening" feedback the user was missing.	1256		// is happening" feedback the user was missing.
1257	-	func TestSwarmTranscriptBusySpinnerRenders(t *testing.T) {	1257	+	func TestSupervisorTranscriptBusySpinnerRenders(t *testing.T) {
1258	-	cur := []swarm.AgentSnapshot{{	1258	+	cur := []subagents.AgentSnapshot{{
1259	-	ID: "agent-1", Task: "x", Status: swarm.StatusRunning,	1259	+	ID: "agent-1", Task: "x", Status: subagents.StatusRunning,
1260		Activity: "thinking", Started: time.Now(),	1260		Activity: "thinking", Started: time.Now(),
1261		Lines: []string{"hello"},	1261		Lines: []string{"hello"},
1262		}}	1262		}}
1263	-	snap := func() []swarm.AgentSnapshot { return cur }	1263	+	snap := func() []subagents.AgentSnapshot { return cur }
1264	-	d := newSwarmDialog()	1264	+	d := newSubagentsDialog()
1265		d.Open(snap, nil, nil, nil,	1265		d.Open(snap, nil, nil, nil,
1266		func(string, string) error { return nil },	1266		func(string, string) error { return nil },
1267		nil, "")	1267		nil, "")

@@ -1289,9 +1289,9 @@ func TestSwarmTranscriptBusySpinnerRenders(t *testing.T) {
1289		}	1289		}
1290			1290
1291		func TestStatusLabelCoversAll(t *testing.T) {	1291		func TestStatusLabelCoversAll(t *testing.T) {
1292	-	for _, s := range []swarm.Status{	1292	+	for _, s := range []subagents.Status{
1293	-	swarm.StatusPending, swarm.StatusRunning,	1293	+	subagents.StatusPending, subagents.StatusRunning,
1294	-	swarm.StatusDone, swarm.StatusFailed, swarm.StatusKilled,	1294	+	subagents.StatusDone, subagents.StatusFailed, subagents.StatusKilled,
1295		} {	1295		} {
1296		if statusLabel(s) == "" {	1296		if statusLabel(s) == "" {
1297		t.Fatalf("no label for %s", s)	1297		t.Fatalf("no label for %s", s)

R packages/agent/modes/swarm_slash.go → packages/agent/modes/subagents_slash.go +94 -94 renamed, 60% similar


@@ -5,30 +5,30 @@ import (
5		"fmt"	5		"fmt"
6		"strings"	6		"strings"
7			7
8	-	"github.com/patriceckhart/zot/packages/agent/swarm"	8	+	"github.com/patriceckhart/zot/packages/agent/subagents"
9		"github.com/patriceckhart/zot/packages/provider"	9		"github.com/patriceckhart/zot/packages/provider"
10		"github.com/patriceckhart/zot/packages/tui"	10		"github.com/patriceckhart/zot/packages/tui"
11		)	11		)
12			12
13	-	// runSwarm dispatches /swarm subcommands. Layout:	13	+	// runSubagents dispatches /subagents subcommands. Layout:
14		//	14		//
15	-	// /swarm -> open the dashboard	15	+	// /subagents -> open the dashboard
16	-	// /swarm list -> open the dashboard	16	+	// /subagents list -> open the dashboard
17	-	// /swarm new [--agent A] [--model M] [--provider P] [--reasoning L] <task...>	17	+	// /subagents new [--agent A] [--model M] [--provider P] [--reasoning L] <task...>
18		// -> spawn an agent with optional profile/model overrides	18		// -> spawn an agent with optional profile/model overrides
19	-	// /swarm kill <id> -> stop a running agent	19	+	// /subagents kill <id> -> stop a running agent
20	-	// /swarm remove <id> -> tear down a terminated agent	20	+	// /subagents remove <id> -> tear down a terminated agent
21	-	// /swarm logs <id> -> open the scrollable transcript view	21	+	// /subagents logs <id> -> open the scrollable transcript view
22	-	// /swarm send <id> <text...> -> send a follow-up user turn to <id>	22	+	// /subagents send <id> <text...> -> send a follow-up user turn to <id>
23	-	// /swarm resume [id] -> resume an agent (omit id to pick from a list)	23	+	// /subagents resume [id] -> resume an agent (omit id to pick from a list)
24	-	// /swarm attach <id> -> (planned) drop into the agent's TUI	24	+	// /subagents attach <id> -> (planned) drop into the agent's TUI
25		//	25		//
26	-	// When cfg.Swarm is nil the command tells the user the feature is	26	+	// When cfg.Supervisor is nil the command tells the user the feature is
27		// disabled instead of pretending to work.	27		// disabled instead of pretending to work.
28	-	func (i *Interactive) runSwarm(ctx context.Context, args []string) {	28	+	func (i *Interactive) runSubagents(ctx context.Context, args []string) {
29	-	if i.cfg.Swarm == nil {	29	+	if i.cfg.Supervisor == nil {
30		i.mu.Lock()	30		i.mu.Lock()
31	-	i.statusErr = "swarm is disabled in this build"	31	+	i.statusErr = "subagent is disabled in this build"
32		i.statusOK = ""	32		i.statusOK = ""
33		i.mu.Unlock()	33		i.mu.Unlock()
34		return	34		return

@@ -39,51 +39,51 @@ func (i *Interactive) runSwarm(ctx context.Context, args []string) {
39		if len(args) > 0 {	39		if len(args) > 0 {
40		sub = strings.ToLower(args[0])	40		sub = strings.ToLower(args[0])
41		// Guard the args[1:] reslice: when only the subcommand was	41		// Guard the args[1:] reslice: when only the subcommand was
42	-	// typed (e.g. bare "/swarm new"), args has length 1 and the	42	+	// typed (e.g. bare "/subagents new"), args has length 1 and the
43		// naive args[1:] is fine, but when args is empty (bare	43		// naive args[1:] is fine, but when args is empty (bare
44	-	// "/swarm") the reslice is [1:0] and panics. The len>0 branch	44	+	// "/subagents") the reslice is [1:0] and panics. The len>0 branch
45		// here keeps both cases safe.	45		// here keeps both cases safe.
46		if len(args) > 1 {	46		if len(args) > 1 {
47		rest = strings.TrimSpace(strings.Join(args[1:], " "))	47		rest = strings.TrimSpace(strings.Join(args[1:], " "))
48		}	48		}
49		}	49		}
50			50
51	-	// spawnAdapter, sendAdapter, resumeAdapter wrap the Swarm methods	51	+	// spawnAdapter, sendAdapter, resumeAdapter wrap the Supervisor methods
52		// in the signatures the dialog expects. Defined once here so the	52		// in the signatures the dialog expects. Defined once here so the
53		// three Open()-shaped entry points (list, logs/view-jump, resume)	53		// three Open()-shaped entry points (list, logs/view-jump, resume)
54		// feed the dialog identical callbacks.	54		// feed the dialog identical callbacks.
55		spawnAdapter := func(task, model, provider string) error {	55		spawnAdapter := func(task, model, provider string) error {
56	-	_, err := i.cfg.Swarm.SpawnReq(ctx, swarm.SpawnRequest{	56	+	_, err := i.cfg.Supervisor.SpawnReq(ctx, subagents.SpawnRequest{
57		Task: task, Model: model, Provider: provider, Reasoning: i.cfg.Reasoning,	57		Task: task, Model: model, Provider: provider, Reasoning: i.cfg.Reasoning,
58		})	58		})
59		return err	59		return err
60		}	60		}
61		sendAdapter := func(id, text string) error {	61		sendAdapter := func(id, text string) error {
62	-	return i.cfg.Swarm.SendUserTurn(id, text)	62	+	return i.cfg.Supervisor.SendUserTurn(id, text)
63		}	63		}
64		resumeAdapter := func(id string) error {	64		resumeAdapter := func(id string) error {
65	-	_, err := i.cfg.Swarm.ResumeSession(ctx, id)	65	+	_, err := i.cfg.Supervisor.ResumeSession(ctx, id)
66		return err	66		return err
67		}	67		}
68			68
69		// Pin every fresh spawn to whatever the host's /model selection	69		// Pin every fresh spawn to whatever the host's /model selection
70	-	// is right now. This is captured at /swarm time — if the user	70	+	// is right now. This is captured at /subagents time — if the user
71	-	// wants a different model for the next swarm agent, they pick it	71	+	// wants a different model for the next subagent agent, they pick it
72		// via /model first (globally), or, while inside the spawn	72		// via /model first (globally), or, while inside the spawn
73		// editor, by typing /model on its own line to pop the picker.	73		// editor, by typing /model on its own line to pop the picker.
74	-	i.swarmDialog.SetCompactMode(i.compactModeEnabled())	74	+	i.subagentsDialog.SetCompactMode(i.compactModeEnabled())
75	-	i.swarmDialog.SetLineInput(tui.NormalizeInputStyle(i.cfg.TUIInputStyle) == tui.InputStyleLines)	75	+	i.subagentsDialog.SetLineInput(tui.NormalizeInputStyle(i.cfg.TUIInputStyle) == tui.InputStyleLines)
76	-	i.swarmDialog.SetCurrentModel(i.cfg.Model, i.cfg.Provider)	76	+	i.subagentsDialog.SetCurrentModel(i.cfg.Model, i.cfg.Provider)
77		if i.cfg.LoggedInProviders != nil {	77		if i.cfg.LoggedInProviders != nil {
78	-	i.swarmDialog.SetLoggedInProviders(i.cfg.LoggedInProviders())	78	+	i.subagentsDialog.SetLoggedInProviders(i.cfg.LoggedInProviders())
79		}	79		}
80			80
81		switch sub {	81		switch sub {
82		case "", "list", "ls", "ps":	82		case "", "list", "ls", "ps":
83	-	i.swarmDialog.Open(	83	+	i.subagentsDialog.Open(
84	-	i.cfg.Swarm.SnapshotAll,	84	+	i.cfg.Supervisor.SnapshotAll,
85	-	i.cfg.Swarm.Stop,	85	+	i.cfg.Supervisor.Stop,
86	-	i.cfg.Swarm.Remove,	86	+	i.cfg.Supervisor.Remove,
87		spawnAdapter,	87		spawnAdapter,
88		sendAdapter,	88		sendAdapter,
89		resumeAdapter,	89		resumeAdapter,

@@ -91,7 +91,7 @@ func (i *Interactive) runSwarm(ctx context.Context, args []string) {
91		)	91		)
92		case "new", "spawn":	92		case "new", "spawn":
93		if rest == "" {	93		if rest == "" {
94	-	i.swarmStatus("", "/swarm new <task>: missing task")	94	+	i.subagentsStatus("", "/subagents new <task>: missing task")
95		return	95		return
96		}	96		}
97		// Permit profile/model/provider/reasoning flags before the task	97		// Permit profile/model/provider/reasoning flags before the task

@@ -102,21 +102,21 @@ func (i *Interactive) runSwarm(ctx context.Context, args []string) {
102		var profileTools []string	102		var profileTools []string
103		var fastModeOverride *bool	103		var fastModeOverride *bool
104		if task == "" {	104		if task == "" {
105	-	i.swarmStatus("", "/swarm new: missing task (after any spawn flags)")	105	+	i.subagentsStatus("", "/subagents new: missing task (after any spawn flags)")
106		return	106		return
107		}	107		}
108		if subagent != "" {	108		if subagent != "" {
109		if i.cfg.ResolveSubagent == nil {	109		if i.cfg.ResolveSubagent == nil {
110	-	i.swarmStatus("", "spawn: named subagent profiles are unavailable")	110	+	i.subagentsStatus("", "spawn: named subagent profiles are unavailable")
111		return	111		return
112		}	112		}
113		profile, err := i.cfg.ResolveSubagent(subagent)	113		profile, err := i.cfg.ResolveSubagent(subagent)
114		if err != nil {	114		if err != nil {
115	-	i.swarmStatus("", "spawn: "+err.Error())	115	+	i.subagentsStatus("", "spawn: "+err.Error())
116		return	116		return
117		}	117		}
118		if profile == nil {	118		if profile == nil {
119	-	i.swarmStatus("", "spawn: unknown subagent profile "+subagent)	119	+	i.subagentsStatus("", "spawn: unknown subagent profile "+subagent)
120		return	120		return
121		}	121		}
122		subagent = profile.Name	122		subagent = profile.Name

@@ -145,18 +145,18 @@ func (i *Interactive) runSwarm(ctx context.Context, args []string) {
145		if reasoning != "" {	145		if reasoning != "" {
146		normalizedReasoning, err := normalizeSpawnReasoning(reasoning)	146		normalizedReasoning, err := normalizeSpawnReasoning(reasoning)
147		if err != nil {	147		if err != nil {
148	-	i.swarmStatus("", "spawn: "+err.Error())	148	+	i.subagentsStatus("", "spawn: "+err.Error())
149		return	149		return
150		}	150		}
151		reasoning = normalizedReasoning	151		reasoning = normalizedReasoning
152		}	152		}
153	-	a, err := i.cfg.Swarm.SpawnReq(ctx, swarm.SpawnRequest{	153	+	a, err := i.cfg.Supervisor.SpawnReq(ctx, subagents.SpawnRequest{
154		Task: task, Model: model, Provider: provider, Reasoning: reasoning,	154		Task: task, Model: model, Provider: provider, Reasoning: reasoning,
155		FastMode: fastModeOverride, Subagent: subagent,	155		FastMode: fastModeOverride, Subagent: subagent,
156		Tools: profileTools,	156		Tools: profileTools,
157		})	157		})
158		if err != nil {	158		if err != nil {
159	-	i.swarmStatus("", "spawn: "+err.Error())	159	+	i.subagentsStatus("", "spawn: "+err.Error())
160		return	160		return
161		}	161		}
162		status := "spawned " + a.ID	162		status := "spawned " + a.ID

@@ -165,91 +165,91 @@ func (i *Interactive) runSwarm(ctx context.Context, args []string) {
165		} else if model != "" {	165		} else if model != "" {
166		status += " (model " + model + ")"	166		status += " (model " + model + ")"
167		}	167		}
168	-	i.swarmStatus(status, "")	168	+	i.subagentsStatus(status, "")
169		case "kill", "stop":	169		case "kill", "stop":
170		if rest == "" {	170		if rest == "" {
171	-	i.swarmStatus("", "/subagents kill <id>: missing id")	171	+	i.subagentsStatus("", "/subagents kill <id>: missing id")
172		return	172		return
173		}	173		}
174	-	if err := i.cfg.Swarm.Stop(rest); err != nil {	174	+	if err := i.cfg.Supervisor.Stop(rest); err != nil {
175	-	i.swarmStatus("", "kill: "+err.Error())	175	+	i.subagentsStatus("", "kill: "+err.Error())
176		return	176		return
177		}	177		}
178	-	i.swarmStatus("stopped "+rest, "")	178	+	i.subagentsStatus("stopped "+rest, "")
179		case "cancel":	179		case "cancel":
180		if rest == "" {	180		if rest == "" {
181	-	i.swarmStatus("", "/subagents cancel <id>: missing id")	181	+	i.subagentsStatus("", "/subagents cancel <id>: missing id")
182		return	182		return
183		}	183		}
184	-	if err := i.cfg.Swarm.CancelTurn(rest); err != nil {	184	+	if err := i.cfg.Supervisor.CancelTurn(rest); err != nil {
185	-	i.swarmStatus("", "cancel: "+err.Error())	185	+	i.subagentsStatus("", "cancel: "+err.Error())
186		return	186		return
187		}	187		}
188	-	i.swarmStatus("canceling turn "+rest, "")	188	+	i.subagentsStatus("canceling turn "+rest, "")
189		case "remove", "rm":	189		case "remove", "rm":
190		if rest == "" {	190		if rest == "" {
191	-	i.swarmStatus("", "/swarm remove <id>: missing id")	191	+	i.subagentsStatus("", "/subagents remove <id>: missing id")
192		return	192		return
193		}	193		}
194	-	if err := i.cfg.Swarm.Remove(rest); err != nil {	194	+	if err := i.cfg.Supervisor.Remove(rest); err != nil {
195	-	i.swarmStatus("", "remove: "+err.Error())	195	+	i.subagentsStatus("", "remove: "+err.Error())
196		return	196		return
197		}	197		}
198	-	i.swarmStatus("removed "+rest, "")	198	+	i.subagentsStatus("removed "+rest, "")
199		case "logs", "log", "view":	199		case "logs", "log", "view":
200		if rest == "" {	200		if rest == "" {
201	-	i.swarmStatus("", "/swarm logs <id>: missing id")	201	+	i.subagentsStatus("", "/subagents logs <id>: missing id")
202		return	202		return
203		}	203		}
204	-	ok := i.swarmDialog.OpenViewing(	204	+	ok := i.subagentsDialog.OpenViewing(
205		rest,	205		rest,
206	-	i.cfg.Swarm.SnapshotAll,	206	+	i.cfg.Supervisor.SnapshotAll,
207	-	i.cfg.Swarm.Stop,	207	+	i.cfg.Supervisor.Stop,
208	-	i.cfg.Swarm.Remove,	208	+	i.cfg.Supervisor.Remove,
209		spawnAdapter,	209		spawnAdapter,
210		sendAdapter,	210		sendAdapter,
211		resumeAdapter,	211		resumeAdapter,
212		i.cfg.CWD,	212		i.cfg.CWD,
213		)	213		)
214		if !ok {	214		if !ok {
215	-	i.swarmStatus("", "/swarm logs: no agent matching "+rest)	215	+	i.subagentsStatus("", "/subagents logs: no agent matching "+rest)
216		}	216		}
217		case "result", "inspect":	217		case "result", "inspect":
218		if rest == "" {	218		if rest == "" {
219	-	i.swarmStatus("", "/subagents result <id>: missing id")	219	+	i.subagentsStatus("", "/subagents result <id>: missing id")
220		return	220		return
221		}	221		}
222	-	result, err := i.cfg.Swarm.ReadResult(rest)	222	+	result, err := i.cfg.Supervisor.ReadResult(rest)
223		if err != nil {	223		if err != nil {
224	-	i.swarmStatus("", "result: "+err.Error())	224	+	i.subagentsStatus("", "result: "+err.Error())
225		return	225		return
226		}	226		}
227	-	status := fmt.Sprintf("%s result %s", result.Status, i.cfg.Swarm.ResultReference(rest))	227	+	status := fmt.Sprintf("%s result %s", result.Status, i.cfg.Supervisor.ResultReference(rest))
228		if result.Summary != "" {	228		if result.Summary != "" {
229		status += ": " + truncateStatus(result.Summary, 160)	229		status += ": " + truncateStatus(result.Summary, 160)
230		}	230		}
231	-	i.swarmStatus(status, "")	231	+	i.subagentsStatus(status, "")
232		case "wait":	232		case "wait":
233		if rest == "" {	233		if rest == "" {
234	-	i.swarmStatus("", "/subagents wait <id>: missing id")	234	+	i.subagentsStatus("", "/subagents wait <id>: missing id")
235		return	235		return
236		}	236		}
237	-	a := i.cfg.Swarm.Get(rest)	237	+	a := i.cfg.Supervisor.Get(rest)
238		if a == nil {	238		if a == nil {
239	-	i.swarmStatus("", "wait: no such agent "+rest)	239	+	i.subagentsStatus("", "wait: no such agent "+rest)
240		return	240		return
241		}	241		}
242		go func() {	242		go func() {
243		a.Wait()	243		a.Wait()
244	-	i.swarmStatus("completed "+a.ID, "")	244	+	i.subagentsStatus("completed "+a.ID, "")
245		}()	245		}()
246	-	i.swarmStatus("waiting for "+a.ID, "")	246	+	i.subagentsStatus("waiting for "+a.ID, "")
247		case "resume-session", "resume", "reattach", "reopen":	247		case "resume-session", "resume", "reattach", "reopen":
248		if rest == "" {	248		if rest == "" {
249	-	count := i.swarmDialog.OpenForResume(	249	+	count := i.subagentsDialog.OpenForResume(
250	-	i.cfg.Swarm.SnapshotAll,	250	+	i.cfg.Supervisor.SnapshotAll,
251	-	i.cfg.Swarm.Stop,	251	+	i.cfg.Supervisor.Stop,
252	-	i.cfg.Swarm.Remove,	252	+	i.cfg.Supervisor.Remove,
253		spawnAdapter,	253		spawnAdapter,
254		sendAdapter,	254		sendAdapter,
255		resumeAdapter,	255		resumeAdapter,

@@ -257,61 +257,61 @@ func (i *Interactive) runSwarm(ctx context.Context, args []string) {
257		)	257		)
258		switch count {	258		switch count {
259		case 0:	259		case 0:
260	-	i.swarmStatus("", "/subagents resume-session: no resumable agents")	260	+	i.subagentsStatus("", "/subagents resume-session: no resumable agents")
261		case 1:	261		case 1:
262	-	i.swarmStatus("1 resumable agent, press R to resume", "")	262	+	i.subagentsStatus("1 resumable agent, press R to resume", "")
263		default:	263		default:
264	-	i.swarmStatus(fmt.Sprintf("%d resumable agents, ↑/↓ to pick, R to resume", count), "")	264	+	i.subagentsStatus(fmt.Sprintf("%d resumable agents, ↑/↓ to pick, R to resume", count), "")
265		}	265		}
266		return	266		return
267		}	267		}
268	-	a, err := i.cfg.Swarm.ResumeSession(ctx, rest)	268	+	a, err := i.cfg.Supervisor.ResumeSession(ctx, rest)
269		if err != nil {	269		if err != nil {
270	-	i.swarmStatus("", "resume-session: "+err.Error())	270	+	i.subagentsStatus("", "resume-session: "+err.Error())
271		return	271		return
272		}	272		}
273	-	i.swarmStatus("resumed "+a.ID, "")	273	+	i.subagentsStatus("resumed "+a.ID, "")
274		case "restart-task", "restart":	274		case "restart-task", "restart":
275		if rest == "" {	275		if rest == "" {
276	-	i.swarmStatus("", "/subagents restart-task <id>: missing id")	276	+	i.subagentsStatus("", "/subagents restart-task <id>: missing id")
277		return	277		return
278		}	278		}
279	-	a, err := i.cfg.Swarm.RestartTask(ctx, rest)	279	+	a, err := i.cfg.Supervisor.RestartTask(ctx, rest)
280		if err != nil {	280		if err != nil {
281	-	i.swarmStatus("", "restart-task: "+err.Error())	281	+	i.subagentsStatus("", "restart-task: "+err.Error())
282		return	282		return
283		}	283		}
284	-	i.swarmStatus("restarted task "+a.ID, "")	284	+	i.subagentsStatus("restarted task "+a.ID, "")
285		case "send", "prompt", "msg":	285		case "send", "prompt", "msg":
286	-	// /swarm send <id> <text...> is the non-interactive	286	+	// /subagents send <id> <text...> is the non-interactive
287		// counterpart of pressing 'p' in the dashboard. We split the	287		// counterpart of pressing 'p' in the dashboard. We split the
288		// joined `rest` ourselves rather than reusing the dispatcher's	288		// joined `rest` ourselves rather than reusing the dispatcher's
289		// already-fielded args[] because the text may contain spaces	289		// already-fielded args[] because the text may contain spaces
290		// the user expects to be preserved verbatim.	290		// the user expects to be preserved verbatim.
291		id, text := splitIDAndRest(rest)	291		id, text := splitIDAndRest(rest)
292		if id == "" {	292		if id == "" {
293	-	i.swarmStatus("", "/swarm send <id> <text>: missing id")	293	+	i.subagentsStatus("", "/subagents send <id> <text>: missing id")
294		return	294		return
295		}	295		}
296		if text == "" {	296		if text == "" {
297	-	i.swarmStatus("", "/swarm send <id> <text>: missing text")	297	+	i.subagentsStatus("", "/subagents send <id> <text>: missing text")
298		return	298		return
299		}	299		}
300	-	if err := i.cfg.Swarm.SendUserTurn(id, text); err != nil {	300	+	if err := i.cfg.Supervisor.SendUserTurn(id, text); err != nil {
301	-	i.swarmStatus("", friendlySendErr(id, err))	301	+	i.subagentsStatus("", friendlySendErr(id, err))
302		return	302		return
303		}	303		}
304	-	i.swarmStatus("sent to "+id, "")	304	+	i.subagentsStatus("sent to "+id, "")
305		case "attach":	305		case "attach":
306		// PTY-reparenting is a significant chunk of work I haven't	306		// PTY-reparenting is a significant chunk of work I haven't
307		// landed yet (see the design sketch). Recognise the name so	307		// landed yet (see the design sketch). Recognise the name so
308	-	// /swarm attach doesn't fall through to the generic "unknown	308	+	// /subagents attach doesn't fall through to the generic "unknown
309		// subcommand" path — that error message is misleading because	309		// subcommand" path — that error message is misleading because
310		// it makes attach sound like a typo instead of a planned	310		// it makes attach sound like a typo instead of a planned
311	-	// feature. Point the user at /swarm logs in the meantime.	311	+	// feature. Point the user at /subagents logs in the meantime.
312	-	i.swarmStatus("", "/swarm attach: not implemented yet (needs PTY reparenting). Use /swarm logs "+firstWord(rest)+" to watch its transcript.")	312	+	i.subagentsStatus("", "/subagents attach: not implemented yet (needs PTY reparenting). Use /subagents logs "+firstWord(rest)+" to watch its transcript.")
313		default:	313		default:
314	-	i.swarmStatus("", "/subagents: unknown subcommand "+sub+" (try list / new / kill / remove / logs / send / result / resume-session / restart-task)")	314	+	i.subagentsStatus("", "/subagents: unknown subcommand "+sub+" (try list / new / kill / remove / logs / send / result / resume-session / restart-task)")
315		}	315		}
316		}	316		}
317			317

@@ -418,7 +418,7 @@ func splitIDAndRest(s string) (id, text string) {
418		}	418		}
419			419
420		// firstWord returns the first whitespace-separated token of s, or	420		// firstWord returns the first whitespace-separated token of s, or
421	-	// "<id>" when s is empty. Used to keep the "/swarm attach" hint	421	+	// "<id>" when s is empty. Used to keep the "/subagents attach" hint
422		// readable even when the user typed no argument.	422		// readable even when the user typed no argument.
423		func firstWord(s string) string {	423		func firstWord(s string) string {
424		s = strings.TrimSpace(s)	424		s = strings.TrimSpace(s)

@@ -442,7 +442,7 @@ func truncateStatus(value string, max int) string {
442		return string([]rune(value)[:max-3]) + "..."	442		return string([]rune(value)[:max-3]) + "..."
443		}	443		}
444			444
445	-	func (i *Interactive) swarmStatus(ok, errMsg string) {	445	+	func (i *Interactive) subagentsStatus(ok, errMsg string) {
446		i.mu.Lock()	446		i.mu.Lock()
447		i.statusOK = ok	447		i.statusOK = ok
448		i.statusErr = errMsg	448		i.statusErr = errMsg

R packages/agent/modes/swarm_slash_test.go → packages/agent/modes/subagents_slash_test.go +73 -64 renamed, 59% similar

 	"time"
 	"github.com/patriceckhart/zot/packages/agent/subagents"
-	"github.com/patriceckhart/zot/packages/agent/swarm"
 )
-// newInteractiveForSwarmTest builds the minimal Interactive scaffolding
+// newInteractiveForSupervisorTest builds the minimal Interactive scaffolding
-// runSwarm needs. It does NOT call NewInteractive (which would pull in
+// runSubagents needs. It does NOT call NewInteractive (which would pull in
-// the whole TUI); the runSwarm method only touches cfg.Swarm, the
+// the whole TUI); the runSubagents method only touches cfg.Supervisor, the
-// status mutex, and the swarm dialog, so we hand-build those.
+// status mutex, and the subagent dialog, so we hand-build those.
-func newInteractiveForSwarmTest(t *testing.T) (*Interactive, *swarm.Swarm) {
+func newInteractiveForSupervisorTest(t *testing.T) (*Interactive, *subagents.Supervisor) {
 	t.Helper()
 	root := t.TempDir()
-	f := swarm.New(swarm.Config{
+	f := subagents.New(subagents.Config{
 		Root:     root,
 		RepoRoot: root,
-		NewRunner: func(a *swarm.Agent) swarm.Runner {
+		NewRunner: func(a *subagents.Agent) subagents.Runner {
-			return swarm.RunnerFunc(func(ctx context.Context, sink swarm.Sink) error {
+			return subagents.RunnerFunc(func(ctx context.Context, sink subagents.Sink) error {
 				<-ctx.Done()
 				return ctx.Err()
 			})
 		},
 	})
 	iv := &Interactive{
-		swarmDialog: newSwarmDialog(),
+		subagentsDialog: newSubagentsDialog(),
-		dirty:       make(chan struct{}, 1),
+		dirty:           make(chan struct{}, 1),
 	}
-	iv.cfg.Swarm = f
+	iv.cfg.Supervisor = f
 	return iv, f
 }
-// TestRunSwarmBareDoesNotPanic regression-tests the slice-out-of-range
+// TestRunSupervisorBareDoesNotPanic regression-tests the slice-out-of-range
-// panic that hit when /swarm was typed with no subcommand: runSwarm
+// panic that hit when /subagents was typed with no subcommand: runSubagents
 // did args[1:] without checking len(args), which panics as [1:0].
-func TestRunSwarmBareDoesNotPanic(t *testing.T) {
+func TestRunSupervisorBareDoesNotPanic(t *testing.T) {
-	iv, _ := newInteractiveForSwarmTest(t)
+	iv, _ := newInteractiveForSupervisorTest(t)
-	defer iv.cfg.Swarm.StopAll()
+	defer iv.cfg.Supervisor.StopAll()
-	// Bare /swarm: parts[1:] from the dispatcher is an empty slice.
+	// Bare /subagents: parts[1:] from the dispatcher is an empty slice.
-	iv.runSwarm(context.Background(), nil)
+	iv.runSubagents(context.Background(), nil)
-	if !iv.swarmDialog.Active() {
+	if !iv.subagentsDialog.Active() {
-		t.Fatal("bare /swarm should open the dashboard")
+		t.Fatal("bare /subagents should open the dashboard")
 	}
 }
-func TestRunSwarmSubcommandsDoNotPanic(t *testing.T) {
+func TestRunSupervisorSubcommandsDoNotPanic(t *testing.T) {
-	iv, _ := newInteractiveForSwarmTest(t)
+	iv, _ := newInteractiveForSupervisorTest(t)
-	defer iv.cfg.Swarm.StopAll()
+	defer iv.cfg.Supervisor.StopAll()
-	// Each row is the slice that the dispatcher hands to runSwarm —
+	// Each row is the slice that the dispatcher hands to runSubagents —
 	// i.e. parts[1:] where parts was strings.Fields of the slash
 	// command. Mixing zero-arg and arg'd forms exercises both
 	// branches of the reslice guard.
 		func() {
 			defer func() {
 				if r := recover(); r != nil {
-					t.Fatalf("runSwarm(%v) panicked: %v", args, r)
+					t.Fatalf("runSubagents(%v) panicked: %v", args, r)
 				}
 			}()
-			iv.runSwarm(context.Background(), args)
+			iv.runSubagents(context.Background(), args)
 		}()
 	}
 }
-func TestRunSwarmRejectsNamedProfileWithoutResolver(t *testing.T) {
+func TestRunSupervisorRejectsNamedProfileWithoutResolver(t *testing.T) {
-	iv, f := newInteractiveForSwarmTest(t)
+	iv, f := newInteractiveForSupervisorTest(t)
 	defer f.StopAll()
-	iv.runSwarm(context.Background(), []string{"new", "--agent", "reviewer", "review", "auth"})
+	iv.runSubagents(context.Background(), []string{"new", "--agent", "reviewer", "review", "auth"})
 	if !strings.Contains(iv.statusErr, "named subagent profiles are unavailable") {
 		t.Fatalf("status error = %q, want unavailable profile resolver", iv.statusErr)
 	}
 	}
 }
-func TestRunSwarmNewSpawnsAgent(t *testing.T) {
+func TestRunSupervisorNewSpawnsAgent(t *testing.T) {
-	iv, f := newInteractiveForSwarmTest(t)
+	iv, f := newInteractiveForSupervisorTest(t)
 	defer f.StopAll()
-	iv.runSwarm(context.Background(), []string{"new", "do", "stuff"})
+	iv.runSubagents(context.Background(), []string{"new", "do", "stuff"})
 	agents := f.List()
 	if len(agents) != 1 {
 		t.Fatalf("want 1 agent; got %d", len(agents))
 	}
 }
-func TestRunSwarmNamedProfileAppliesFastModeRestriction(t *testing.T) {
+func TestRunSupervisorNamedProfileAppliesFastModeRestriction(t *testing.T) {
 	root := t.TempDir()
 	profileFastMode := false
-	f := swarm.New(swarm.Config{
+	f := subagents.New(subagents.Config{
 		Root:     root,
 		RepoRoot: root,
 		FastMode: true,
-		NewRunner: func(*swarm.Agent) swarm.Runner {
+		NewRunner: func(*subagents.Agent) subagents.Runner {
-			return swarm.RunnerFunc(func(ctx context.Context, _ swarm.Sink) error {
+			return subagents.RunnerFunc(func(ctx context.Context, _ subagents.Sink) error {
 				<-ctx.Done()
 				return ctx.Err()
 			})
 		},
 	})
 	defer f.StopAll()
-	iv := &Interactive{swarmDialog: newSwarmDialog(), dirty: make(chan struct{}, 1)}
+	iv := &Interactive{subagentsDialog: newSubagentsDialog(), dirty: make(chan struct{}, 1)}
-	iv.cfg.Swarm = f
+	iv.cfg.Supervisor = f
 	iv.cfg.ResolveSubagent = func(name string) (*subagents.Profile, error) {
 		if name != "reviewer" {
 			return nil, nil
 		return &subagents.Profile{Name: name, FastMode: &profileFastMode}, nil
 	}
-	iv.runSwarm(context.Background(), []string{"new", "--agent", "reviewer", "review", "auth"})
+	iv.runSubagents(context.Background(), []string{"new", "--agent", "reviewer", "review", "auth"})
 	agents := f.List()
 	if len(agents) != 1 || agents[0].FastMode {
 		t.Fatalf("agent fast mode = %#v, want disabled by profile", agents)
 	}
 }
-// TestRunSwarmSendDeliversToAgentInbox spins up a real agent with a
+// TestRunSupervisorSendDeliversToAgentInbox spins up a real agent with a
 // fake Runner whose only job is to forward inbox lines to a channel,
-// then asserts the /swarm send <id> <text...> path routes through
+// then asserts the /subagents send <id> <text...> path routes through
-// Swarm.SendUserTurn and lands at the agent verbatim.
+// Supervisor.SendUserTurn and lands at the agent verbatim.
-func TestRunSwarmSendDeliversToAgentInbox(t *testing.T) {
+func TestRunSupervisorSendDeliversToAgentInbox(t *testing.T) {
 	if runtime.GOOS == "windows" {
-		t.Skip("swarm inbox transport uses Unix-domain sockets")
+		t.Skip("subagent inbox transport uses Unix-domain sockets")
 	}
 	root := t.TempDir()
 	recv := make(chan string, 4)
 	ready := make(chan error, 1)
-	f := swarm.New(swarm.Config{
+	f := subagents.New(subagents.Config{
 		Root:     root,
 		RepoRoot: root,
-		NewRunner: func(a *swarm.Agent) swarm.Runner {
+		NewRunner: func(a *subagents.Agent) subagents.Runner {
-			return swarm.RunnerFunc(func(ctx context.Context, sink swarm.Sink) error {
+			return subagents.RunnerFunc(func(ctx context.Context, sink subagents.Sink) error {
 				// Stand up a real Listener on the agent's inbox path so
 				// SendUserTurn (which dials a unix socket) actually has
 				// something to talk to. The runner-test stubs do the
 				// same; this is the minimum to exercise the wire.
-				ln, err := swarm.Listen(a.InboxPath)
+				ln, err := subagents.Listen(a.InboxPath)
 				ready <- err
 				if err != nil {
 					return err
 		},
 	})
 	defer f.StopAll()
-	iv := &Interactive{swarmDialog: newSwarmDialog(), dirty: make(chan struct{}, 1)}
+	iv := &Interactive{subagentsDialog: newSubagentsDialog(), dirty: make(chan struct{}, 1)}
-	iv.cfg.Swarm = f
+	iv.cfg.Supervisor = f
 	a, err := f.Spawn(context.Background(), "do thing")
 	if err != nil {
 		t.Fatal("timed out waiting for agent inbox listener")
 	}
-	// Run /swarm send <id> <text...>. The dispatcher would have
+	// Run /subagents send <id> <text...>. The dispatcher would have
 	// already strings.Fields-ed the input; mirror that here.
-	iv.runSwarm(context.Background(), []string{"send", a.ID, "please", "continue"})
+	iv.runSubagents(context.Background(), []string{"send", a.ID, "please", "continue"})
 	select {
 	case msg := <-recv:
-		want := "user please continue"
+		command, parseErr := subagents.ParseCommand(msg)
-		if msg != want {
+		if parseErr != nil {
-			t.Fatalf("agent received %q; want %q", msg, want)
+			t.Fatalf("agent received invalid command %q: %v", msg, parseErr)
+		}
+		if command.Type != subagents.CommandTurnStart {
+			t.Fatalf("agent received command %q; want %q", command.Type, subagents.CommandTurnStart)
+		}
+		var payload subagents.TurnStartPayload
+		if err := command.DecodePayload(&payload); err != nil {
+			t.Fatalf("decode turn.start payload: %v", err)
+		}
+		if payload.Prompt != "please continue" {
+			t.Fatalf("agent received prompt %q; want %q", payload.Prompt, "please continue")
 		}
 	case <-time.After(2 * time.Second):
 		t.Fatal("timed out waiting for agent to receive the prompt")
 	}
 }
-func TestRunSwarmWithoutSwarmIsNoop(t *testing.T) {
+func TestRunSupervisorWithoutSupervisorIsNoop(t *testing.T) {
 	iv := &Interactive{
-		swarmDialog: newSwarmDialog(),
+		subagentsDialog: newSubagentsDialog(),
-		dirty:       make(chan struct{}, 1),
+		dirty:           make(chan struct{}, 1),
 	}
-	// cfg.Swarm stays nil. The command should set a status err and
+	// cfg.Supervisor stays nil. The command should set a status err and
 	// otherwise be inert.
-	iv.runSwarm(context.Background(), nil)
+	iv.runSubagents(context.Background(), nil)
-	if iv.swarmDialog.Active() {
+	if iv.subagentsDialog.Active() {
-		t.Fatal("dialog opened despite no swarm")
+		t.Fatal("dialog opened despite no subagent")
 	}
 	if iv.statusErr == "" {
-		t.Fatal("expected a status error when swarm is nil")
+		t.Fatal("expected a status error when subagent is nil")
 	}
 }

M packages/agent/settings_store.go +10 -10


@@ -59,12 +59,12 @@ func (configSettingsStore) SetTerminalTitleEnabled(enabled bool) error {
59		return SaveConfig(cfg)	59		return SaveConfig(cfg)
60		}	60		}
61			61
62	-	func (configSettingsStore) SetAutoSwarm(enabled bool) error {	62	+	func (configSettingsStore) SetAutoSubagents(enabled bool) error {
63		cfg, err := LoadConfig()	63		cfg, err := LoadConfig()
64		if err != nil {	64		if err != nil {
65		return err	65		return err
66		}	66		}
67	-	cfg.AutoSwarmEnabled = &enabled	67	+	cfg.AutoSubagentsEnabled = &enabled
68		return SaveConfig(cfg)	68		return SaveConfig(cfg)
69		}	69		}
70			70

@@ -212,24 +212,24 @@ func (configSettingsStore) SetTheme(name string) error {
212		return SaveConfig(cfg)	212		return SaveConfig(cfg)
213		}	213		}
214			214
215	-	// AutoSwarmEnabled reads the current auto-swarm flag from config.	215	+	// AutoSubagentsEnabled reads the current auto-subagents flag from config.
216	-	// Used by the subagent_spawn/swarm_spawn tools at call time to gate execution.	216	+	// Used by the subagent_spawn tool at call time to gate execution.
217	-	func AutoSwarmEnabled() bool {	217	+	func AutoSubagentsEnabled() bool {
218		cfg, err := LoadConfig()	218		cfg, err := LoadConfig()
219		if err != nil {	219		if err != nil {
220		return false	220		return false
221		}	221		}
222	-	return cfg.AutoSwarmEnabled != nil && *cfg.AutoSwarmEnabled	222	+	return cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled
223		}	223		}
224			224
225	-	// AutoSwarmSystemAddendum is appended to the system prompt when	225	+	// AutoSubagentsSystemAddendum is appended to the system prompt when
226	-	// auto-swarm is enabled, so the model knows it may delegate to	226	+	// auto-subagents is enabled, so the model knows it may delegate to
227		// background sub-agents without the user having to mention the tool	227		// background sub-agents without the user having to mention the tool
228		// by name. Kept short so it doesn't bloat the cached prompt prefix.	228		// by name. Kept short so it doesn't bloat the cached prompt prefix.
229	-	const AutoSwarmSystemAddendum = `Auto-swarm is enabled. You have a subagent_spawn tool (with swarm_spawn as a compatibility alias) that starts background sub-agents in separate long-lived processes.	229	+	const AutoSubagentsSystemAddendum = `Auto-subagents are enabled. You have a subagent_spawn tool that starts background sub-agents in separate long-lived processes.
230			230
231		Use it proactively when the user's request naturally splits into independent sub-tasks that can run concurrently; prefer isolation:"worktree" for parallel coding and use the returned result_ref/event path for completion (e.g. "refactor module A and module B", "write the implementation and the tests", "investigate three separate files"). Spawn one sub-agent per independent sub-task with a self-contained task description (sub-agents start with no context from this conversation). If [subagents_list] is present, choose the named profile whose description best matches the task and pass its name as the tool's agent field. Continue working on the remaining or coordinating work yourself in parallel; do not wait for sub-agents to finish before responding. Briefly tell the user which sub-agents you spawned and what each is doing.	231		Use it proactively when the user's request naturally splits into independent sub-tasks that can run concurrently; prefer isolation:"worktree" for parallel coding and use the returned result_ref/event path for completion (e.g. "refactor module A and module B", "write the implementation and the tests", "investigate three separate files"). Spawn one sub-agent per independent sub-task with a self-contained task description (sub-agents start with no context from this conversation). If [subagents_list] is present, choose the named profile whose description best matches the task and pass its name as the tool's agent field. Continue working on the remaining or coordinating work yourself in parallel; do not wait for sub-agents to finish before responding. Briefly tell the user which sub-agents you spawned and what each is doing.
232			232
233		Do NOT use subagent_spawn for trivial single-step work, for tasks that depend on each other sequentially, or when the user explicitly asked you to do the work yourself. Child workers cannot recursively spawn more sub-agents in v1.	233		Do NOT use subagent_spawn for trivial single-step work, for tasks that depend on each other sequentially, or when the user explicitly asked you to do the work yourself. Child workers cannot recursively spawn more sub-agents in v1.
234			234
235	-	When every sub-agent you spawned reaches a terminal state, the host injects a single [auto-swarm update] message recapping each agent's status, task, and result reference. Treat that message as observed state (not as a new user request) and write a short follow-up summary referencing each agent by id.`	235	+	When every sub-agent you spawned reaches a terminal state, the host injects a single [auto-subagents update] message recapping each agent's status, task, and result reference. Treat that message as observed state (not as a new user request) and write a short follow-up summary referencing each agent by id.`

R packages/agent/swarm_agent.go → packages/agent/subagent_worker.go +56 -108 renamed, 75% similar

 package agent
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
 	"unicode/utf8"
 	"github.com/patriceckhart/zot/packages/agent/modes"
-	"github.com/patriceckhart/zot/packages/agent/swarm"
+	"github.com/patriceckhart/zot/packages/agent/subagents"
 	"github.com/patriceckhart/zot/packages/core"
 	"github.com/patriceckhart/zot/packages/provider"
 )
-// runSwarmAgentMode is the daemon-mode entry point used by every
+// runSubagentWorkerMode is the daemon-mode entry point used by every
-// swarm-spawned zot subprocess. It's intentionally close in shape to
+// subagent-spawned zot subprocess. It's intentionally close in shape to
 // runJSONMode but with two key differences:
 //
 //   - Lifetime: the process stays alive across many user turns. The
 //     initial positional task (if any) is the first turn; subsequent
-//     turns arrive through the inbox unix socket at args.SwarmAgent.
+//     turns arrive through the inbox unix socket at args.SubagentWorker.
 //
 //   - Output: every emitted JSON line is also mirrored verbatim into
-//     events.jsonl (see ZOT_SWARM_EVENT_LOG) so a separate zot
+//     events.jsonl (see ZOT_SUBAGENT_EVENT_LOG) so a separate zot
-//     process can /swarm open this agent and replay its full history
+//     process can /subagents open this agent and replay its full history
 //     even after the parent that spawned us is long gone.
 //
-// The runner in packages/agent/swarm/runner.go is the only caller in
+// The runner in packages/agent/subagents/runner.go is the only caller in
 // production; tests use the stubchild binary under
-// packages/agent/swarm/testdata/cmd/stubchild instead of the real model
+// packages/agent/subagents/testdata/cmd/stubchild instead of the real model
 // loop.
-func runSwarmAgentMode(ctx context.Context, args Args, version string) error {
+func runSubagentWorkerMode(ctx context.Context, args Args, version string) error {
-	if args.SwarmAgent == "" {
+	if args.SubagentWorker == "" {
-		return fmt.Errorf("--swarm-agent requires a socket path")
+		return fmt.Errorf("--subagent-worker requires a socket path")
 	}
-	if os.Getenv("ZOT_SWARM_CREDENTIAL_STDIN") == "1" {
+	if os.Getenv("ZOT_SUBAGENT_CREDENTIAL_STDIN") == "1" {
-		var inherited swarm.Credential
+		var inherited subagents.Credential
 		dec := json.NewDecoder(io.LimitReader(os.Stdin, 1<<20))
 		if err := dec.Decode(&inherited); err != nil {
-			return fmt.Errorf("read inherited swarm credential: %w", err)
+			return fmt.Errorf("read inherited subagent credential: %w", err)
 		}
 		if inherited.Value == "" || inherited.Method == "" {
-			return fmt.Errorf("read inherited swarm credential: missing value or method")
+			return fmt.Errorf("read inherited subagent credential: missing value or method")
 		}
 		args.inheritedCredential = inherited.Value
 		args.inheritedAuthMethod = inherited.Method
 	// Open the inbox listener BEFORE emitting agent_ready so the
 	// supervisor can dial through on the very first send. The
-	// swarm supervisor's Inbox.SendInput retries dialing for a
+	// subagent supervisor's Inbox retries dialing for a
 	// short window, but emitting ready first and then listening
 	// would still race in tight loops.
-	ln, err := swarm.Listen(args.SwarmAgent)
+	ln, err := subagents.Listen(args.SubagentWorker)
 	if err != nil {
-		return fmt.Errorf("swarm-agent listen: %w", err)
+		return fmt.Errorf("subagent-worker listen: %w", err)
 	}
 	defer ln.Close()
 	// pipe is closed (e.g. parent zot exited but the agent is still
 	// running headless). The env var is set by the runner; if it's
 	// empty we silently skip the second mirror.
-	var logMirror *swarm.EventLog
+	var logMirror *subagents.EventLog
-	if path := os.Getenv("ZOT_SWARM_EVENT_LOG"); path != "" {
+	if path := os.Getenv("ZOT_SUBAGENT_EVENT_LOG"); path != "" {
-		logMirror, _ = swarm.OpenEventLog(path)
+		logMirror, _ = subagents.OpenEventLog(path)
 	}
 	if logMirror != nil {
 		defer logMirror.Close()
 	}
-	em := newSwarmEmitter(os.Stdout, logMirror)
+	em := newSubagentEmitter(os.Stdout, logMirror)
-	em.setProtocolIdentity(os.Getenv("ZOT_SWARM_AGENT_ID"))
+	em.setProtocolIdentity(os.Getenv("ZOT_SUBAGENT_AGENT_ID"))
 	em.emit("agent.ready", map[string]any{
 		"version": version,
 		"cwd":     r.CWD,
 	defer close(heartbeatDone)
 	go func() {
 		interval := 10 * time.Second
-		if raw := os.Getenv("ZOT_SWARM_HEARTBEAT_INTERVAL"); raw != "" {
+		if raw := os.Getenv("ZOT_SUBAGENT_HEARTBEAT_INTERVAL"); raw != "" {
 			if parsed, parseErr := time.ParseDuration(raw); parseErr == nil && parsed > 0 {
 				interval = parsed
 			}
 		mu           sync.Mutex
 		cancelFn     context.CancelFunc
 		busyTurn     bool
-		turnNo       = initialTurnNumber(os.Getenv("ZOT_SWARM_EVENT_LOG"))
+		turnNo       = initialTurnNumber(os.Getenv("ZOT_SUBAGENT_EVENT_LOG"))
 		turnWG       sync.WaitGroup
 		closing      bool
 		shutdown     = make(chan struct{})
 	// Initial task: run before processing the inbox so the agent
 	// "starts working" the moment it boots, matching what users
-	// expect from `/swarm new <task>`.
+	// expect from `/subagents new <task>`.
 	if args.Prompt != "" {
 		launchTurn(args.Prompt)
 	}
 				em.emit("agent.exited", map[string]any{"reason": "inbox-closed"})
 				return nil
 			}
-			command, parseErr := swarm.ParseCommand(msg)
+			command, parseErr := subagents.ParseCommand(msg)
 			if parseErr != nil {
 				em.emit("error", map[string]any{"message": "invalid supervisor command"})
 				continue
 			}
 			switch command.Type {
-			case swarm.CommandAgentShutdown:
+			case subagents.CommandAgentShutdown:
 				requestShutdown()
-			case swarm.CommandTurnCancel:
+			case subagents.CommandTurnCancel:
 				mu.Lock()
 				if cancelFn != nil {
 					cancelFn()
 				}
 				mu.Unlock()
-			case swarm.CommandAgentPing:
+			case subagents.CommandAgentPing:
 				em.emit("agent.heartbeat", map[string]any{"activity": "alive"})
-			case swarm.CommandTurnStart:
+			case subagents.CommandTurnStart:
-				var payload swarm.TurnStartPayload
+				var payload subagents.TurnStartPayload
 				if err := command.DecodePayload(&payload); err != nil {
 					em.emit("error", map[string]any{"message": "invalid turn.start payload"})
 					continue
 	}
 }
-// swarmEmitter serialises events to stdout and (optionally) to a
+// subagentEmitter serialises events to stdout and (optionally) to a
 // durable log file. Concurrent goroutines call emit so we have to
 // hold a mutex around the encoder.
-type swarmEmitter struct {
+type subagentEmitter struct {
-	mu        sync.Mutex
+	mu      sync.Mutex
-	w         *os.File
+	w       *os.File
-	mirror    *swarm.EventLog
+	mirror  *subagents.EventLog
-	agentID   string
+	agentID string
-	versioned bool
 	// orphan flips true the first time a stdout write fails (broken
 	// pipe — the supervisor died). Until then the mirror stays
 	orphan bool
 }
-func newSwarmEmitter(w *os.File, mirror *swarm.EventLog) *swarmEmitter {
+func newSubagentEmitter(w *os.File, mirror *subagents.EventLog) *subagentEmitter {
-	return &swarmEmitter{w: w, mirror: mirror}
+	return &subagentEmitter{w: w, mirror: mirror}
 }
-func (e *swarmEmitter) setProtocolIdentity(agentID string) {
+func (e *subagentEmitter) setProtocolIdentity(agentID string) {
 	e.mu.Lock()
 	e.agentID = agentID
-	e.versioned = true
 	e.mu.Unlock()
 }
-func (e *swarmEmitter) emit(typ string, data map[string]any) {
+func (e *subagentEmitter) emit(typ string, data map[string]any) {
 	if data == nil {
 		data = map[string]any{}
 	}
 	e.mu.Lock()
 	defer e.mu.Unlock()
-	wireType := typ
+	wireType := canonicalWorkerEvent(typ)
-	if e.versioned {
+	envelope := subagents.NewEventEnvelope(wireType, e.agentID, turnID, payload)
-		wireType = canonicalWorkerEvent(typ)
+	line, err := subagents.MarshalJSONL(envelope)
-	}
-	var line []byte
-	var err error
-	if e.versioned {
-		envelope := swarm.NewEventEnvelope(wireType, e.agentID, turnID, payload)
-		line, err = swarm.MarshalJSONL(envelope)
-		if err == nil {
-			// Flatten payload fields as a compatibility courtesy. New peers
-			// read `payload`; old peers can still inspect `step`, `content`,
-			// and similar fields at the top level.
-			var object map[string]any
-			if json.Unmarshal(bytes.TrimSpace(line), &object) == nil {
-				for key, value := range payload {
-					if _, exists := object[key]; exists {
-						continue
-					}
-					// Keep the compatibility flattening useful for old peers,
-					// but do not duplicate large result/output fields on the
-					// wire. New peers read the canonical payload object; a
-					// duplicated 500 KiB output would otherwise exceed the
-					// supervisor's bounded JSONL frame budget.
-					if !compatibilityFlatValue(value) {
-						continue
-					}
-					object[key] = value
-				}
-				line, err = json.Marshal(object)
-				line = append(line, '\n')
-			}
-		}
-	} else {
-		payload["type"] = typ
-		payload["time"] = time.Now().Format(time.RFC3339Nano)
-		line, err = json.Marshal(payload)
-		line = append(line, '\n')
-	}
 	if !e.orphan && err == nil {
 		if _, werr := e.w.Write(line); werr != nil {
 	}
 	if e.orphan && e.mirror != nil {
-		_ = e.mirror.Append(swarm.NewEvent(wireType, payload))
+		_ = e.mirror.Append(subagents.NewEvent(wireType, payload))
-	}
-}
-const compatibilityFlatValueBytes = 64 * 1024
-func compatibilityFlatValue(value any) bool {
-	switch v := value.(type) {
-	case string:
-		return len(v) <= compatibilityFlatValueBytes
-	case json.RawMessage:
-		return len(v) <= compatibilityFlatValueBytes
-	default:
-		return true
 	}
 }
 func canonicalWorkerEvent(typ string) string {
 	switch typ {
 	case "agent_ready":
-		return swarm.EventAgentReady
+		return subagents.EventAgentReady
 	case "agent_stopped":
-		return swarm.EventAgentExited
+		return subagents.EventAgentExited
 	case "turn_start":
-		return swarm.EventTurnStarted
+		return subagents.EventTurnStarted
 	case "turn_progress":
-		return swarm.EventTurnProgress
+		return subagents.EventTurnProgress
 	case "tool_call":
-		return swarm.EventToolStarted
+		return subagents.EventToolStarted
 	case "tool_result":
-		return swarm.EventToolFinished
+		return subagents.EventToolFinished
 	case "text_delta":
-		return swarm.EventMessageDelta
+		return subagents.EventMessageDelta
 	default:
 		return typ
 	}
 func workerOutputLimits() (maxBytes, maxLines int) {
 	maxBytes, maxLines = 500_000, 5_000
-	if value, err := strconv.Atoi(strings.TrimSpace(os.Getenv("ZOT_SWARM_MAX_OUTPUT_BYTES"))); err == nil && value > 0 {
+	if value, err := strconv.Atoi(strings.TrimSpace(os.Getenv("ZOT_SUBAGENT_MAX_OUTPUT_BYTES"))); err == nil && value > 0 {
 		maxBytes = value
 	}
-	if value, err := strconv.Atoi(strings.TrimSpace(os.Getenv("ZOT_SWARM_MAX_OUTPUT_LINES"))); err == nil && value > 0 {
+	if value, err := strconv.Atoi(strings.TrimSpace(os.Getenv("ZOT_SUBAGENT_MAX_OUTPUT_LINES"))); err == nil && value > 0 {
 		maxLines = value
 	}
 	return maxBytes, maxLines
 	if strings.TrimSpace(path) == "" {
 		return 0
 	}
-	events, err := swarm.ReadEventLog(path)
+	events, err := subagents.ReadEventLog(path)
 	if err != nil {
 		return 0
 	}

R packages/agent/swarm_agent_test.go → packages/agent/subagent_worker_test.go +27 -26 renamed, 77% similar

 	"strings"
 	"testing"
-	"github.com/patriceckhart/zot/packages/agent/swarm"
+	"github.com/patriceckhart/zot/packages/agent/subagents"
 )
 // TestWorkerOutputLimitsUseSupervisorPolicy verifies that the child reads
 // the effective output caps propagated by the supervisor and retains safe
 // defaults for standalone workers.
 func TestWorkerOutputLimitsUseSupervisorPolicy(t *testing.T) {
-	t.Setenv("ZOT_SWARM_MAX_OUTPUT_BYTES", "123")
+	t.Setenv("ZOT_SUBAGENT_MAX_OUTPUT_BYTES", "123")
-	t.Setenv("ZOT_SWARM_MAX_OUTPUT_LINES", "7")
+	t.Setenv("ZOT_SUBAGENT_MAX_OUTPUT_LINES", "7")
 	bytesLimit, linesLimit := workerOutputLimits()
 	if bytesLimit != 123 || linesLimit != 7 {
 		t.Fatalf("worker output limits = (%d, %d), want (123, 7)", bytesLimit, linesLimit)
 	}
-	t.Setenv("ZOT_SWARM_MAX_OUTPUT_BYTES", "invalid")
+	t.Setenv("ZOT_SUBAGENT_MAX_OUTPUT_BYTES", "invalid")
-	t.Setenv("ZOT_SWARM_MAX_OUTPUT_LINES", "0")
+	t.Setenv("ZOT_SUBAGENT_MAX_OUTPUT_LINES", "0")
 	bytesLimit, linesLimit = workerOutputLimits()
 	if bytesLimit != 500_000 || linesLimit != 5_000 {
 		t.Fatalf("invalid worker output limits = (%d, %d), want defaults", bytesLimit, linesLimit)
 	}
 }
-// TestSwarmEmitterMirrorDormantUntilStdoutBreaks regresses the
+// TestSupervisorEmitterMirrorDormantUntilStdoutBreaks regresses the
-// "everything is doubled after reopening a swarm agent" bug.
+// "everything is doubled after reopening a subagent agent" bug.
 //
 // Symptom: events.jsonl held two copies of every event because the
 // child mirrored each event to disk AND the supervisor parsed the
 // alive on the other end of the pipe), the child's mirror writes
 // NOTHING. Only when a stdout write fails (broken pipe → orphan)
 // does the mirror take over so events still get persisted.
-func TestSwarmEmitterMirrorDormantUntilStdoutBreaks(t *testing.T) {
+func TestSupervisorEmitterMirrorDormantUntilStdoutBreaks(t *testing.T) {
 	// Real *os.File for the emitter's stdout-equivalent so the
 	// emitter's write() path (which expects *os.File) actually runs.
 	stdoutPath := filepath.Join(t.TempDir(), "stdout.fifo")
 	// Mirror writes go to a separate events.jsonl that we can read
 	// at the end to assert how many events the mirror emitted.
 	mirrorPath := filepath.Join(t.TempDir(), "events.jsonl")
-	mirror, err := swarm.OpenEventLog(mirrorPath)
+	mirror, err := subagents.OpenEventLog(mirrorPath)
 	if err != nil {
 		t.Fatalf("open mirror: %v", err)
 	}
 	defer mirror.Close()
-	em := newSwarmEmitter(stdoutFile, mirror)
+	em := newSubagentEmitter(stdoutFile, mirror)
 	// Healthy stdout: emit three events. Mirror must stay empty.
 	em.emit("turn_start", map[string]any{"step": 1})
 	em.emit("assistant_message", map[string]any{"text": "hi"})
 	em.emit("turn_end", map[string]any{"step": 1})
-	got, err := swarm.ReadEventLog(mirrorPath)
+	got, err := subagents.ReadEventLog(mirrorPath)
 	if err != nil {
 		t.Fatalf("read mirror: %v", err)
 	}
 	em.emit("assistant_message", map[string]any{"text": "after orphan"})
 	em.emit("turn_end", map[string]any{"step": 2})
-	got, err = swarm.ReadEventLog(mirrorPath)
+	got, err = subagents.ReadEventLog(mirrorPath)
 	if err != nil {
 		t.Fatalf("read mirror post-orphan: %v", err)
 	}
 	}
 }
-// TestSwarmEmitterStdoutShapeMatchesSupervisorParser pins the
+// TestSupervisorEmitterStdoutShapeMatchesSupervisorParser pins the
 // wire-format contract: each emitted event lands on stdout as one
 // JSON object per line with type+time at top level alongside the
 // data fields. The supervisor's runner parses this exact shape.
-func TestSwarmEmitterLargeResultIsNotDuplicatedOnWire(t *testing.T) {
+func TestSupervisorEmitterLargeResultIsNotDuplicatedOnWire(t *testing.T) {
 	path := filepath.Join(t.TempDir(), "events.jsonl")
 	file, err := os.Create(path)
 	if err != nil {
 	}
 	defer file.Close()
-	em := newSwarmEmitter(file, nil)
+	em := newSubagentEmitter(file, nil)
 	em.setProtocolIdentity("agent-1")
 	em.emit("turn.result", map[string]any{
 		"status":  "succeeded",
 	if !ok || len(payload["output"].(string)) != 500_000 {
 		t.Fatal("canonical payload lost the complete bounded output")
 	}
-	events, err := swarm.ReadEventLog(path)
+	events, err := subagents.ReadEventLog(path)
 	if err != nil || len(events) != 1 {
 		t.Fatalf("supervisor event parser could not recover the large result: events=%d err=%v", len(events), err)
 	}
 	}
 }
-func TestSwarmEmitterStdoutShapeMatchesSupervisorParser(t *testing.T) {
+func TestSupervisorEmitterStdoutShapeMatchesSupervisorParser(t *testing.T) {
 	// Pipe so we can read what the emitter wrote.
 	r, w, err := os.Pipe()
 	if err != nil {
 	}
 	defer r.Close()
-	em := newSwarmEmitter(w, nil)
+	em := newSubagentEmitter(w, nil)
 	em.emit("turn_start", map[string]any{"step": 1})
 	_ = w.Close()
 	if len(lines) != 1 {
 		t.Fatalf("expected 1 event line, got %d: %q", len(lines), body)
 	}
-	var flat map[string]any
+	var object map[string]any
-	if err := json.Unmarshal(lines[0], &flat); err != nil {
+	if err := json.Unmarshal(lines[0], &object); err != nil {
 		t.Fatalf("not valid json: %v\n%s", err, lines[0])
 	}
-	if flat["type"] != "turn_start" {
+	if object["type"] != "turn.started" {
-		t.Errorf("type field missing or wrong: %v", flat["type"])
+		t.Errorf("type field missing or wrong: %v", object["type"])
 	}
-	if _, ok := flat["time"].(string); !ok {
+	if _, ok := object["timestamp"].(string); !ok {
-		t.Errorf("time field missing: %v", flat["time"])
+		t.Errorf("timestamp field missing: %v", object["timestamp"])
 	}
-	if flat["step"] != float64(1) {
+	payload, ok := object["payload"].(map[string]any)
-		t.Errorf("step field missing or wrong: %v", flat["step"])
+	if !ok || payload["step"] != float64(1) {
+		t.Errorf("payload step field missing or wrong: %v", object["payload"])
 	}
 }

R packages/agent/swarm/agent.go → packages/agent/subagents/agent.go +10 -28 renamed, 93% similar

-package swarm
+package subagents
 import (
 	"context"
 	// SessionID, when non-empty, scopes the agent to a particular
 	// host zot session: the dashboard only surfaces agents whose
-	// SessionID matches the active session. Empty means "unscoped"
+	// SessionID matches the active session. Empty means "unscoped" and
-	// (legacy meta files from before the field existed, or agents
+	// applies to agents spawned without a session context such as in tests. Set at
-	// spawned without a session context such as in tests). Set at
+	// Spawn time from Supervisor.activeSession and persisted in
-	// Spawn time from Swarm.activeSession and persisted in
 	// meta.json so the scope survives restarts.
 	SessionID string
 	// EventLogPath is the durable JSONL event log for this agent.
 	// The runner appends every well-formed event from the child
-	// (plus lifecycle events of its own) here. /swarm open in any
+	// (plus lifecycle events of its own) here. /subagents open in any
 	// zot process reads from this file to replay the full history.
 	EventLogPath string
 	// SessionPath is the child's persistent session file. Surfaced
-	// so the dashboard / /swarm open can resume the agent later.
+	// so the dashboard / /subagents open can resume the agent later.
 	SessionPath string
 	// inbox is the supervisor-side socket handle. Populated by
-	// Swarm.Spawn so SendInput can route messages without each
+	// Supervisor.Spawn so callers do not need to manage the socket directly.
-	// caller redialing.
 	inbox *Inbox
 	mu            sync.Mutex
 	lifecycleMu      sync.Mutex
 	processState     ProcessState
 	turnState        TurnState
-	protocolVersion  int
 	currentTurnID    string
 	updatedAt        time.Time
 	lastActivity     time.Time
 	workspaceCapture func() (WorkspaceCapture, error)
 	// OnTurnEnd, if set, fires once per prompt-level turn_end event
-	// emitted by the swarm daemon wrapper. Provider/tool-loop
+	// emitted by the subagent daemon wrapper. Provider/tool-loop
 	// turn_end events (for example stop=tool_use) are ignored by the
 	// runner because they do not mean the sub-agent task finished.
-	// Used by auto-swarm watchers to detect that a sub-agent's first
+	// Used by auto-subagents watchers to detect that a sub-agent's first
 	// (or n-th) task has finished without waiting for the long-lived
 	// daemon itself to exit — sub-agents keep running on the inbox
 	// even after the initial task completes, so Wait() never unblocks
 	return cloneTurnResult(a.result)
 }
-func (a *Agent) setProtocolVersion(version int) {
-	a.lifecycleMu.Lock()
-	if version > a.protocolVersion {
-		a.protocolVersion = version
-	}
-	a.updatedAt = time.Now()
-	a.lifecycleMu.Unlock()
-}
-func (a *Agent) protocolReady() bool {
-	a.lifecycleMu.Lock()
-	defer a.lifecycleMu.Unlock()
-	return a.protocolVersion >= ProtocolVersion
-}
 func (a *Agent) setProcessState(state ProcessState) {
 	a.lifecycleMu.Lock()
 	a.processState = state
 }
 // Wait blocks until the agent reaches a terminal state. Used by tests
-// and by /swarm wait <id>.
+// and by /subagents wait <id>.
 func (a *Agent) Wait() { <-a.done }
 func (a *Agent) waitForTurnResult(ctx context.Context) (*TurnResult, error) {

R packages/agent/swarm/batch.go → packages/agent/subagents/batch.go +8 -8 renamed, 96% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

@@ -76,7 +76,7 @@ func (b Batch) Result() BatchResult {
76		func (b *Batch) Wait() { <-b.done }	76		func (b *Batch) Wait() { <-b.done }
77		func (b *Batch) closeDone() { b.once.Do(func() { close(b.done) }) }	77		func (b *Batch) closeDone() { b.once.Do(func() { close(b.done) }) }
78			78
79	-	func (f Swarm) SpawnBatch(ctx context.Context, req BatchRequest) (Batch, error) {	79	+	func (f Supervisor) SpawnBatch(ctx context.Context, req BatchRequest) (Batch, error) {
80		if len(req.Tasks) == 0 {	80		if len(req.Tasks) == 0 {
81		return nil, fmt.Errorf("subagents: batch requires at least one task")	81		return nil, fmt.Errorf("subagents: batch requires at least one task")
82		}	82		}

@@ -166,7 +166,7 @@ func (f Swarm) SpawnBatch(ctx context.Context, req BatchRequest) (Batch, error
166		return batch, nil	166		return batch, nil
167		}	167		}
168			168
169	-	func (f Swarm) collectBatch(batch Batch) {	169	+	func (f Supervisor) collectBatch(batch Batch) {
170		if batch.TaskCount > 0 && len(batch.ChildIDs) < batch.TaskCount {	170		if batch.TaskCount > 0 && len(batch.ChildIDs) < batch.TaskCount {
171		batch.mu.Lock()	171		batch.mu.Lock()
172		batch.status = BatchFailed	172		batch.status = BatchFailed

@@ -228,7 +228,7 @@ func (f Swarm) collectBatch(batch Batch) {
228		batch.closeDone()	228		batch.closeDone()
229		}	229		}
230			230
231	-	func (f Swarm) waitForBatchResult(a Agent) (*TurnResult, error) {	231	+	func (f Supervisor) waitForBatchResult(a Agent) (*TurnResult, error) {
232		if a == nil {	232		if a == nil {
233		return nil, errors.New("subagents: missing batch child")	233		return nil, errors.New("subagents: missing batch child")
234		}	234		}

@@ -293,7 +293,7 @@ func (f Swarm) waitForBatchResult(a Agent) (*TurnResult, error) {
293		}	293		}
294		}	294		}
295			295
296	-	func (f Swarm) WaitBatch(id string) (BatchResult, error) {	296	+	func (f Supervisor) WaitBatch(id string) (BatchResult, error) {
297		f.mu.Lock()	297		f.mu.Lock()
298		batch := f.batches[id]	298		batch := f.batches[id]
299		f.mu.Unlock()	299		f.mu.Unlock()

@@ -304,7 +304,7 @@ func (f Swarm) WaitBatch(id string) (BatchResult, error) {
304		return batch.Result(), nil	304		return batch.Result(), nil
305		}	305		}
306			306
307	-	func (f Swarm) GetBatch(id string) Batch {	307	+	func (f Supervisor) GetBatch(id string) Batch {
308		f.mu.Lock()	308		f.mu.Lock()
309		defer f.mu.Unlock()	309		defer f.mu.Unlock()
310		return f.batches[id]	310		return f.batches[id]

@@ -325,7 +325,7 @@ func cloneBatchResult(result BatchResult) BatchResult {
325		return &copy	325		return &copy
326		}	326		}
327			327
328	-	func (f *Swarm) reloadBatches(root string) []error {	328	+	func (f *Supervisor) reloadBatches(root string) []error {
329		entries, err := os.ReadDir(filepath.Join(root, "batches"))	329		entries, err := os.ReadDir(filepath.Join(root, "batches"))
330		if err != nil {	330		if err != nil {
331		if errors.Is(err, os.ErrNotExist) {	331		if errors.Is(err, os.ErrNotExist) {

@@ -402,7 +402,7 @@ func (f *Swarm) reloadBatches(root string) []error {
402		return errs	402		return errs
403		}	403		}
404			404
405	-	func (f Swarm) persistBatch(batch Batch) {	405	+	func (f Supervisor) persistBatch(batch Batch) {
406		if batch == nil \|\| !safeAgentID(batch.ID) {	406		if batch == nil \|\| !safeAgentID(batch.ID) {
407		return	407		return
408		}	408		}

R packages/agent/swarm/batch_test.go → packages/agent/subagents/batch_test.go +4 -4 renamed, 96% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

@@ -36,7 +36,7 @@ func TestBatchIDsRemainUniqueWithFixedClock(t *testing.T) {
36			36
37		func TestBatchReloadsDurableResult(t *testing.T) {	37		func TestBatchReloadsDurableResult(t *testing.T) {
38		root := t.TempDir()	38		root := t.TempDir()
39	-	newSwarm := func() *Swarm {	39	+	newSupervisor := func() *Supervisor {
40		return New(Config{	40		return New(Config{
41		Root: root, RepoRoot: root,	41		Root: root, RepoRoot: root,
42		NewRunner: func(*Agent) Runner {	42		NewRunner: func(*Agent) Runner {

@@ -44,7 +44,7 @@ func TestBatchReloadsDurableResult(t *testing.T) {
44		},	44		},
45		})	45		})
46		}	46		}
47	-	first := newSwarm()	47	+	first := newSupervisor()
48		t.Cleanup(first.StopAll)	48		t.Cleanup(first.StopAll)
49		batch, err := first.SpawnBatch(context.Background(), BatchRequest{Context: "review", Tasks: []string{"one", "two"}})	49		batch, err := first.SpawnBatch(context.Background(), BatchRequest{Context: "review", Tasks: []string{"one", "two"}})
50		if err != nil {	50		if err != nil {

@@ -58,7 +58,7 @@ func TestBatchReloadsDurableResult(t *testing.T) {
58		t.Fatalf("first batch status = %s", want.Status)	58		t.Fatalf("first batch status = %s", want.Status)
59		}	59		}
60			60
61	-	second := newSwarm()	61	+	second := newSupervisor()
62		t.Cleanup(second.StopAll)	62		t.Cleanup(second.StopAll)
63		loaded, errs := second.Reload()	63		loaded, errs := second.Reload()
64		if len(errs) != 0 {	64		if len(errs) != 0 {

R packages/agent/swarm/event.go → packages/agent/subagents/event.go +53 -64 renamed, 81% similar

-package swarm
+package subagents
 import (
 	"bufio"
 // Event is one structured datum in an agent's durable event log.
 //
 // The shape is intentionally a thin map+timestamp wrapper rather
-// than a strict struct so the swarm package doesn't have to track
+// than a strict struct so the subagent package doesn't have to track
 // every field added to core.AgentEvent. The child writes
-// `modes.EventToJSON(ev)` plus a few swarm-internal types
+// `modes.EventToJSON(ev)` plus a few subagent-internal types
 // (lifecycle, user_input echo, error). The supervisor doesn't
 // interpret most fields; it just keeps them for replay and lifts
 // a few well-known ones into AgentSnapshot (Activity, Status,
 	AgentID   string         `json:"agent_id,omitempty"`
 	TurnID    string         `json:"turn_id,omitempty"`
 	Data      map[string]any `json:"-"`
-	Raw       map[string]any `json:"-"` // includes type+time+data for replay
+	Raw       map[string]any `json:"-"` // original canonical event for replay
 }
-// MarshalJSON flattens Data into the top-level object so consumers
+// MarshalJSON writes the canonical versioned event shape used by the
-// see {type, time, ...fields} rather than {type, time, data:{...}}.
+// worker protocol and durable event logs.
 func (e Event) MarshalJSON() ([]byte, error) {
-	out := make(map[string]any, len(e.Data)+7)
+	version := e.Version
-	for k, v := range e.Data {
+	if version == 0 {
-		out[k] = v
+		version = ProtocolVersion
 	}
-	out["type"] = e.Type
+	when := e.Time
-	out["time"] = e.Time
+	if when.IsZero() {
-	if e.Version != 0 {
+		when = time.Now().UTC()
-		out["version"] = e.Version
+	}
+	payload := e.Data
+	if payload == nil {
+		payload = map[string]any{}
+	}
+	out := map[string]any{
+		"version":   version,
+		"type":      e.Type,
+		"timestamp": when,
+		"payload":   payload,
 	}
 	if e.MessageID != "" {
 		out["message_id"] = e.MessageID
 	if e.TurnID != "" {
 		out["turn_id"] = e.TurnID
 	}
-	if e.Version != 0 {
-		out["timestamp"] = e.Time
-		out["payload"] = e.Data
-	}
 	return json.Marshal(out)
 }
-// UnmarshalJSON accepts a flat object with at least type+time.
+// UnmarshalJSON accepts the canonical versioned event shape and retains the
-// All other fields land in both Data and Raw.
+// decoded payload for dashboard replay.
 func (e *Event) UnmarshalJSON(b []byte) error {
-	m := map[string]any{}
+	var wire struct {
-	if err := json.Unmarshal(b, &m); err != nil {
+		Version   int            `json:"version"`
+		Type      string         `json:"type"`
+		MessageID string         `json:"message_id,omitempty"`
+		AgentID   string         `json:"agent_id,omitempty"`
+		TurnID    string         `json:"turn_id,omitempty"`
+		Timestamp time.Time      `json:"timestamp"`
+		Payload   map[string]any `json:"payload"`
+	}
+	if err := json.Unmarshal(b, &wire); err != nil {
 		return err
 	}
-	e.Raw = m
+	if wire.Version != ProtocolVersion {
-	e.Data = map[string]any{}
+		return fmt.Errorf("subagent event: unsupported version %d", wire.Version)
-	for k, v := range m {
-		if k == "type" || k == "time" || k == "timestamp" || k == "version" || k == "message_id" || k == "agent_id" || k == "turn_id" || k == "payload" {
-			continue
-		}
-		e.Data[k] = v
-	}
-	// Versioned events keep their forward-compatible payload under a
-	// dedicated object. The child also flattens known fields for legacy
-	// readers, but a newer event may contain payload fields that were not
-	// flattened by the producer. Merge those fields so replay sees the same
-	// data regardless of which wire shape was written.
-	if payload, ok := m["payload"].(map[string]any); ok {
-		for k, v := range payload {
-			if _, exists := e.Data[k]; !exists {
-				e.Data[k] = v
-			}
-		}
-	}
-	if version, ok := m["version"].(float64); ok {
-		e.Version = int(version)
-	}
-	if messageID, ok := m["message_id"].(string); ok {
-		e.MessageID = messageID
 	}
-	if agentID, ok := m["agent_id"].(string); ok {
+	if wire.Type == "" {
-		e.AgentID = agentID
+		return errors.New("subagent event: missing type")
 	}
-	if turnID, ok := m["turn_id"].(string); ok {
+	if wire.Timestamp.IsZero() {
-		e.TurnID = turnID
+		return errors.New("subagent event: missing timestamp")
 	}
-	if t, ok := m["type"].(string); ok {
+	if wire.Payload == nil {
-		e.Type = t
+		wire.Payload = map[string]any{}
-	} else {
-		return errors.New("swarm event: missing type")
 	}
-	ts, _ := m["time"].(string)
+	e.Raw = map[string]any{}
-	if ts == "" {
+	if err := json.Unmarshal(b, &e.Raw); err != nil {
-		ts, _ = m["timestamp"].(string)
+		return err
-	}
-	if ts != "" {
-		parsed, err := time.Parse(time.RFC3339Nano, ts)
-		if err == nil {
-			e.Time = parsed
-		}
 	}
+	e.Time = wire.Timestamp
+	e.Type = wire.Type
+	e.Version = wire.Version
+	e.MessageID = wire.MessageID
+	e.AgentID = wire.AgentID
+	e.TurnID = wire.TurnID
+	e.Data = wire.Payload
 	return nil
 }
 	if data == nil {
 		data = map[string]any{}
 	}
-	return Event{Time: time.Now(), Type: typ, Data: data}
+	return Event{Time: time.Now().UTC(), Type: typ, Version: ProtocolVersion, Data: data}
 }
 // ReadEventLog parses every event currently in the file. Used by

R packages/agent/swarm/event_test.go → packages/agent/subagents/event_test.go +2 -2 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"bytes"	4		"bytes"

@@ -13,7 +13,7 @@ import (
13			13
14		// TestEventLogAppendAndRead is the simplest possible invariant:	14		// TestEventLogAppendAndRead is the simplest possible invariant:
15		// what we write goes back through ReadEventLog exactly, including	15		// what we write goes back through ReadEventLog exactly, including
16	-	// the flat field shape and the timestamp.	16	+	// the payload fields and the timestamp.
17		func TestEventLogAppendAndRead(t *testing.T) {	17		func TestEventLogAppendAndRead(t *testing.T) {
18		path := filepath.Join(t.TempDir(), "events.jsonl")	18		path := filepath.Join(t.TempDir(), "events.jsonl")
19		log, err := OpenEventLog(path)	19		log, err := OpenEventLog(path)

R packages/agent/swarm/fast_mode_test.go → packages/agent/subagents/fast_mode_test.go +10 -10 renamed, 88% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

@@ -6,7 +6,7 @@ import (
6		"testing"	6		"testing"
7		)	7		)
8			8
9	-	func TestSwarmFastModePropagatesToChild(t *testing.T) {	9	+	func TestSupervisorFastModePropagatesToChild(t *testing.T) {
10		root := t.TempDir()	10		root := t.TempDir()
11		f := New(Config{	11		f := New(Config{
12		Root: root,	12		Root: root,

@@ -103,9 +103,9 @@ func TestSpawnRequestFastModeIsBoundByHostSetting(t *testing.T) {
103		}	103		}
104		}	104		}
105			105
106	-	func TestSwarmReloadPreservesExplicitFastModeOff(t *testing.T) {	106	+	func TestSupervisorReloadPreservesExplicitFastModeOff(t *testing.T) {
107		root := t.TempDir()	107		root := t.TempDir()
108	-	newSwarm := func(fastMode bool) *Swarm {	108	+	newSupervisor := func(fastMode bool) *Supervisor {
109		return New(Config{	109		return New(Config{
110		Root: root,	110		Root: root,
111		RepoRoot: root,	111		RepoRoot: root,

@@ -119,7 +119,7 @@ func TestSwarmReloadPreservesExplicitFastModeOff(t *testing.T) {
119		})	119		})
120		}	120		}
121			121
122	-	f := newSwarm(false)	122	+	f := newSupervisor(false)
123		a, err := f.SpawnReq(context.Background(), SpawnRequest{Task: "x"})	123		a, err := f.SpawnReq(context.Background(), SpawnRequest{Task: "x"})
124		if err != nil {	124		if err != nil {
125		t.Fatalf("spawn: %v", err)	125		t.Fatalf("spawn: %v", err)

@@ -132,7 +132,7 @@ func TestSwarmReloadPreservesExplicitFastModeOff(t *testing.T) {
132		}	132		}
133		a.Wait()	133		a.Wait()
134			134
135	-	g := newSwarm(true)	135	+	g := newSupervisor(true)
136		if loaded, errs := g.Reload(); loaded != 1 \|\| len(errs) != 0 {	136		if loaded, errs := g.Reload(); loaded != 1 \|\| len(errs) != 0 {
137		t.Fatalf("reload loaded=%d errs=%v", loaded, errs)	137		t.Fatalf("reload loaded=%d errs=%v", loaded, errs)
138		}	138		}

@@ -141,15 +141,15 @@ func TestSwarmReloadPreservesExplicitFastModeOff(t *testing.T) {
141		}	141		}
142		}	142		}
143			143
144	-	func TestSwarmAgentArgsOmitFastModeWhenUnset(t *testing.T) {	144	+	func TestSubagentWorkerArgsOmitFastModeWhenUnset(t *testing.T) {
145	-	args := swarmAgentArgs(swarmAgentArgsOpts{Exe: "/zot", Dir: "/wt", SessionPath: "/s", InboxPath: "/i"})	145	+	args := subagentWorkerArgs(subagentWorkerArgsOpts{Exe: "/zot", Dir: "/wt", SessionPath: "/s", InboxPath: "/i"})
146		if strings.Contains(strings.Join(args, " "), "--fast-mode") \|\| strings.Contains(strings.Join(args, " "), "--no-fast-mode") {	146		if strings.Contains(strings.Join(args, " "), "--fast-mode") \|\| strings.Contains(strings.Join(args, " "), "--no-fast-mode") {
147		t.Fatalf("child args = %v, want fast mode omitted when unset", args)	147		t.Fatalf("child args = %v, want fast mode omitted when unset", args)
148		}	148		}
149		}	149		}
150			150
151	-	func TestSwarmAgentArgsExplicitlyDisablesFastMode(t *testing.T) {	151	+	func TestSubagentWorkerArgsExplicitlyDisablesFastMode(t *testing.T) {
152	-	args := swarmAgentArgs(swarmAgentArgsOpts{	152	+	args := subagentWorkerArgs(subagentWorkerArgsOpts{
153		Exe: "/zot",	153		Exe: "/zot",
154		Dir: "/wt",	154		Dir: "/wt",
155		SessionPath: "/s",	155		SessionPath: "/s",

R packages/agent/swarm/inbox.go → packages/agent/subagents/inbox.go +15 -38 renamed, 82% similar

-package swarm
+package subagents
 import (
 	"bufio"
 	"time"
 )
-// Inbox is the supervisor-side handle on a per-agent unix socket
+// Inbox is the supervisor-side handle on a per-agent unix socket.
-// that the parent zot uses to send follow-up prompts (and other
+// The wire format is newline-delimited, versioned JSON commands. The child
-// control lines) to a running swarm agent.
+// listens on the same socket via Listener (below); the parent never reads
-//
+// from it.
-// Protocol on the wire: one UTF-8 message per line, newline-
-// terminated. Three message kinds:
-//
-//	user <text>...  — append <text> as the next user turn
-//	cancel          — cancel the agent's in-flight turn
-//	shutdown        — graceful exit; child will write a final
-//	                  EvTurnEnd-equivalent JSON event and quit
-//
-// The child listens on the same socket via Listener (below) and
-// translates the messages into core.Agent.Prompt calls. The
-// parent never reads from the socket — it's a one-way channel
-// driven by the supervisor.
 //
 // Why a socket and not a FIFO: FIFOs are POSIX-only and have
 // awkward blocking-open semantics. A unix socket gives us:
 //
 //   - the ability to fail fast if no child is listening yet,
-//     so SendInput returns a useful error to the TUI;
+//     so the supervisor gets a useful error to surface in the TUI;
 //   - clean shutdown semantics when the child closes the
 //     listener;
 //   - works under tests with a temp dir; and
 }
 // NewInbox returns a handle that will dial the socket at path on
-// the first SendInput call. The socket file is expected to be
+// the first SendCommand call. The socket file is expected to be
 // created by the child (Listener.Open below). This split lets the
 // parent build the Inbox before the child has booted; sends that
 // happen before the child is ready get a clear "not yet" error
 // pass the path to the child as a flag.
 func (b *Inbox) Path() string { return b.path }
-// SendInput writes msg to the inbox as one line. msg must already
+// SendCommand sends a versioned JSONL command.
-// include the leading kind ("user ", "cancel", "shutdown") — the
-// caller chooses the shape so we don't proliferate methods. The
-// socket is reused across calls; transient dial failures yield
-// ErrNotReady so the TUI can retry or report "agent not listening
-// yet" rather than crashing.
-func (b *Inbox) SendInput(msg string) error {
-	return b.sendBytes([]byte(msg + "\n"))
-}
-// SendCommand sends a versioned JSONL command. SendInput remains available
-// for older children and tests; new supervisor paths use this method.
 func (b *Inbox) SendCommand(command Envelope) error {
 	line, err := MarshalJSONL(command)
 	if err != nil {
 	return nil
 }
-// ErrNotReady is returned by SendInput when the child hasn't yet
+// ErrNotReady is returned when the child hasn't yet
 // opened its listener. Callers can retry after a short backoff;
 // the TUI surfaces it as "agent <id> not listening yet".
-var ErrNotReady = errors.New("swarm: agent inbox not ready")
+var ErrNotReady = errors.New("subagent: agent inbox not ready")
 // dialUnix wraps net.DialTimeout with a small retry window so the
 // happy path "child just started, supervisor sends right away"
 // one is listening": either the socket file doesn't exist (child
 // hasn't booted) or it does exist but the dial was refused (the
 // previous child exited and left a stale inode). Both are
-// recoverable by Swarm.Resume, and both should surface as the same
+// recoverable by Supervisor.Resume, and both should surface as the same
 // user-facing hint rather than as a path-leaking error string.
 func dialUnix(path string, timeout time.Duration) (net.Conn, error) {
 	deadline := time.Now().Add(timeout)
 	if isNoListenerErr(lastErr) {
 		return nil, ErrNotReady
 	}
-	return nil, fmt.Errorf("swarm: dial %s: %w", path, lastErr)
+	return nil, fmt.Errorf("subagent: dial %s: %w", path, lastErr)
 }
 // isNoListenerErr reports whether err means "the socket file exists
 // distinguish a live worker from a stale path. Callers use this probe before
 // resume/remove operations to avoid racing a detached worker's session and
 // workspace ownership.
-const inboxProbeLine = "__zot_swarm_probe__"
+const inboxProbeLine = "__zot_subagent_probe__"
 func inboxLive(path string) bool {
 	if path == "" {
 	return writeErr == nil
 }
-// Listener is the child-side end of the inbox. The swarm-agent
+// Listener is the child-side end of the inbox. The subagent-worker
 // daemon mode constructs one with Listen, then iterates Lines
 // to receive supervisor messages. Designed so a single goroutine
 // in the child can drive prompting without juggling raw net code.
 	// could let Resume start a second worker on the same session and event log.
 	if _, statErr := os.Stat(path); statErr == nil {
 		if inboxLive(path) {
-			return nil, fmt.Errorf("swarm inbox already has a live listener")
+			return nil, fmt.Errorf("subagent inbox already has a live listener")
 		}
 		// A refused probe means the socket inode is stale. Remove only that
 		// endpoint; a live listener was handled above without unlinking it.

R packages/agent/swarm/inbox_test.go → packages/agent/subagents/inbox_test.go +16 -16 renamed, 86% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"errors"	4		"errors"

@@ -20,7 +20,7 @@ import (
20		func shortSocketDir(t *testing.T) string {	20		func shortSocketDir(t *testing.T) string {
21		t.Helper()	21		t.Helper()
22		if runtime.GOOS == "windows" {	22		if runtime.GOOS == "windows" {
23	-	t.Skip("swarm inbox transport uses Unix-domain sockets; Windows support will use a named-pipe backend")	23	+	t.Skip("subagent inbox transport uses Unix-domain sockets; Windows support will use a named-pipe backend")
24		}	24		}
25		dir, err := os.MkdirTemp("/tmp", "zot-in-")	25		dir, err := os.MkdirTemp("/tmp", "zot-in-")
26		if err != nil {	26		if err != nil {

@@ -47,8 +47,8 @@ func TestInboxRoundTrip(t *testing.T) {
47			47
48		want := []string{"user hello", "user world", "cancel"}	48		want := []string{"user hello", "user world", "cancel"}
49		for _, msg := range want {	49		for _, msg := range want {
50	-	if err := inbox.SendInput(msg); err != nil {	50	+	if err := inbox.sendBytes([]byte(msg + "\n")); err != nil {
51	-	t.Fatalf("SendInput(%q): %v", msg, err)	51	+	t.Fatalf("sendBytes(%q): %v", msg, err)
52		}	52		}
53		}	53		}
54			54

@@ -70,19 +70,19 @@ func TestInboxNotReady(t *testing.T) {
70		path := filepath.Join(shortSocketDir(t), "in.sock")	70		path := filepath.Join(shortSocketDir(t), "in.sock")
71		inbox := NewInbox(path)	71		inbox := NewInbox(path)
72		defer inbox.Close()	72		defer inbox.Close()
73	-	err := inbox.SendInput("user hi")	73	+	err := inbox.sendBytes([]byte("user hi\n"))
74		if err == nil {	74		if err == nil {
75	-	t.Fatal("SendInput on missing socket: want error")	75	+	t.Fatal("sendBytes on missing socket: want error")
76		}	76		}
77		if !errors.Is(err, ErrNotReady) {	77		if !errors.Is(err, ErrNotReady) {
78	-	t.Fatalf("SendInput err = %v; want ErrNotReady", err)	78	+	t.Fatalf("sendBytes err = %v; want ErrNotReady", err)
79		}	79		}
80		}	80		}
81			81
82		// TestIsNoListenerErrMatchesECONNREFUSED documents the contract	82		// TestIsNoListenerErrMatchesECONNREFUSED documents the contract
83		// that the user's screenshot regression depends on: any dial error	83		// that the user's screenshot regression depends on: any dial error
84		// whose root cause is "the kernel refused the connect because nobody	84		// whose root cause is "the kernel refused the connect because nobody
85	-	// is listening" must fold into ErrNotReady at the SendInput layer,	85	+	// is listening" must fold into ErrNotReady at the sendBytes layer,
86		// so the TUI shows "agent not accepting input (press R to resume)"	86		// so the TUI shows "agent not accepting input (press R to resume)"
87		// instead of leaking the unix-socket path. We pattern-match via	87		// instead of leaking the unix-socket path. We pattern-match via
88		// errors.Is on syscall.ECONNREFUSED rather than string-matching the	88		// errors.Is on syscall.ECONNREFUSED rather than string-matching the

@@ -104,7 +104,7 @@ func TestIsNoListenerErrMatchesECONNREFUSED(t *testing.T) {
104		}	104		}
105			105
106		// TestInboxNewSupervisorPreemptsOld documents that only one	106		// TestInboxNewSupervisorPreemptsOld documents that only one
107	-	// supervisor connection at a time is honoured. The swarm design	107	+	// supervisor connection at a time is honoured. The subagent design
108		// assumes a single parent zot owns each agent; if a second	108		// assumes a single parent zot owns each agent; if a second
109		// parent dials, the listener boots the first one. The first	109		// parent dials, the listener boots the first one. The first
110		// supervisor's already-delivered messages still land in the	110		// supervisor's already-delivered messages still land in the

@@ -119,7 +119,7 @@ func TestInboxNewSupervisorPreemptsOld(t *testing.T) {
119		defer ln.Close()	119		defer ln.Close()
120			120
121		first := NewInbox(path)	121		first := NewInbox(path)
122	-	if err := first.SendInput("user one"); err != nil {	122	+	if err := first.sendBytes([]byte("user one\n")); err != nil {
123		t.Fatalf("first send: %v", err)	123		t.Fatalf("first send: %v", err)
124		}	124		}
125		// Wait for the listener to absorb "user one" before dialing the	125		// Wait for the listener to absorb "user one" before dialing the

@@ -130,7 +130,7 @@ func TestInboxNewSupervisorPreemptsOld(t *testing.T) {
130			130
131		second := NewInbox(path)	131		second := NewInbox(path)
132		defer second.Close()	132		defer second.Close()
133	-	if err := second.SendInput("user two"); err != nil {	133	+	if err := second.sendBytes([]byte("user two\n")); err != nil {
134		t.Fatalf("second send: %v", err)	134		t.Fatalf("second send: %v", err)
135		}	135		}
136			136

@@ -140,17 +140,17 @@ func TestInboxNewSupervisorPreemptsOld(t *testing.T) {
140		}	140		}
141			141
142		// The original supervisor's connection was preempted by the	142		// The original supervisor's connection was preempted by the
143	-	// listener accepting the second dial. The next SendInput on the	143	+	// listener accepting the second dial. The next sendBytes on the
144		// first handle sees a broken pipe and drops the cached connection;	144		// first handle sees a broken pipe and drops the cached connection;
145		// the call after that redials successfully. Both behaviours	145		// the call after that redials successfully. Both behaviours
146		// matter: the broken-pipe error must surface (so a real	146		// matter: the broken-pipe error must surface (so a real
147		// supervisor knows it lost ownership) AND the next call must	147		// supervisor knows it lost ownership) AND the next call must
148		// recover so a flaky reconnect doesn't permanently wedge the	148		// recover so a flaky reconnect doesn't permanently wedge the
149		// inbox.	149		// inbox.
150	-	if err := first.SendInput("user three"); err == nil {	150	+	if err := first.sendBytes([]byte("user three\n")); err == nil {
151		t.Fatal("expected broken-pipe error on stale connection")	151		t.Fatal("expected broken-pipe error on stale connection")
152		}	152		}
153	-	if err := first.SendInput("user four"); err != nil {	153	+	if err := first.sendBytes([]byte("user four\n")); err != nil {
154		t.Fatalf("first redial after eviction: %v", err)	154		t.Fatalf("first redial after eviction: %v", err)
155		}	155		}
156		}	156		}

@@ -197,7 +197,7 @@ func collectFor(t *testing.T, ch <-chan string, n int, timeout time.Duration) <-
197		return out	197		return out
198		}	198		}
199			199
200	-	// TestInboxConcurrentSends serialises the SendInput call so two	200	+	// TestInboxConcurrentSends serialises the sendBytes call so two
201		// goroutines writing at once still produce two whole lines, never	201		// goroutines writing at once still produce two whole lines, never
202		// a tearing of bytes between them.	202		// a tearing of bytes between them.
203		func TestInboxConcurrentSends(t *testing.T) {	203		func TestInboxConcurrentSends(t *testing.T) {

@@ -216,7 +216,7 @@ func TestInboxConcurrentSends(t *testing.T) {
216		for i := 0; i < n; i++ {	216		for i := 0; i < n; i++ {
217		go func(i int) {	217		go func(i int) {
218		defer wg.Done()	218		defer wg.Done()
219	-	if err := inbox.SendInput("user msg"); err != nil {	219	+	if err := inbox.sendBytes([]byte("user msg\n")); err != nil {
220		t.Errorf("send %d: %v", i, err)	220		t.Errorf("send %d: %v", i, err)
221		}	221		}
222		}(i)	222		}(i)

R packages/agent/swarm/lease.go → packages/agent/subagents/lease.go +3 -3 renamed, 80% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"errors"	4		"errors"

@@ -8,8 +8,8 @@ import (
8		)	8		)
9			9
10		// ErrAgentLeaseHeld means another supervisor currently owns an agent's	10		// ErrAgentLeaseHeld means another supervisor currently owns an agent's
11	-	// durable state. The lease is advisory only to old versions; socket probing	11	+	// durable state. The lease is advisory; socket probing remains the fence for
12	-	// remains the compatibility fence for workers that predate the lease.	12	+	// workers that are still live.
13		var ErrAgentLeaseHeld = errors.New("subagents: agent state is owned by another supervisor")	13		var ErrAgentLeaseHeld = errors.New("subagents: agent state is owned by another supervisor")
14			14
15		type agentLease struct {	15		type agentLease struct {

R packages/agent/swarm/lease_test.go → packages/agent/subagents/lease_test.go +1 -1 renamed, 97% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"errors"	4		"errors"

R packages/agent/swarm/lease_unix.go → packages/agent/subagents/lease_unix.go +1 -1 renamed, 97% similar

@@ -1,6 +1,6 @@
1		//go:build !windows	1		//go:build !windows
2			2
3	-	package swarm	3	+	package subagents
4			4
5		import (	5		import (
6		"errors"	6		"errors"

R packages/agent/swarm/lease_windows.go → packages/agent/subagents/lease_windows.go +1 -1 renamed, 97% similar

@@ -1,6 +1,6 @@
1		//go:build windows	1		//go:build windows
2			2
3	-	package swarm	3	+	package subagents
4			4
5		import (	5		import (
6		"errors"	6		"errors"

R packages/agent/swarm/model.go → packages/agent/subagents/model.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import "time"	3		import "time"
4			4

R packages/agent/swarm/persist.go → packages/agent/subagents/persist.go +40 -52 renamed, 90% similar

-package swarm
+package subagents
-// On-disk persistence for swarm agents.
+// On-disk persistence for subagent agents.
 //
 // Every Spawn writes a meta.json next to the agent's events.jsonl and
 // session.json. The file captures the immutable identity bits (id,
 // task, branch, dir) plus the paths the runner needs to resume the
-// agent later. On a fresh zot launch, Swarm.Reload() walks
+// agent later. On a fresh zot launch, Supervisor.Reload() walks
 // <root>/agents/*/meta.json and re-registers every agent it finds in
 // StatusDetached so the user can see, view, resume, or remove them
 // from the dashboard.
 // agentMeta is the durable identity record for one agent. Only fields
 // the supervisor needs to rebuild an Agent after a restart live here.
-// Adding a field is backwards-compatible (older meta.json files just
+// Adding a field leaves it zero when absent; removing or renaming a field
-// leave it zero); removing or renaming one is not.
+// changes the persisted contract.
 //
 // Historical fields like `branch` and `isolated` are silently dropped
 // by encoding/json's permissive decoder when an older meta.json is
 	// (and agents spawned outside of any session, e.g. by tests or
 	// scripted callers that didn't call SetActiveSession) have an
 	// empty SessionID and are visible from every session as a
-	// backward-compat fallback.
+	// unscoped-agent fallback.
 	SessionID string `json:"session_id,omitempty"`
 }
 	}
 	b, err := json.MarshalIndent(m, "", "  ")
 	if err != nil {
-		return fmt.Errorf("swarm meta marshal: %w", err)
+		return fmt.Errorf("subagent meta marshal: %w", err)
 	}
 	if err := os.MkdirAll(stateDir, 0o700); err != nil {
 		return fmt.Errorf("subagents meta dir: %w", err)
 	}
 	if err := os.Rename(tmp, final); err != nil {
 		_ = os.Remove(tmp)
-		return fmt.Errorf("swarm meta rename: %w", err)
+		return fmt.Errorf("subagent meta rename: %w", err)
 	}
 	return nil
 }
 		return m, err
 	}
 	if err := json.Unmarshal(b, &m); err != nil {
-		return m, fmt.Errorf("swarm meta parse %s: %w", stateDir, err)
+		return m, fmt.Errorf("subagent meta parse %s: %w", stateDir, err)
 	}
 	if m.ID == "" {
-		return m, fmt.Errorf("swarm meta %s: missing id", stateDir)
+		return m, fmt.Errorf("subagent meta %s: missing id", stateDir)
 	}
 	return m, nil
 }
 //
 // The reloaded agents have no live Runner; the user can:
 //   - view their transcript (the dashboard reads from EventLogPath),
-//   - resume them via Swarm.Resume (starts a fresh subprocess on the
+//   - resume them via Supervisor.Resume (starts a fresh subprocess on the
 //     same worktree / session / inbox path),
 //   - remove them (worktree + meta + events log gone).
 //
 // Reload returns the number of agents loaded plus any per-directory
 // error encountered. Malformed entries are skipped rather than
 // failing the whole reload — one bad meta.json shouldn't hide the
-// rest of the swarm.
+// rest of the subagents.
 func safeAgentID(id string) bool {
 	return id != "" && id != "." && id != ".." && filepath.Base(id) == id && !strings.ContainsAny(id, `/\\`)
 }
-func (f *Swarm) sanitizeReloadMeta(stateDir, root string, m *agentMeta) error {
+func (f *Supervisor) sanitizeReloadMeta(stateDir, root string, m *agentMeta) error {
 	if m == nil {
 		return errors.New("subagents reload: nil metadata")
 	}
 		return false
 	}
 	dir := filepath.Dir(path)
-	if !strings.HasPrefix(filepath.Base(dir), "zot-swarm-") {
+	if !strings.HasPrefix(filepath.Base(dir), "zot-subagents-") {
 		return false
 	}
 	bases := []string{os.TempDir(), "/tmp"}
 	return ""
 }
-func (f *Swarm) Reload() (loaded int, errs []error) {
+func (f *Supervisor) Reload() (loaded int, errs []error) {
-	roots := []string{f.cfg.Root}
+	root := filepath.Clean(f.cfg.Root)
-	roots = append(roots, f.cfg.LegacyRoots...)
+	if root == "." {
-	seenRoots := make(map[string]struct{}, len(roots))
+		return 0, nil
-	for _, root := range roots {
-		root = filepath.Clean(root)
-		if root == "." {
-			continue
-		}
-		if _, seen := seenRoots[root]; seen {
-			continue
-		}
-		seenRoots[root] = struct{}{}
-		count, rootErrs := f.reloadRoot(root)
-		loaded += count
-		errs = append(errs, rootErrs...)
-		errs = append(errs, f.reloadBatches(root)...)
 	}
+	loaded, errs = f.reloadRoot(root)
+	errs = append(errs, f.reloadBatches(root)...)
 	return loaded, errs
 }
-func (f *Swarm) reloadRoot(root string) (loaded int, errs []error) {
+func (f *Supervisor) reloadRoot(root string) (loaded int, errs []error) {
 	agentsDir := filepath.Join(root, "agents")
 	entries, err := os.ReadDir(agentsDir)
 	if err != nil {
 //
 // The returned Agent has a closed `done` channel because Wait should
 // return instantly: there is nothing to wait for.
-func (f *Swarm) buildDetachedAgent(m agentMeta) *Agent {
+func (f *Supervisor) buildDetachedAgent(m agentMeta) *Agent {
-	// Legacy meta.json files may not record a repository identity. Those
+	// Metadata without a repository identity uses the current RepoRoot;
-	// records are migrated to the current RepoRoot; current-format records
+	// records with one retain their persisted repository so a restart from
-	// retain their persisted repository so a restart from another checkout
+	// another checkout cannot silently redirect the child.
-	// cannot silently redirect the child.
 	dir := m.Dir
 	if m.WorkspaceMode != WorkspaceWorktree && m.RepositoryRoot == "" && f.cfg.RepoRoot != "" {
-		// Legacy metadata did not record the repository identity. Preserve
+		// Preserve the best-effort migration only for records without an
-		// the historical best-effort migration only for those records.
+		// explicit repository identity.
 		dir = f.cfg.RepoRoot
 	}
 	if dir == "" {
 // Resume re-attaches a Runner to a previously-spawned agent. Durable
 // session and event files are kept, while the transient inbox path is
 // recalculated for the current runtime environment. Use this to
-// continue a swarm session across zot restarts:
+// continue a subagent session across zot restarts:
 //
-//	swarmMgr.Reload()
+//	subagentMgr.Reload()
-//	a, err := swarmMgr.Resume(ctx, "alpha-12345")
+//	a, err := subagentMgr.Resume(ctx, "alpha-12345")
-//	swarmMgr.SendUserTurn(a.ID, "where were we?")
+//	subagentMgr.SendUserTurn(a.ID, "where were we?")
 //
 // The agent must be in a non-running state (Detached, Done, Failed,
 // Killed). Resuming a still-running agent returns an error so two
 // runners don't race for the same session.
-func (f *Swarm) Resume(ctx context.Context, id string) (*Agent, error) {
+func (f *Supervisor) Resume(ctx context.Context, id string) (*Agent, error) {
 	return f.resume(ctx, id, true)
 }
 // ResumeSession continues the existing child session without replaying the
 // original task. It is the explicit canonical spelling for Resume.
-func (f *Swarm) ResumeSession(ctx context.Context, id string) (*Agent, error) {
+func (f *Supervisor) ResumeSession(ctx context.Context, id string) (*Agent, error) {
 	return f.resume(ctx, id, true)
 }
 // RestartTask intentionally runs the stored original task again in a fresh
 // worker attempt. Callers should use ResumeSession for normal recovery.
-func (f *Swarm) RestartTask(ctx context.Context, id string) (*Agent, error) {
+func (f *Supervisor) RestartTask(ctx context.Context, id string) (*Agent, error) {
 	return f.resume(ctx, id, false)
 }
-func (f *Swarm) resume(ctx context.Context, id string, resuming bool) (*Agent, error) {
+func (f *Supervisor) resume(ctx context.Context, id string, resuming bool) (*Agent, error) {
 	f.operationMu.Lock()
 	defer f.operationMu.Unlock()
 	if ctx == nil {
 	}
 	existing := f.Get(id)
 	if existing == nil {
-		return nil, fmt.Errorf("swarm: no such agent %q", id)
+		return nil, fmt.Errorf("subagent: no such agent %q", id)
 	}
 	existing.mu.Lock()
 	st := existing.status
 	existing.mu.Unlock()
 	if st == StatusRunning || st == StatusPending {
-		return nil, fmt.Errorf("swarm: agent %s is still %s; stop it first", existing.ID, st)
+		return nil, fmt.Errorf("subagent: agent %s is still %s; stop it first", existing.ID, st)
 	}
 	select {
 	case <-existing.done:
 	default:
-		return nil, fmt.Errorf("swarm: agent %s is still finalizing; wait before resuming", existing.ID)
+		return nil, fmt.Errorf("subagent: agent %s is still finalizing; wait before resuming", existing.ID)
 	}
 	// A reloaded worker may still be alive even though this supervisor has no
 	// in-process Runner (the old host can disappear after the child daemon
 	// starts). Fence resume before touching the shared session/worktree: a
 	// second worker must never own the same inbox and files concurrently.
 	if inboxLive(existing.InboxPath) {
-		return nil, fmt.Errorf("swarm: agent %s still has a live worker; send shutdown or stop it first", existing.ID)
+		return nil, fmt.Errorf("subagent: agent %s still has a live worker; send shutdown or stop it first", existing.ID)
 	}
 	stateDir := existing.stateDirectory(f.cfg.Root)
 	lease, err := acquireAgentLease(stateDir)
 	// older zot version, so always select it again on resume.
 	inboxPath, err := inboxSocketPath(f.cfg.Root, existing.ID)
 	if err != nil {
-		return nil, fmt.Errorf("swarm inbox path: %w", err)
+		return nil, fmt.Errorf("subagent inbox path: %w", err)
 	}
 	fastMode := existing.FastMode
 	m := agentMeta{

R packages/agent/swarm/persist_test.go → packages/agent/subagents/persist_test.go +33 -33 renamed, 94% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

@@ -64,7 +64,7 @@ func TestSpawnWritesMetaJSON(t *testing.T) {
64		}	64		}
65			65
66		// TestReloadRebuildsDetachedAgents simulates a zot restart by spawning	66		// TestReloadRebuildsDetachedAgents simulates a zot restart by spawning
67	-	// in one Swarm, throwing it away, then opening a fresh Swarm against	67	+	// in one Supervisor, throwing it away, then opening a fresh Supervisor against
68		// the same root and calling Reload. The user-visible state — id,	68		// the same root and calling Reload. The user-visible state — id,
69		// task, branch, dir — must come back, and status must be Detached so	69		// task, branch, dir — must come back, and status must be Detached so
70		// the dashboard can offer resume.	70		// the dashboard can offer resume.

@@ -240,7 +240,7 @@ func TestReloadIsIdempotent(t *testing.T) {
240		// TestReloadReplaysTranscriptFromEventLog drops a curated events.jsonl	240		// TestReloadReplaysTranscriptFromEventLog drops a curated events.jsonl
241		// next to a meta.json and checks that the transcript surfaces in the	241		// next to a meta.json and checks that the transcript surfaces in the
242		// reloaded agent. This is the user-facing payoff of Reload: opening	242		// reloaded agent. This is the user-facing payoff of Reload: opening
243	-	// /swarm logs <id> after a restart shows what the agent said before.	243	+	// /subagents logs <id> after a restart shows what the agent said before.
244		func TestReloadReplaysTranscriptFromEventLog(t *testing.T) {	244		func TestReloadReplaysTranscriptFromEventLog(t *testing.T) {
245		root := t.TempDir()	245		root := t.TempDir()
246		id := "alpha-9"	246		id := "alpha-9"

@@ -423,9 +423,9 @@ func TestResumeRestartsRunnerOnSameSession(t *testing.T) {
423		}	423		}
424		}	424		}
425			425
426	-	func TestResumeRecalculatesLegacyStateInboxPath(t *testing.T) {	426	+	func TestResumeRecalculatesInvalidStateInboxPath(t *testing.T) {
427		if runtime.GOOS == "windows" {	427		if runtime.GOOS == "windows" {
428	-	t.Skip("swarm inbox runtime relocation applies to Unix sockets")	428	+	t.Skip("subagent inbox runtime relocation applies to Unix sockets")
429		}	429		}
430		root := t.TempDir()	430		root := t.TempDir()
431		f := New(Config{	431		f := New(Config{

@@ -434,21 +434,21 @@ func TestResumeRecalculatesLegacyStateInboxPath(t *testing.T) {
434		return RunnerFunc(func(context.Context, Sink) error { return nil })	434		return RunnerFunc(func(context.Context, Sink) error { return nil })
435		},	435		},
436		})	436		})
437	-	a, err := f.Spawn(context.Background(), "legacy inbox")	437	+	a, err := f.Spawn(context.Background(), "invalid inbox")
438		if err != nil {	438		if err != nil {
439		t.Fatal(err)	439		t.Fatal(err)
440		}	440		}
441		a.Wait()	441		a.Wait()
442			442
443	-	legacyPath := filepath.Join(root, "agents", a.ID, "in.sock")	443	+	invalidPath := filepath.Join(root, "agents", a.ID, "in.sock")
444	-	a.InboxPath = legacyPath	444	+	a.InboxPath = invalidPath
445		a2, err := f.Resume(context.Background(), a.ID)	445		a2, err := f.Resume(context.Background(), a.ID)
446		if err != nil {	446		if err != nil {
447		t.Fatalf("resume: %v", err)	447		t.Fatalf("resume: %v", err)
448		}	448		}
449		a2.Wait()	449		a2.Wait()
450	-	if a2.InboxPath == legacyPath {	450	+	if a2.InboxPath == invalidPath {
451	-	t.Fatalf("resume kept legacy state-directory inbox path %q", legacyPath)	451	+	t.Fatalf("resume kept state-directory inbox path %q", invalidPath)
452		}	452		}
453		if strings.HasPrefix(a2.InboxPath, root+string(filepath.Separator)) {	453		if strings.HasPrefix(a2.InboxPath, root+string(filepath.Separator)) {
454		t.Fatalf("resumed inbox %q remains below state root %q", a2.InboxPath, root)	454		t.Fatalf("resumed inbox %q remains below state root %q", a2.InboxPath, root)

@@ -557,7 +557,7 @@ func TestResumeAfterReload(t *testing.T) {
557		a.StopAll()	557		a.StopAll()
558		ag.Wait()	558		ag.Wait()
559			559
560	-	// Process B: a new Swarm against the same root.	560	+	// Process B: a new Supervisor against the same root.
561		resumed := make(chan struct{}, 1)	561		resumed := make(chan struct{}, 1)
562		b := New(Config{	562		b := New(Config{
563		Root: root, RepoRoot: root,	563		Root: root, RepoRoot: root,

@@ -667,9 +667,9 @@ func TestResumeFencesLiveReloadedWorker(t *testing.T) {
667		}	667		}
668		}	668		}
669			669
670	-	func TestSwarmProviderSettingsPersistAcrossReloadAndResume(t *testing.T) {	670	+	func TestSupervisorProviderSettingsPersistAcrossReloadAndResume(t *testing.T) {
671		root := t.TempDir()	671		root := t.TempDir()
672	-	newSwarm := func(baseURL string, insecureTLS bool) *Swarm {	672	+	newSupervisor := func(baseURL string, insecureTLS bool) *Supervisor {
673		return New(Config{	673		return New(Config{
674		Root: root,	674		Root: root,
675		RepoRoot: root,	675		RepoRoot: root,

@@ -684,7 +684,7 @@ func TestSwarmProviderSettingsPersistAcrossReloadAndResume(t *testing.T) {
684		})	684		})
685		}	685		}
686			686
687	-	first := newSwarm("https://parent.example.test/v1", true)	687	+	first := newSupervisor("https://parent.example.test/v1", true)
688		a, err := first.SpawnReq(context.Background(), SpawnRequest{Task: "x"})	688		a, err := first.SpawnReq(context.Background(), SpawnRequest{Task: "x"})
689		if err != nil {	689		if err != nil {
690		t.Fatalf("spawn: %v", err)	690		t.Fatalf("spawn: %v", err)

@@ -715,7 +715,7 @@ func TestSwarmProviderSettingsPersistAcrossReloadAndResume(t *testing.T) {
715		t.Fatalf("metadata contains credential material: %s", metaBytes)	715		t.Fatalf("metadata contains credential material: %s", metaBytes)
716		}	716		}
717			717
718	-	second := newSwarm("https://different.example.test/v1", false)	718	+	second := newSupervisor("https://different.example.test/v1", false)
719		if loaded, errs := second.Reload(); loaded != 1 \|\| len(errs) != 0 {	719		if loaded, errs := second.Reload(); loaded != 1 \|\| len(errs) != 0 {
720		t.Fatalf("reload loaded=%d errs=%v", loaded, errs)	720		t.Fatalf("reload loaded=%d errs=%v", loaded, errs)
721		}	721		}

@@ -823,7 +823,7 @@ func TestSpawnReqPersistsModel(t *testing.T) {
823		t.Errorf("meta = (%q,%q,%q,%q,%q); want model/provider/reasoning/profile/session persisted", got.Model, got.Provider, got.Reasoning, got.Subagent, got.SessionID)	823		t.Errorf("meta = (%q,%q,%q,%q,%q); want model/provider/reasoning/profile/session persisted", got.Model, got.Provider, got.Reasoning, got.Subagent, got.SessionID)
824		}	824		}
825			825
826	-	// Reload in a fresh Swarm and confirm the detached agent still	826	+	// Reload in a fresh Supervisor and confirm the detached agent still
827		// carries the model/provider so Resume can route the child	827		// carries the model/provider so Resume can route the child
828		// subprocess back to the same model.	828		// subprocess back to the same model.
829		g := New(Config{	829		g := New(Config{

@@ -856,12 +856,12 @@ func TestSpawnReqPersistsModel(t *testing.T) {
856		resumed.Wait()	856		resumed.Wait()
857		}	857		}
858			858
859	-	// TestSwarmAgentArgsIncludesModelFlags pins the argv contract that	859	+	// TestSubagentWorkerArgsIncludesModelFlags pins the argv contract that
860		// connects the supervisor's per-agent model override to the child's	860		// connects the supervisor's per-agent model override to the child's
861		// --model / --provider flag set. Adding a new path to argv without	861		// --model / --provider flag set. Adding a new path to argv without
862		// updating this assertion is the failure mode this catches.	862		// updating this assertion is the failure mode this catches.
863	-	func TestSwarmAgentArgsIncludesModelFlags(t *testing.T) {	863	+	func TestSubagentWorkerArgsIncludesModelFlags(t *testing.T) {
864	-	args := swarmAgentArgs(swarmAgentArgsOpts{	864	+	args := subagentWorkerArgs(subagentWorkerArgsOpts{
865		Exe: "/zot", Dir: "/wt", SessionPath: "/s.json", InboxPath: "/in.sock",	865		Exe: "/zot", Dir: "/wt", SessionPath: "/s.json", InboxPath: "/in.sock",
866		Task: "do x", Model: "gpt-5", Provider: "openai",	866		Task: "do x", Model: "gpt-5", Provider: "openai",
867		})	867		})

@@ -887,14 +887,14 @@ func TestSwarmAgentArgsIncludesModelFlags(t *testing.T) {
887			887
888		// TestStopOnDetachedAgentIsNoopAndDoesNotPanic regression-tests the	888		// TestStopOnDetachedAgentIsNoopAndDoesNotPanic regression-tests the
889		// segfault that hit when the user pressed 'k' on a reloaded	889		// segfault that hit when the user pressed 'k' on a reloaded
890	-	// (detached) agent: Swarm.Stop unconditionally called a.cancel(),	890	+	// (detached) agent: Supervisor.Stop unconditionally called a.cancel(),
891		// but buildDetachedAgent never assigns a cancel func because there's	891		// but buildDetachedAgent never assigns a cancel func because there's
892		// no in-process runner to cancel. The fix is to short-circuit Stop	892		// no in-process runner to cancel. The fix is to short-circuit Stop
893		// for StatusDetached and — belt-and-braces — nil-check a.cancel.	893		// for StatusDetached and — belt-and-braces — nil-check a.cancel.
894		func TestStopOnDetachedAgentIsNoopAndDoesNotPanic(t *testing.T) {	894		func TestStopOnDetachedAgentIsNoopAndDoesNotPanic(t *testing.T) {
895		root := t.TempDir()	895		root := t.TempDir()
896		// Build a detached agent the same way Reload does: drop a	896		// Build a detached agent the same way Reload does: drop a
897	-	// meta.json on disk, then ask a fresh Swarm to pick it up.	897	+	// meta.json on disk, then ask a fresh Supervisor to pick it up.
898		id := "alpha-1"	898		id := "alpha-1"
899		stateDir := filepath.Join(root, "agents", id)	899		stateDir := filepath.Join(root, "agents", id)
900		if err := os.MkdirAll(stateDir, 0o755); err != nil {	900		if err := os.MkdirAll(stateDir, 0o755); err != nil {

@@ -919,7 +919,7 @@ func TestStopOnDetachedAgentIsNoopAndDoesNotPanic(t *testing.T) {
919		}	919		}
920		a := f.Get(id)	920		a := f.Get(id)
921		if a == nil {	921		if a == nil {
922	-	t.Fatal("detached agent missing from swarm")	922	+	t.Fatal("detached agent missing from subagent")
923		}	923		}
924		if a.Status() != StatusDetached {	924		if a.Status() != StatusDetached {
925		t.Fatalf("setup: agent status = %q; want detached", a.Status())	925		t.Fatalf("setup: agent status = %q; want detached", a.Status())

@@ -973,7 +973,7 @@ func TestRemoveAlsoCleansStateDir(t *testing.T) {
973		t.Fatalf("state dir should be gone after remove; got %v", err)	973		t.Fatalf("state dir should be gone after remove; got %v", err)
974		}	974		}
975			975
976	-	// A fresh Swarm + Reload should find nothing.	976	+	// A fresh Supervisor + Reload should find nothing.
977		g := New(Config{Root: root, RepoRoot: root})	977		g := New(Config{Root: root, RepoRoot: root})
978		if loaded, _ := g.Reload(); loaded != 0 {	978		if loaded, _ := g.Reload(); loaded != 0 {
979		t.Fatalf("reload after remove loaded=%d; want 0", loaded)	979		t.Fatalf("reload after remove loaded=%d; want 0", loaded)

@@ -1012,7 +1012,7 @@ func TestRemoveReloadedAgentKeepsSiblingState(t *testing.T) {
1012		}	1012		}
1013			1013
1014		// TestActiveSessionScopesSnapshotAll proves the session filter the	1014		// TestActiveSessionScopesSnapshotAll proves the session filter the
1015	-	// user asked for: a single Swarm with agents spawned under two	1015	+	// user asked for: a single Supervisor with agents spawned under two
1016		// different active sessions only surfaces the agents matching the	1016		// different active sessions only surfaces the agents matching the
1017		// currently-active session via SnapshotAll. Switching the active	1017		// currently-active session via SnapshotAll. Switching the active
1018		// session re-narrows the view without touching agent state.	1018		// session re-narrows the view without touching agent state.

@@ -1074,14 +1074,14 @@ func TestActiveSessionScopesSnapshotAll(t *testing.T) {
1074		}	1074		}
1075			1075
1076		// TestSessionIDPersistsAcrossReload confirms the SessionID field	1076		// TestSessionIDPersistsAcrossReload confirms the SessionID field
1077	-	// survives a Swarm restart: an agent spawned under session A in one	1077	+	// survives a Supervisor restart: an agent spawned under session A in one
1078	-	// Swarm instance is still SessionID="sess-A" after a fresh New +	1078	+	// Supervisor instance is still SessionID="sess-A" after a fresh New +
1079		// Reload reads it back from meta.json. Without persistence, the	1079		// Reload reads it back from meta.json. Without persistence, the
1080		// scope filter would forget which session owned each agent after	1080		// scope filter would forget which session owned each agent after
1081		// a zot restart and the dashboard would leak everything again.	1081		// a zot restart and the dashboard would leak everything again.
1082		func TestSessionIDPersistsAcrossReload(t *testing.T) {	1082		func TestSessionIDPersistsAcrossReload(t *testing.T) {
1083		root := t.TempDir()	1083		root := t.TempDir()
1084	-	mkSwarm := func() *Swarm {	1084	+	mkSupervisor := func() *Supervisor {
1085		return New(Config{	1085		return New(Config{
1086		Root: root, RepoRoot: root,	1086		Root: root, RepoRoot: root,
1087		NewRunner: func(a *Agent) Runner {	1087		NewRunner: func(a *Agent) Runner {

@@ -1090,7 +1090,7 @@ func TestSessionIDPersistsAcrossReload(t *testing.T) {
1090		})	1090		})
1091		}	1091		}
1092			1092
1093	-	f := mkSwarm()	1093	+	f := mkSupervisor()
1094		f.SetActiveSession("sess-keep")	1094		f.SetActiveSession("sess-keep")
1095		a, err := f.Spawn(context.Background(), "persist me")	1095		a, err := f.Spawn(context.Background(), "persist me")
1096		if err != nil {	1096		if err != nil {

@@ -1099,8 +1099,8 @@ func TestSessionIDPersistsAcrossReload(t *testing.T) {
1099		_ = f.Stop(a.ID)	1099		_ = f.Stop(a.ID)
1100		a.Wait()	1100		a.Wait()
1101			1101
1102	-	// Fresh Swarm, same root, reload from disk.	1102	+	// Fresh Supervisor, same root, reload from disk.
1103	-	g := mkSwarm()	1103	+	g := mkSupervisor()
1104		if loaded, errs := g.Reload(); loaded != 1 \|\| len(errs) > 0 {	1104		if loaded, errs := g.Reload(); loaded != 1 \|\| len(errs) > 0 {
1105		t.Fatalf("reload loaded=%d errs=%v; want 1 / no errs", loaded, errs)	1105		t.Fatalf("reload loaded=%d errs=%v; want 1 / no errs", loaded, errs)
1106		}	1106		}

@@ -1118,7 +1118,7 @@ func TestSessionIDPersistsAcrossReload(t *testing.T) {
1118		}	1118		}
1119		}	1119		}
1120			1120
1121	-	// TestEmptySessionIDIsVisibleFromAnyScope pins the backward-compat	1121	+	// TestEmptySessionIDIsVisibleFromAnyScope pins the unscoped-agent
1122		// rule: agents whose meta.json predates the SessionID field (or who	1122		// rule: agents whose meta.json predates the SessionID field (or who
1123		// were spawned without an active session, e.g. via a test rig or	1123		// were spawned without an active session, e.g. via a test rig or
1124		// scripted caller) carry SessionID == "" and remain visible from	1124		// scripted caller) carry SessionID == "" and remain visible from

@@ -1133,7 +1133,7 @@ func TestEmptySessionIDIsVisibleFromAnyScope(t *testing.T) {
1133		},	1133		},
1134		})	1134		})
1135		// No SetActiveSession call → agent spawned with empty SessionID.	1135		// No SetActiveSession call → agent spawned with empty SessionID.
1136	-	a, err := f.Spawn(context.Background(), "legacy")	1136	+	a, err := f.Spawn(context.Background(), "unscoped")
1137		if err != nil {	1137		if err != nil {
1138		t.Fatal(err)	1138		t.Fatal(err)
1139		}	1139		}

@@ -1145,7 +1145,7 @@ func TestEmptySessionIDIsVisibleFromAnyScope(t *testing.T) {
1145		f.SetActiveSession(scope)	1145		f.SetActiveSession(scope)
1146		got := snapshotIDs(f.SnapshotAll())	1146		got := snapshotIDs(f.SnapshotAll())
1147		if len(got) != 1 \|\| got[0] != a.ID {	1147		if len(got) != 1 \|\| got[0] != a.ID {
1148	-	t.Errorf("scope=%q: ids = %v; want legacy agent visible", scope, got)	1148	+	t.Errorf("scope=%q: ids = %v; want unscoped agent visible", scope, got)
1149		}	1149		}
1150		}	1150		}
1151			1151

R packages/agent/swarm/process_unix.go → packages/agent/subagents/process_unix.go +1 -1 renamed, 98% similar

@@ -1,6 +1,6 @@
1		//go:build !windows	1		//go:build !windows
2			2
3	-	package swarm	3	+	package subagents
4			4
5		import (	5		import (
6		"os/exec"	6		"os/exec"

R packages/agent/swarm/process_unix_test.go → packages/agent/subagents/process_unix_test.go +1 -1 renamed, 98% similar

@@ -1,6 +1,6 @@
1		//go:build !windows	1		//go:build !windows
2			2
3	-	package swarm	3	+	package subagents
4			4
5		import (	5		import (
6		"context"	6		"context"

R packages/agent/swarm/process_windows.go → packages/agent/subagents/process_windows.go +1 -1 renamed, 98% similar

@@ -1,6 +1,6 @@
1		//go:build windows	1		//go:build windows
2			2
3	-	package swarm	3	+	package subagents
4			4
5		import (	5		import (
6		"os/exec"	6		"os/exec"

M packages/agent/subagents/profiles.go +2 -2

@@ -1,5 +1,5 @@
1		// Package subagents discovers named agent profiles that can be selected by	1		// Package subagents discovers named agent profiles that can be selected by
2	-	// zot's swarm supervisor. Profiles use the common markdown/frontmatter layout:	2	+	// zot's subagent supervisor. Profiles use the common markdown/frontmatter layout:
3		// a YAML-like metadata block followed by the agent's system prompt.	3		// a YAML-like metadata block followed by the agent's system prompt.
4		//	4		//
5		// Discovery prefers explicitly configured directories, then the shared	5		// Discovery prefers explicitly configured directories, then the shared

@@ -132,7 +132,7 @@ func SystemPromptAddendum(profiles []*Profile) string {
132		}	132		}
133		var sb strings.Builder	133		var sb strings.Builder
134		sb.WriteString("[subagents_list]\n")	134		sb.WriteString("[subagents_list]\n")
135	-	sb.WriteString("Named subagents available to swarm_spawn. Choose the profile whose description best matches the independent task and pass its name as the tool's agent field. The selected profile's instructions, model, thinking level, tool limits, and fast-mode preference are applied to the child.\n")	135	+	sb.WriteString("Named subagents available to subagent_spawn. Choose the profile whose description best matches the independent task and pass its name as the tool's agent field. The selected profile's instructions, model, thinking level, tool limits, and fast-mode preference are applied to the child.\n")
136		for _, profile := range profiles {	136		for _, profile := range profiles {
137		if profile == nil {	137		if profile == nil {
138		continue	138		continue

R packages/agent/swarm/protocol.go → packages/agent/subagents/protocol.go +47 -278 renamed, 66% similar

-package swarm
+package subagents
 import (
 	"bufio"
 )
 // ProtocolVersion is the version of the supervisor/worker JSONL protocol.
-// Version zero is reserved for the legacy flat event and text-inbox formats;
-// it is not a versioned wire format.
 const ProtocolVersion = 1
-// LegacyProtocolVersion identifies a message read from the pre-versioned
-// protocol. Legacy messages are accepted by the readers but new messages are
-// always emitted at ProtocolVersion.
-const LegacyProtocolVersion = 0
 // Canonical parent-to-worker command names.
 const (
 	CommandAgentPing     = "agent.ping"
 var (
 	// ErrEmptyProtocolLine is returned for a blank JSONL line or command.
-	ErrEmptyProtocolLine = errors.New("swarm protocol: empty line")
+	ErrEmptyProtocolLine = errors.New("subagent protocol: empty line")
 	// ErrNotCommand is returned when ParseCommand is given a JSON event.
-	ErrNotCommand = errors.New("swarm protocol: message is not a command")
+	ErrNotCommand = errors.New("subagent protocol: message is not a command")
 	// ErrNotEvent is returned when ParseEvent is given a JSON command.
-	ErrNotEvent = errors.New("swarm protocol: message is not an event")
+	ErrNotEvent = errors.New("subagent protocol: message is not an event")
 	// ErrUnsupportedProtocolVersion is returned by Validate for a version
 	// this implementation cannot interpret.
-	ErrUnsupportedProtocolVersion = errors.New("swarm protocol: unsupported version")
+	ErrUnsupportedProtocolVersion = errors.New("subagent protocol: unsupported version")
 )
 var commandNames = map[string]struct{}{
 //	 "turn_id":"...","timestamp":"...","payload":{...}}
 //
 // TurnID is omitted when it is empty. Unknown top-level fields are retained in
-// Unknown. A flat legacy event is represented by Legacy=true and uses `time`
+// Unknown.
-// instead of `timestamp` when marshaled.
 type Envelope struct {
 	Version   int             `json:"version"`
 	Type      string          `json:"type"`
 	// Unknown contains unrecognised top-level fields from a versioned
 	// envelope. Payload itself retains unrecognised payload fields.
 	Unknown map[string]json.RawMessage `json:"-"`
-	// Legacy is true only for an old flat event read by ParseEnvelope. It
-	// causes MarshalJSON to retain the old flat shape. It is not set for a
-	// text inbox command, since text commands are normalised to a new
-	// versioned command as soon as they are read.
-	Legacy bool `json:"-"`
-	// LegacyCommand and LegacyText record that this envelope came from a
-	// text inbox command. They are useful to bridges that need to echo the
-	// original command, and do not affect versioned JSON marshaling.
-	LegacyCommand bool   `json:"-"`
-	LegacyText    string `json:"-"`
 }
 // Command and ProtocolEvent are aliases rather than separate structs so a
 // NewEnvelopeWithPayload is the checked form of NewEnvelope.
 func NewEnvelopeWithPayload(typ, agentID, turnID string, payload any) (Envelope, error) {
 	if strings.TrimSpace(typ) == "" {
-		return Envelope{}, errors.New("swarm protocol: empty message type")
+		return Envelope{}, errors.New("subagent protocol: empty message type")
 	}
 	p, err := marshalPayload(payload)
 	if err != nil {
-		return Envelope{}, fmt.Errorf("swarm protocol payload: %w", err)
+		return Envelope{}, fmt.Errorf("subagent protocol payload: %w", err)
 	}
 	return Envelope{
 		Version:   ProtocolVersion,
 }
 // NewProtocolEvent is a more explicit spelling of NewEventEnvelope. NewEvent
-// is already the legacy flat-event constructor in this package.
+// is the canonical event-envelope constructor in this package.
 func NewProtocolEvent(name, agentID, turnID string, payload ...any) Envelope {
 	return NewEventEnvelope(name, agentID, turnID, payload...)
 }
 // intentionally separate from ParseEnvelope: parsing an unknown future event
 // should succeed, while a sender can opt into strict validation before write.
 func (e Envelope) Validate() error {
-	if e.Legacy {
-		if e.Type == "" {
-			return errors.New("swarm protocol: legacy event has no type")
-		}
-		return nil
-	}
 	if e.Version != ProtocolVersion {
 		return fmt.Errorf("%w: %d", ErrUnsupportedProtocolVersion, e.Version)
 	}
 	if e.Type == "" {
-		return errors.New("swarm protocol: missing type")
+		return errors.New("subagent protocol: missing type")
 	}
 	if e.MessageID == "" {
-		return errors.New("swarm protocol: missing message_id")
+		return errors.New("subagent protocol: missing message_id")
 	}
 	if e.AgentID == "" {
-		return errors.New("swarm protocol: missing agent_id")
+		return errors.New("subagent protocol: missing agent_id")
 	}
 	if e.Timestamp.IsZero() {
-		return errors.New("swarm protocol: missing timestamp")
+		return errors.New("subagent protocol: missing timestamp")
 	}
 	if len(e.Payload) == 0 || !json.Valid(e.Payload) {
-		return errors.New("swarm protocol: invalid payload")
+		return errors.New("subagent protocol: invalid payload")
 	}
 	return nil
 }
 // event while still retaining it for a later forward-compatible write.
 func (e Envelope) DecodePayload(dst any) error {
 	if dst == nil {
-		return errors.New("swarm protocol: nil payload destination")
+		return errors.New("subagent protocol: nil payload destination")
 	}
 	if len(e.Payload) == 0 {
-		return errors.New("swarm protocol: missing payload")
+		return errors.New("subagent protocol: missing payload")
 	}
 	return json.Unmarshal(e.Payload, dst)
 }
 		return nil, err
 	}
 	if fields == nil {
-		return nil, errors.New("swarm protocol: payload is not an object")
+		return nil, errors.New("subagent protocol: payload is not an object")
 	}
 	return fields, nil
 }
 // message id intact.
 func (e *Envelope) SetPayload(payload any) error {
 	if e == nil {
-		return errors.New("swarm protocol: nil envelope")
+		return errors.New("subagent protocol: nil envelope")
 	}
 	p, err := marshalPayload(payload)
 	if err != nil {
-		return fmt.Errorf("swarm protocol payload: %w", err)
+		return fmt.Errorf("subagent protocol payload: %w", err)
 	}
 	e.Payload = p
 	return nil
 }
-// ParseEnvelope parses either a versioned envelope or a legacy flat event.
+// ParseEnvelope parses one current-protocol envelope. Unknown event types and
-// Unknown event types and unknown payload fields are valid and retained.
+// unknown payload fields are valid and retained.
 func ParseEnvelope(data []byte) (Envelope, error) {
 	data = bytes.TrimSpace(data)
 	if len(data) == 0 {
 	}
 	var raw map[string]json.RawMessage
 	if err := json.Unmarshal(data, &raw); err != nil {
-		return Envelope{}, fmt.Errorf("swarm protocol: decode envelope: %w", err)
+		return Envelope{}, fmt.Errorf("subagent protocol: decode envelope: %w", err)
 	}
 	if raw == nil {
-		return Envelope{}, errors.New("swarm protocol: envelope must be an object")
+		return Envelope{}, errors.New("subagent protocol: envelope must be an object")
 	}
 	var e Envelope
-	if hasNumericVersion(raw) {
+	if err := unmarshalVersionedEnvelope(raw, &e); err != nil {
-		if err := unmarshalVersionedEnvelope(raw, &e); err != nil {
-			return Envelope{}, err
-		}
-		return e, nil
-	}
-	if err := unmarshalLegacyEvent(raw, &e); err != nil {
 		return Envelope{}, err
 	}
 	return e, nil
 	return ParseEnvelope([]byte(line))
 }
-// ParseEvent parses a versioned or legacy JSON event. A known command is
+// ParseEvent parses a current-protocol JSON event. A known command is
 // rejected; unknown types are accepted because an older peer cannot know
 // whether a future event name is present in its event registry.
 func ParseEvent(data []byte) (Envelope, error) {
 // ParseEventLine parses one JSONL event line.
 func ParseEventLine(line string) (Envelope, error) { return ParseEvent([]byte(line)) }
-// ParseCommand parses either a versioned JSON command or one of the legacy
+// ParseCommand parses one current-protocol JSON command.
-// text inbox commands: `user <prompt>`, `cancel`, and `shutdown`. The text
-// form is normalised to a versioned envelope with a fresh message id.
 func ParseCommand(line string) (Envelope, error) {
-	raw := strings.TrimRight(line, "\r\n")
+	raw := strings.TrimSpace(line)
-	if strings.TrimSpace(raw) == "" {
+	if raw == "" {
 		return Envelope{}, ErrEmptyProtocolLine
 	}
-	if strings.HasPrefix(strings.TrimSpace(raw), "{") {
+	e, err := ParseEnvelope([]byte(raw))
-		e, err := ParseEnvelope([]byte(raw))
+	if err != nil {
-		if err != nil {
+		return Envelope{}, err
-			return Envelope{}, err
+	}
-		}
+	if IsEventName(e.Type) {
-		if IsEventName(e.Type) {
+		return Envelope{}, ErrNotCommand
-			return Envelope{}, ErrNotCommand
-		}
-		return e, nil
 	}
-	return ParseLegacyCommand(raw)
+	return e, nil
 }
 // ParseCommandLine is an alias for ParseCommand.
 func ParseCommandLine(line string) (Envelope, error) { return ParseCommand(line) }
-// ParseLegacyCommand converts the old text inbox command syntax to a current
-// envelope. The old syntax had no agent or turn id, so those fields remain
-// empty until the owning supervisor supplies them.
-func ParseLegacyCommand(line string) (Envelope, error) {
-	if strings.TrimSpace(line) == "" {
-		return Envelope{}, ErrEmptyProtocolLine
-	}
-	var e Envelope
-	switch {
-	case strings.HasPrefix(line, "user "):
-		e = NewCommand(CommandTurnStart, "", "", TurnStartPayload{Prompt: strings.TrimPrefix(line, "user ")})
-	case strings.TrimSpace(line) == "cancel":
-		e = NewCommand(CommandTurnCancel, "", "", TurnCancelPayload{})
-	case strings.TrimSpace(line) == "shutdown":
-		e = NewCommand(CommandAgentShutdown, "", "", AgentShutdownPayload{})
-	case strings.TrimSpace(line) == "ping":
-		e = NewCommand(CommandAgentPing, "", "", AgentPingPayload{})
-	default:
-		return Envelope{}, fmt.Errorf("swarm protocol: unknown legacy command %q", line)
-	}
-	e.LegacyCommand = true
-	e.LegacyText = line
-	return e, nil
-}
 // MarshalEnvelope returns one JSON object without a trailing newline.
 func MarshalEnvelope(e Envelope) ([]byte, error) {
 	return json.Marshal(e)
 // WriteEnvelope writes one complete newline-terminated JSONL message.
 func WriteEnvelope(w io.Writer, e Envelope) error {
 	if w == nil {
-		return errors.New("swarm protocol: nil writer")
+		return errors.New("subagent protocol: nil writer")
 	}
 	b, err := MarshalJSONL(e)
 	if err != nil {
 // caller reading many messages should reuse the same bufio.Reader.
 func ReadEnvelope(r *bufio.Reader) (Envelope, error) {
 	if r == nil {
-		return Envelope{}, errors.New("swarm protocol: nil reader")
+		return Envelope{}, errors.New("subagent protocol: nil reader")
 	}
 	line, err := r.ReadBytes('\n')
 	if len(bytes.TrimSpace(line)) == 0 && err == io.EOF {
 	return Envelope{}, err
 }
-// MarshalLegacyCommand converts a normalised command back to the text inbox
-// syntax. It is intended for compatibility bridges, not for new transports.
-func MarshalLegacyCommand(e Envelope) (string, error) {
-	if !e.IsCommand() {
-		return "", ErrNotCommand
-	}
-	if e.LegacyCommand && e.LegacyText != "" {
-		return e.LegacyText, nil
-	}
-	fields, err := e.PayloadFields()
-	if err != nil {
-		return "", err
-	}
-	switch e.Type {
-	case CommandTurnStart:
-		var p TurnStartPayload
-		if err := e.DecodePayload(&p); err != nil {
-			return "", err
-		}
-		return "user " + p.Prompt, nil
-	case CommandTurnCancel:
-		return "cancel", nil
-	case CommandAgentShutdown:
-		return "shutdown", nil
-	case CommandAgentPing:
-		return "ping", nil
-	default:
-		_ = fields // retain the object check for useful errors above
-		return "", fmt.Errorf("swarm protocol: no legacy spelling for command %q", e.Type)
-	}
-}
-// LegacyEvent converts an envelope to the package's existing flat Event
-// representation. This is the compatibility bridge for the durable event
-// reader while callers migrate to Envelope.
-func (e Envelope) LegacyEvent() (Event, error) {
-	if e.IsCommand() {
-		return Event{}, ErrNotEvent
-	}
-	fields, err := e.PayloadFields()
-	if err != nil {
-		return Event{}, err
-	}
-	data := make(map[string]any, len(fields))
-	for key, raw := range fields {
-		var value any
-		if err := json.Unmarshal(raw, &value); err != nil {
-			return Event{}, fmt.Errorf("swarm protocol payload field %q: %w", key, err)
-		}
-		data[key] = value
-	}
-	return Event{
-		Time: e.Timestamp, Type: e.Type, Version: e.Version,
-		MessageID: e.MessageID, AgentID: e.AgentID, TurnID: e.TurnID,
-		Data: data,
-	}, nil
-}
-// EnvelopeFromEvent upgrades an existing flat Event to the current protocol.
-// The event's Data is copied into a raw payload and the generated envelope
-// receives fresh metadata.
-func EnvelopeFromEvent(ev Event, agentID, turnID string) Envelope {
-	return NewEventEnvelope(ev.Type, agentID, turnID, ev.Data)
-}
-// EventFromEnvelope is an alias for LegacyEvent.
-func EventFromEnvelope(e Envelope) (Event, error) { return e.LegacyEvent() }
 func (e Envelope) MarshalJSON() ([]byte, error) {
-	if e.Legacy {
-		return e.marshalLegacyJSON()
-	}
 	return e.marshalVersionedJSON()
 }
 func (e Envelope) marshalVersionedJSON() ([]byte, error) {
 	version := e.Version
-	if version == LegacyProtocolVersion {
-		version = ProtocolVersion
-	}
 	messageID := e.MessageID
 	if messageID == "" {
 		messageID = NewMessageID()
 		payload = json.RawMessage("{}")
 	}
 	if !json.Valid(payload) {
-		return nil, errors.New("swarm protocol: invalid payload JSON")
+		return nil, errors.New("subagent protocol: invalid payload JSON")
 	}
 	out := make(map[string]json.RawMessage, len(e.Unknown)+7)
 	for key, value := range e.Unknown {
 	return json.Marshal(out)
 }
-func (e Envelope) marshalLegacyJSON() ([]byte, error) {
-	fields, err := e.PayloadFields()
-	if err != nil {
-		return nil, err
-	}
-	out := make(map[string]json.RawMessage, len(fields)+5)
-	for key, value := range fields {
-		out[key] = cloneRaw(value)
-	}
-	for key, value := range e.Unknown {
-		if isLegacyEnvelopeField(key) {
-			continue
-		}
-		if _, exists := out[key]; !exists {
-			out[key] = cloneRaw(value)
-		}
-	}
-	putRaw(out, "type", e.Type)
-	if !e.Timestamp.IsZero() {
-		putRaw(out, "time", e.Timestamp)
-	}
-	if e.MessageID != "" {
-		putRaw(out, "message_id", e.MessageID)
-	}
-	if e.AgentID != "" {
-		putRaw(out, "agent_id", e.AgentID)
-	}
-	if e.TurnID != "" {
-		putRaw(out, "turn_id", e.TurnID)
-	}
-	return json.Marshal(out)
-}
 func (e *Envelope) UnmarshalJSON(data []byte) error {
 	var raw map[string]json.RawMessage
 	if err := json.Unmarshal(data, &raw); err != nil {
 		return err
 	}
 	if raw == nil {
-		return errors.New("swarm protocol: envelope must be an object")
+		return errors.New("subagent protocol: envelope must be an object")
 	}
 	var parsed Envelope
-	if hasNumericVersion(raw) {
+	if err := unmarshalVersionedEnvelope(raw, &parsed); err != nil {
-		if err := unmarshalVersionedEnvelope(raw, &parsed); err != nil {
-			return err
-		}
-	} else if err := unmarshalLegacyEvent(raw, &parsed); err != nil {
 		return err
 	}
 	*e = parsed
 	return nil
 }
-func hasNumericVersion(raw map[string]json.RawMessage) bool {
-	value, ok := raw["version"]
-	if !ok {
-		return false
-	}
-	var version int
-	return json.Unmarshal(value, &version) == nil
-}
 func unmarshalVersionedEnvelope(raw map[string]json.RawMessage, e *Envelope) error {
 	if err := decodeRequired(raw, "version", &e.Version); err != nil {
 		return err
 	}
 	if timestamp, ok := raw["timestamp"]; ok {
 		if err := json.Unmarshal(timestamp, &e.Timestamp); err != nil {
-			return fmt.Errorf("swarm protocol: timestamp: %w", err)
+			return fmt.Errorf("subagent protocol: timestamp: %w", err)
 		}
 	}
 	if payload, ok := raw["payload"]; ok {
 	return nil
 }
-func unmarshalLegacyEvent(raw map[string]json.RawMessage, e *Envelope) error {
-	if err := decodeRequired(raw, "type", &e.Type); err != nil {
-		return err
-	}
-	e.Version = LegacyProtocolVersion
-	e.Legacy = true
-	if err := decodeOptionalString(raw, "message_id", &e.MessageID); err != nil {
-		return err
-	}
-	if err := decodeOptionalString(raw, "agent_id", &e.AgentID); err != nil {
-		return err
-	}
-	if err := decodeOptionalString(raw, "turn_id", &e.TurnID); err != nil {
-		return err
-	}
-	if value, ok := raw["time"]; ok {
-		// Legacy Event historically ignored an invalid timestamp. Keep that
-		// permissive behaviour while still retaining all other fields.
-		_ = json.Unmarshal(value, &e.Timestamp)
-	}
-	payload := make(map[string]json.RawMessage)
-	for key, value := range raw {
-		switch key {
-		case "type", "time", "message_id", "agent_id", "turn_id":
-			continue
-		}
-		payload[key] = cloneRaw(value)
-	}
-	if len(payload) == 0 {
-		e.Payload = json.RawMessage("{}")
-	} else {
-		encoded, err := json.Marshal(payload)
-		if err != nil {
-			return err
-		}
-		e.Payload = encoded
-	}
-	return nil
-}
 func decodeRequired(raw map[string]json.RawMessage, name string, dst any) error {
 	value, ok := raw[name]
 	if !ok {
-		return fmt.Errorf("swarm protocol: missing %s", name)
+		return fmt.Errorf("subagent protocol: missing %s", name)
 	}
 	if err := json.Unmarshal(value, dst); err != nil {
-		return fmt.Errorf("swarm protocol: %s: %w", name, err)
+		return fmt.Errorf("subagent protocol: %s: %w", name, err)
 	}
 	if name == "type" {
 		if text, ok := dst.(*string); ok && strings.TrimSpace(*text) == "" {
-			return errors.New("swarm protocol: empty message type")
+			return errors.New("subagent protocol: empty message type")
 		}
 	}
 	return nil
 		return nil
 	}
 	if err := json.Unmarshal(value, dst); err != nil {
-		return fmt.Errorf("swarm protocol: %s: %w", name, err)
+		return fmt.Errorf("subagent protocol: %s: %w", name, err)
 	}
 	return nil
 }
 	}
 }
-func isLegacyEnvelopeField(key string) bool {
-	switch key {
-	case "type", "time", "message_id", "agent_id", "turn_id", "version", "timestamp", "payload":
-		return true
-	default:
-		return false
-	}
-}
 func putRaw(out map[string]json.RawMessage, key string, value any) {
 	b, err := json.Marshal(value)
 	if err == nil {
 type AgentPingPayload struct{}
 type AgentShutdownPayload struct{}
 type AgentReadyPayload struct {
-	// Version is the worker/application version used by the legacy ready
+	// Version is the worker/application version. WorkerVersion is the
-	// event. WorkerVersion is the unambiguous spelling for new producers.
+	// unambiguous spelling for new producers.
 	Version       string `json:"version,omitempty"`
 	WorkerVersion string `json:"worker_version,omitempty"`
 	CWD           string `json:"cwd,omitempty"`

R packages/agent/swarm/protocol_test.go → packages/agent/subagents/protocol_test.go +2 -80 renamed, 76% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"bufio"	4		"bufio"

@@ -102,84 +102,6 @@ func TestProtocolPreservesUnknownEventAndPayload(t *testing.T) {
102		}	102		}
103		}	103		}
104			104
105	-	func TestProtocolReadsAndRetainsLegacyFlatEvent(t *testing.T) {
106	-	// Legacy agent.ready events historically used a string `version`
107	-	// payload field, so its presence must not be mistaken for the numeric
108	-	// protocol version field.
109	-	input := `{"type":"assistant_message","time":"2026-08-04T12:00:00.123Z","version":"zot-test","content":[{"type":"text","text":"hello"}],"new_field":{"v":7}}`
110	-	e, err := ParseEvent([]byte(input))
111	-	if err != nil {
112	-	t.Fatalf("ParseEvent: %v", err)
113	-	}
114	-	if !e.Legacy \|\| e.Version != LegacyProtocolVersion {
115	-	t.Fatalf("legacy marker/version = %v/%d", e.Legacy, e.Version)
116	-	}
117	-	if e.Type != "assistant_message" \|\| e.Timestamp.IsZero() {
118	-	t.Fatalf("legacy metadata = %+v", e)
119	-	}
120	-	legacy, err := e.LegacyEvent()
121	-	if err != nil {
122	-	t.Fatalf("LegacyEvent: %v", err)
123	-	}
124	-	if legacy.Type != e.Type \|\| legacy.Data["version"] != "zot-test" \|\| legacy.Data["new_field"] == nil {
125	-	t.Fatalf("legacy conversion lost data: %+v", legacy)
126	-	}
127	-
128	-	encoded, err := MarshalEnvelope(e)
129	-	if err != nil {
130	-	t.Fatalf("MarshalEnvelope legacy: %v", err)
131	-	}
132	-	var got map[string]any
133	-	if err := json.Unmarshal(encoded, &got); err != nil {
134	-	t.Fatalf("legacy output JSON: %v", err)
135	-	}
136	-	if got["version"] != "zot-test" {
137	-	t.Fatalf("legacy payload version was changed: %#v", got["version"])
138	-	}
139	-	if got["type"] != "assistant_message" \|\| got["new_field"] == nil {
140	-	t.Fatalf("legacy fields not retained: %#v", got)
141	-	}
142	-	}
143	-
144	-	func TestProtocolParsesLegacyTextCommands(t *testing.T) {
145	-	tests := []struct {
146	-	line string
147	-	kind string
148	-	want string
149	-	}{
150	-	{"user inspect the parser ", CommandTurnStart, "inspect the parser "},
151	-	{"cancel", CommandTurnCancel, ""},
152	-	{"shutdown", CommandAgentShutdown, ""},
153	-	}
154	-	for _, tt := range tests {
155	-	t.Run(tt.line, func(t *testing.T) {
156	-	e, err := ParseCommand(tt.line)
157	-	if err != nil {
158	-	t.Fatalf("ParseCommand: %v", err)
159	-	}
160	-	if e.Type != tt.kind \|\| e.Version != ProtocolVersion \|\| e.MessageID == "" {
161	-	t.Fatalf("command metadata = %+v", e)
162	-	}
163	-	if !e.LegacyCommand \|\| e.LegacyText != tt.line {
164	-	t.Fatalf("legacy source was not retained: %+v", e)
165	-	}
166	-	if tt.want != "" {
167	-	var payload TurnStartPayload
168	-	if err := e.DecodePayload(&payload); err != nil {
169	-	t.Fatalf("DecodePayload: %v", err)
170	-	}
171	-	if payload.Prompt != tt.want {
172	-	t.Fatalf("prompt = %q, want %q", payload.Prompt, tt.want)
173	-	}
174	-	}
175	-	legacy, err := MarshalLegacyCommand(e)
176	-	if err != nil \|\| legacy != tt.line {
177	-	t.Fatalf("MarshalLegacyCommand = %q, %v; want %q", legacy, err, tt.line)
178	-	}
179	-	})
180	-	}
181	-	}
182	-
183		func TestProtocolJSONCommandsAndDirectionChecks(t *testing.T) {	105		func TestProtocolJSONCommandsAndDirectionChecks(t *testing.T) {
184		command := NewCommand(CommandTurnStart, "agent-1", "turn-2", TurnStartPayload{Prompt: "hello"})	106		command := NewCommand(CommandTurnStart, "agent-1", "turn-2", TurnStartPayload{Prompt: "hello"})
185		line, err := MarshalJSONL(command)	107		line, err := MarshalJSONL(command)

@@ -266,7 +188,7 @@ func TestProtocolUnsupportedVersion(t *testing.T) {
266		}	188		}
267		}	189		}
268			190
269	-	func TestProtocolLegacyEmptyAndMalformedInputs(t *testing.T) {	191	+	func TestProtocolEmptyAndMalformedInputs(t *testing.T) {
270		for _, input := range []string{"", " ", "not a command"} {	192		for _, input := range []string{"", " ", "not a command"} {
271		if _, err := ParseCommand(input); err == nil {	193		if _, err := ParseCommand(input); err == nil {
272		t.Errorf("ParseCommand(%q) succeeded", input)	194		t.Errorf("ParseCommand(%q) succeeded", input)

R packages/agent/swarm/result.go → packages/agent/subagents/result.go +7 -7 renamed, 96% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

@@ -248,7 +248,7 @@ func writeTurnResult(stateDir string, result *TurnResult) error {
248		return nil	248		return nil
249		}	249		}
250			250
251	-	func (f Swarm) captureWorkspace(a Agent) {	251	+	func (f Supervisor) captureWorkspace(a Agent) {
252		if a == nil \|\| a.workspaceCapture == nil {	252		if a == nil \|\| a.workspaceCapture == nil {
253		return	253		return
254		}	254		}

@@ -280,7 +280,7 @@ func (f Swarm) captureWorkspace(a Agent) {
280		a.lifecycleMu.Unlock()	280		a.lifecycleMu.Unlock()
281		}	281		}
282			282
283	-	func (f Swarm) ensureResult(a Agent, status Status, runErr error) {	283	+	func (f Supervisor) ensureResult(a Agent, status Status, runErr error) {
284		if a == nil {	284		if a == nil {
285		return	285		return
286		}	286		}

@@ -371,7 +371,7 @@ func (f Swarm) ensureResult(a Agent, status Status, runErr error) {
371		}	371		}
372			372
373		// ReadResult returns the durable structured result for an agent.	373		// ReadResult returns the durable structured result for an agent.
374	-	func (f Swarm) ReadResult(id string) (TurnResult, error) {	374	+	func (f Supervisor) ReadResult(id string) (TurnResult, error) {
375		a := f.Get(id)	375		a := f.Get(id)
376		if a == nil {	376		if a == nil {
377		return nil, fmt.Errorf("subagents: no such agent %q", id)	377		return nil, fmt.Errorf("subagents: no such agent %q", id)

@@ -392,9 +392,9 @@ func (f Swarm) ReadResult(id string) (TurnResult, error) {
392		return result.Bounded(f.cfg.Policy.MaxOutputBytes, f.cfg.Policy.MaxOutputLines), nil	392		return result.Bounded(f.cfg.Policy.MaxOutputBytes, f.cfg.Policy.MaxOutputLines), nil
393		}	393		}
394			394
395	-	func (f *Swarm) ResultReference(id string) string { return ResultRef(id) }	395	+	func (f *Supervisor) ResultReference(id string) string { return ResultRef(id) }
396	-	func (f *Swarm) HistoryReference(id string) string { return HistoryRef(id) }	396	+	func (f *Supervisor) HistoryReference(id string) string { return HistoryRef(id) }
397	-	func (f *Swarm) PatchReference(id string) string { return PatchRef(id) }	397	+	func (f *Supervisor) PatchReference(id string) string { return PatchRef(id) }
398			398
399		func readTurnResult(stateDir string) (*TurnResult, error) {	399		func readTurnResult(stateDir string) (*TurnResult, error) {
400		file, err := os.Open(resultPath(stateDir))	400		file, err := os.Open(resultPath(stateDir))

R packages/agent/swarm/result_test.go → packages/agent/subagents/result_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"encoding/json"	4		"encoding/json"

R packages/agent/swarm/runner.go → packages/agent/subagents/runner.go +48 -53 renamed, 88% similar

-package swarm
+package subagents
 import (
 	"bufio"
 //
 // Why a long-lived daemon and not `zot --print`: the supervisor and
 // the user expect agents to keep accepting follow-up prompts. A
-// one-shot subprocess can't do that; this design gives each swarm
+// one-shot subprocess can't do that; this design gives each subagent
 // agent a persistent session file plus an inbox socket the parent
 // writes to, mirroring Claude Code's "Agents view" model.
 //
 	Command []string
 	// SessionPath is the agent's session file. Empty means "defer
-	// to r.agent.SessionPath", which Swarm.Spawn always populates
+	// to r.agent.SessionPath", which Supervisor.Spawn always populates
-	// with <swarm-root>/agents/<id>/session.json. Tests that
+	// with <subagent-root>/agents/<id>/session.json. Tests that
 	// hand-build an Agent without going through Spawn must set
 	// one of the two; the runner refuses to invent a fallback
 	// because the only plausible one (<Dir>/.zot/session.json)
 	SessionPath string
 }
-// swarmAgentArgsOpts captures every dynamic input to swarmAgentArgs.
+// subagentWorkerArgsOpts captures every dynamic input to subagentWorkerArgs.
 // The fields map 1:1 onto child CLI flags; empty values omit the flag
 // entirely and let the child resolve a default the same way a normal
 // `zot` invocation does.
-type swarmAgentArgsOpts struct {
+type subagentWorkerArgsOpts struct {
 	Exe         string
 	Dir         string
 	SessionPath string
 	if a.Resuming {
 		task = ""
 	}
-	return swarmAgentArgs(swarmAgentArgsOpts{
+	return subagentWorkerArgs(subagentWorkerArgsOpts{
 		Exe:         exe,
 		Dir:         a.Dir,
 		SessionPath: sessionPath,
 	})
 }
-// swarmAgentArgs builds the argv used when execRunner.Command is
+// subagentWorkerArgs builds the argv used when execRunner.Command is
 // empty. Pulled out so tests can lock in the flag set without
 // actually spawning a subprocess.
-func swarmAgentArgs(opts swarmAgentArgsOpts) []string {
+func subagentWorkerArgs(opts subagentWorkerArgsOpts) []string {
 	args := []string{
 		opts.Exe,
 		"--subagent-worker", opts.InboxPath,
-		// Keep the old flag during the compatibility window. The child
-		// parser accepts both and canonicalises the mode internally.
-		"--swarm-agent", opts.InboxPath,
 		"--session", opts.SessionPath,
 		"--cwd", opts.Dir,
 	}
 func (r *execRunner) Run(ctx context.Context, sink Sink) error {
 	// SessionPath resolution order:
 	//   1. explicit r.SessionPath set by the test / caller
-	//   2. r.agent.SessionPath baked in by Swarm.Spawn — the
+	//   2. r.agent.SessionPath baked in by Supervisor.Spawn — the
 	//      production path. Always lives under
-	//      <swarm-root>/agents/<id>/session.json so the per-
+	//      <subagent-root>/agents/<id>/session.json so the per-
 	//      agent state is entirely outside the working tree.
 	//      Crucial because Agent.Dir points at the user's repo;
 	//      any .zot/ scratch directory under Dir would litter
 		sessionPath = r.agent.SessionPath
 	}
 	if sessionPath == "" {
-		return fmt.Errorf("swarm: agent missing session path (set SpawnRequest via Swarm.SpawnReq, or hand-build Agent with SessionPath populated)")
+		return fmt.Errorf("subagent: agent missing session path (set SpawnRequest via Supervisor.SpawnReq, or hand-build Agent with SessionPath populated)")
 	}
 	if err := os.MkdirAll(filepath.Dir(sessionPath), 0o755); err != nil {
 		return fmt.Errorf("session dir: %w", err)
 	inboxPath := r.agent.InboxPath
 	logPath := r.agent.EventLogPath
 	if logPath == "" {
-		return fmt.Errorf("swarm: agent missing event log path")
+		return fmt.Errorf("subagent: agent missing event log path")
 	}
 	log, err := OpenEventLog(logPath)
 	if err != nil {
 	configureWorkerProcess(cmd)
 	cmd.Dir = r.agent.Dir
 	cmd.Env = append(workerEnvironment(r.agent.Provider),
-		"ZOT_SWARM_AGENT_ID="+r.agent.ID,
+		"ZOT_SUBAGENT_AGENT_ID="+r.agent.ID,
-		"ZOT_SWARM_EVENT_LOG="+logPath,
+		"ZOT_SUBAGENT_EVENT_LOG="+logPath,
 	)
 	if r.agent.HeartbeatInterval > 0 {
-		cmd.Env = append(cmd.Env, "ZOT_SWARM_HEARTBEAT_INTERVAL="+r.agent.HeartbeatInterval.String())
+		cmd.Env = append(cmd.Env, "ZOT_SUBAGENT_HEARTBEAT_INTERVAL="+r.agent.HeartbeatInterval.String())
 	}
 	if r.agent.maxOutputBytes > 0 {
-		cmd.Env = append(cmd.Env, fmt.Sprintf("ZOT_SWARM_MAX_OUTPUT_BYTES=%d", r.agent.maxOutputBytes))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("ZOT_SUBAGENT_MAX_OUTPUT_BYTES=%d", r.agent.maxOutputBytes))
 	}
 	if r.agent.maxOutputLines > 0 {
-		cmd.Env = append(cmd.Env, fmt.Sprintf("ZOT_SWARM_MAX_OUTPUT_LINES=%d", r.agent.maxOutputLines))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("ZOT_SUBAGENT_MAX_OUTPUT_LINES=%d", r.agent.maxOutputLines))
 	}
 	if r.resolveCredential != nil {
 		credential, resolveErr := r.resolveCredential(ctx, r.agent.Provider)
 		if resolveErr != nil {
-			return fmt.Errorf("resolve swarm credential for %s: %w", r.agent.Provider, resolveErr)
+			return fmt.Errorf("resolve subagent credential for %s: %w", r.agent.Provider, resolveErr)
 		}
 		if credential.Value != "" {
 			encoded, encodeErr := json.Marshal(credential)
 			if encodeErr != nil {
-				return fmt.Errorf("encode swarm credential: %w", encodeErr)
+				return fmt.Errorf("encode subagent credential: %w", encodeErr)
 			}
 			cmd.Stdin = bytes.NewReader(encoded)
-			cmd.Env = append(cmd.Env, "ZOT_SWARM_CREDENTIAL_STDIN=1")
+			cmd.Env = append(cmd.Env, "ZOT_SUBAGENT_CREDENTIAL_STDIN=1")
 		}
 	}
 						// also forwards provider/tool-loop turn_end
 						// events (for example stop=tool_use); those do
 						// not contain step and must not be treated as
-						// swarm task completion.
+						// subagent task completion.
 						notifyPromptTurnEnd(r.agent, ev)
 					} else {
 						sink.Transcript(trimmed)
 	if err != nil && ctx.Err() != nil {
 		appendLog(NewEvent("agent_stopped", map[string]any{"reason": "cancelled"}))
 		if logErr := firstLogErr(); logErr != nil {
-			return fmt.Errorf("swarm event log: %w", logErr)
+			return fmt.Errorf("subagent event log: %w", logErr)
 		}
 		return ctx.Err()
 	}
 	if err != nil {
 		appendLog(NewEvent("agent_stopped", map[string]any{"reason": "exit", "code": exit, "error": err.Error()}))
 		if logErr := firstLogErr(); logErr != nil {
-			return fmt.Errorf("swarm event log: %v; worker: %w", logErr, err)
+			return fmt.Errorf("subagent event log: %v; worker: %w", logErr, err)
 		}
 		return err
 	}
 	appendLog(NewEvent("agent_stopped", map[string]any{"reason": "exit", "code": 0}))
 	if logErr := firstLogErr(); logErr != nil {
-		return fmt.Errorf("swarm event log: %w", logErr)
+		return fmt.Errorf("subagent event log: %w", logErr)
 	}
 	sink.Activity("done")
 	return nil
 	}
 }
-// parseEventLine attempts to decode one JSONL line as an Event.
+// parseEventLine attempts to decode one current-protocol JSONL line as an Event.
-// Returns ok=false for non-JSON or JSON without a "type" field.
 func parseEventLine(line string) (Event, bool) {
 	if len(line) == 0 || line[0] != '{' {
 		return Event{}, false
 	}
-	if env, err := ParseEvent([]byte(line)); err == nil && !env.Legacy {
+	env, err := ParseEvent([]byte(line))
-		if ev, convertErr := env.LegacyEvent(); convertErr == nil {
+	if err != nil {
-			ev.Version = env.Version
-			ev.MessageID = env.MessageID
-			ev.AgentID = env.AgentID
-			ev.TurnID = env.TurnID
-			if ev.Time.IsZero() {
-				ev.Time = time.Now()
-			}
-			return ev, true
-		}
-	}
-	var ev Event
-	if err := json.Unmarshal([]byte(line), &ev); err != nil {
 		return Event{}, false
 	}
-	if ev.Type == "" {
+	fields, err := env.PayloadFields()
+	if err != nil {
 		return Event{}, false
 	}
-	if ev.Time.IsZero() {
+	data := make(map[string]any, len(fields))
-		ev.Time = time.Now()
+	for key, raw := range fields {
+		var value any
+		if err := json.Unmarshal(raw, &value); err != nil {
+			return Event{}, false
+		}
+		data[key] = value
+	}
+	when := env.Timestamp
+	if when.IsZero() {
+		when = time.Now()
 	}
-	return ev, true
+	return Event{
+		Time: when, Type: env.Type, Version: env.Version,
+		MessageID: env.MessageID, AgentID: env.AgentID, TurnID: env.TurnID,
+		Data: data,
+	}, true
 }
 func updateAgentFromEvent(a *Agent, ev Event) {
 	if now.IsZero() {
 		now = time.Now()
 	}
-	if ev.Version > 0 {
-		a.setProtocolVersion(ev.Version)
-	}
 	a.markActivity(now)
 	persist := false
 	switch ev.Type {
 	}
 }
-// notifyPromptTurnEnd calls Agent.OnTurnEnd only for the swarm
+// notifyPromptTurnEnd calls Agent.OnTurnEnd only for the subagent
 // daemon's prompt-level completion event. Provider/tool-loop
 // turn_end events (such as stop=tool_use) do not include step and
 // are not terminal for the delegated task.
 	case "agent_ready", EventAgentReady, EventAgentHeartbeat:
 		sink.Activity("idle")
 	case "agent_stopped":
-		// terminal status is decided by Swarm.run from the runner's
+		// terminal status is decided by Supervisor.run from the runner's
 		// return value, not from this event. Don't overwrite the
 		// activity here.
 	case "error":

R packages/agent/swarm/runner_e2e_test.go → packages/agent/subagents/runner_e2e_test.go +9 -9 renamed, 88% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

@@ -15,11 +15,11 @@ import (
15		// TestRunnerEndToEndWithStubChild is the integration test for the	15		// TestRunnerEndToEndWithStubChild is the integration test for the
16		// new daemon-mode runner. It compiles the stubchild binary in	16		// new daemon-mode runner. It compiles the stubchild binary in
17		// testdata/cmd/stubchild, points an execRunner at it, and drives	17		// testdata/cmd/stubchild, points an execRunner at it, and drives
18	-	// a Swarm through one Spawn + one SendUserTurn + Stop cycle.	18	+	// a Supervisor through one Spawn + one SendUserTurn + Stop cycle.
19		//	19		//
20		// What this proves:	20		// What this proves:
21		//	21		//
22	-	// - The default argv shape (swarmAgentArgs) is one the child can	22	+	// - The default argv shape (subagentWorkerArgs) is one the child can
23		// actually parse — locks the shape against silent breakage.	23		// actually parse — locks the shape against silent breakage.
24		// - The stdout JSONL parser ingests events and writes them to the	24		// - The stdout JSONL parser ingests events and writes them to the
25		// durable log.	25		// durable log.

@@ -50,7 +50,7 @@ func TestRunnerEndToEndWithStubChild(t *testing.T) {
50		NewRunner: func(a *Agent) Runner {	50		NewRunner: func(a *Agent) Runner {
51		return &execRunner{	51		return &execRunner{
52		agent: a,	52		agent: a,
53	-	Command: swarmAgentArgs(swarmAgentArgsOpts{	53	+	Command: subagentWorkerArgs(subagentWorkerArgsOpts{
54		Exe: exe,	54		Exe: exe,
55		Dir: a.Dir,	55		Dir: a.Dir,
56		SessionPath: a.SessionPath,	56		SessionPath: a.SessionPath,

@@ -94,13 +94,13 @@ func TestRunnerEndToEndWithStubChild(t *testing.T) {
94			94
95		// Send a follow-up over the inbox. The stub echoes the text into	95		// Send a follow-up over the inbox. The stub echoes the text into
96		// an assistant_message we can poll for in the log.	96		// an assistant_message we can poll for in the log.
97	-	if err := retrySend(f, a.ID, "user follow up", time.Second); err != nil {	97	+	if err := retrySend(f, a.ID, "follow up", time.Second); err != nil {
98	-	t.Fatalf("SendInput: %v", err)	98	+	t.Fatalf("SendUserTurn: %v", err)
99		}	99		}
100		waitFor("echo: follow up")	100		waitFor("echo: follow up")
101			101
102		// Shut the agent down gracefully via the inbox.	102		// Shut the agent down gracefully via the inbox.
103	-	if err := f.SendInput(a.ID, "shutdown"); err != nil && !errors.Is(err, ErrNotReady) {	103	+	if err := a.inbox.SendCommand(NewCommand(CommandAgentShutdown, a.ID, a.CurrentTurnID(), AgentShutdownPayload{})); err != nil && !errors.Is(err, ErrNotReady) {
104		t.Fatalf("shutdown send: %v", err)	104		t.Fatalf("shutdown send: %v", err)
105		}	105		}
106		a.Wait()	106		a.Wait()

@@ -112,11 +112,11 @@ func TestRunnerEndToEndWithStubChild(t *testing.T) {
112		// retrySend exists because the inbox dial races against the child	112		// retrySend exists because the inbox dial races against the child
113		// opening the socket. Production callers handle ErrNotReady with a	113		// opening the socket. Production callers handle ErrNotReady with a
114		// status message; tests retry within a small window.	114		// status message; tests retry within a small window.
115	-	func retrySend(f *Swarm, id, msg string, timeout time.Duration) error {	115	+	func retrySend(f *Supervisor, id, msg string, timeout time.Duration) error {
116		deadline := time.Now().Add(timeout)	116		deadline := time.Now().Add(timeout)
117		var lastErr error	117		var lastErr error
118		for time.Now().Before(deadline) {	118		for time.Now().Before(deadline) {
119	-	err := f.SendInput(id, msg)	119	+	err := f.SendUserTurn(id, msg)
120		if err == nil {	120		if err == nil {
121		return nil	121		return nil
122		}	122		}

R packages/agent/swarm/runner_test.go → packages/agent/subagents/runner_test.go +20 -20 renamed, 90% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

@@ -11,8 +11,8 @@ import (
11		"time"	11		"time"
12		)	12		)
13			13
14	-	// TestSwarmAgentArgs locks in the exact flag set the subprocess	14	+	// TestSubagentWorkerArgs locks in the exact flag set the subprocess
15	-	// runner uses to start a swarm agent in daemon mode. Past	15	+	// runner uses to start a subagent agent in daemon mode. Past
16		// regressions in this area:	16		// regressions in this area:
17		//	17		//
18		// - "--no-sess" instead of "--no-session" (old print-mode runner):	18		// - "--no-sess" instead of "--no-session" (old print-mode runner):

@@ -31,10 +31,10 @@ import (
31		// positions. If a flag is renamed, update both the runner and this	31		// positions. If a flag is renamed, update both the runner and this
32		// test so we notice immediately.	32		// test so we notice immediately.
33		func TestCredentialStdinHelperProcess(t *testing.T) {	33		func TestCredentialStdinHelperProcess(t *testing.T) {
34	-	if os.Getenv("ZOT_SWARM_CREDENTIAL_HELPER") != "1" {	34	+	if os.Getenv("ZOT_SUBAGENT_CREDENTIAL_HELPER") != "1" {
35		return	35		return
36		}	36		}
37	-	if os.Getenv("ZOT_SWARM_CREDENTIAL_STDIN") != "1" {	37	+	if os.Getenv("ZOT_SUBAGENT_CREDENTIAL_STDIN") != "1" {
38		os.Exit(2)	38		os.Exit(2)
39		}	39		}
40		var credential Credential	40		var credential Credential

@@ -65,7 +65,7 @@ func TestWorkerEnvironmentRedactsProviderSecrets(t *testing.T) {
65		t.Setenv("GITHUB_TOKEN", "github-secret")	65		t.Setenv("GITHUB_TOKEN", "github-secret")
66		t.Setenv("CUSTOM_PROVIDER_TOKEN", "token-secret")	66		t.Setenv("CUSTOM_PROVIDER_TOKEN", "token-secret")
67		t.Setenv("GOOGLE_APPLICATION_CREDENTIALS", "/tmp/service-account.json")	67		t.Setenv("GOOGLE_APPLICATION_CREDENTIALS", "/tmp/service-account.json")
68	-	t.Setenv("ZOT_SWARM_TEST_VALUE", "not-secret")	68	+	t.Setenv("ZOT_SUBAGENT_TEST_VALUE", "not-secret")
69		env := strings.Join(workerEnvironment("openai"), "\n")	69		env := strings.Join(workerEnvironment("openai"), "\n")
70		for _, secret := range []string{	70		for _, secret := range []string{
71		"OPENAI_API_KEY=openai-secret",	71		"OPENAI_API_KEY=openai-secret",

@@ -79,7 +79,7 @@ func TestWorkerEnvironmentRedactsProviderSecrets(t *testing.T) {
79		t.Fatalf("worker environment leaked %s", secret)	79		t.Fatalf("worker environment leaked %s", secret)
80		}	80		}
81		}	81		}
82	-	if !strings.Contains(env, "ZOT_SWARM_TEST_VALUE=not-secret") {	82	+	if !strings.Contains(env, "ZOT_SUBAGENT_TEST_VALUE=not-secret") {
83		t.Fatal("worker environment dropped unrelated variables")	83		t.Fatal("worker environment dropped unrelated variables")
84		}	84		}
85			85

@@ -91,7 +91,7 @@ func TestWorkerEnvironmentRedactsProviderSecrets(t *testing.T) {
91		}	91		}
92			92
93		func TestExecRunnerTransfersCredentialOnlyOnStdin(t *testing.T) {	93		func TestExecRunnerTransfersCredentialOnlyOnStdin(t *testing.T) {
94	-	t.Setenv("ZOT_SWARM_CREDENTIAL_HELPER", "1")	94	+	t.Setenv("ZOT_SUBAGENT_CREDENTIAL_HELPER", "1")
95		root := t.TempDir()	95		root := t.TempDir()
96		a := &Agent{	96		a := &Agent{
97		ID: "credential-test",	97		ID: "credential-test",

@@ -138,8 +138,8 @@ func TestApplyEventPreservesMultilineRolesAndFinalAssistant(t *testing.T) {
138		}	138		}
139		}	139		}
140			140
141	-	func TestSwarmAgentArgs(t *testing.T) {	141	+	func TestSubagentWorkerArgs(t *testing.T) {
142	-	args := swarmAgentArgs(swarmAgentArgsOpts{	142	+	args := subagentWorkerArgs(subagentWorkerArgsOpts{
143		Exe: "/path/to/zot",	143		Exe: "/path/to/zot",
144		Dir: "/tmp/worktree",	144		Dir: "/tmp/worktree",
145		SessionPath: "/tmp/state/session.json",	145		SessionPath: "/tmp/state/session.json",

@@ -161,11 +161,11 @@ func TestSwarmAgentArgs(t *testing.T) {
161		}	161		}
162			162
163		mustHave := map[string]string{	163		mustHave := map[string]string{
164	-	"--swarm-agent": "/tmp/state/in.sock",	164	+	"--subagent-worker": "/tmp/state/in.sock",
165	-	"--session": "/tmp/state/session.json",	165	+	"--session": "/tmp/state/session.json",
166	-	"--cwd": "/tmp/worktree",	166	+	"--cwd": "/tmp/worktree",
167	-	"--reasoning": "high",	167	+	"--reasoning": "high",
168	-	"--subagent": "reviewer",	168	+	"--subagent": "reviewer",
169		}	169		}
170		for flag, value := range mustHave {	170		for flag, value := range mustHave {
171		i := indexOf(args, flag)	171		i := indexOf(args, flag)

@@ -187,8 +187,8 @@ func TestSwarmAgentArgs(t *testing.T) {
187		}	187		}
188		}	188		}
189			189
190	-	func TestSwarmAgentArgsPropagatesProviderConnectionSettings(t *testing.T) {	190	+	func TestSubagentWorkerArgsPropagatesProviderConnectionSettings(t *testing.T) {
191	-	args := swarmAgentArgs(swarmAgentArgsOpts{	191	+	args := subagentWorkerArgs(subagentWorkerArgsOpts{
192		Exe: "/zot",	192		Exe: "/zot",
193		Dir: "/work",	193		Dir: "/work",
194		SessionPath: "/state/session.json",	194		SessionPath: "/state/session.json",

@@ -224,11 +224,11 @@ func TestDefaultChildArgsPropagatesProviderConnectionSettings(t *testing.T) {
224		}	224		}
225		}	225		}
226			226
227	-	// TestSwarmAgentArgsEmptyTaskOmitsPositional makes sure that when the	227	+	// TestSubagentWorkerArgsEmptyTaskOmitsPositional makes sure that when the
228		// agent is being adopted (no fresh task) we don't pass an empty	228		// agent is being adopted (no fresh task) we don't pass an empty
229		// positional which the arg parser would treat as a real prompt.	229		// positional which the arg parser would treat as a real prompt.
230	-	func TestSwarmAgentArgsEmptyTaskOmitsPositional(t *testing.T) {	230	+	func TestSubagentWorkerArgsEmptyTaskOmitsPositional(t *testing.T) {
231	-	args := swarmAgentArgs(swarmAgentArgsOpts{	231	+	args := subagentWorkerArgs(subagentWorkerArgsOpts{
232		Exe: "/zot", Dir: "/wt", SessionPath: "/s.json", InboxPath: "/in.sock",	232		Exe: "/zot", Dir: "/wt", SessionPath: "/s.json", InboxPath: "/in.sock",
233		})	233		})
234		for _, a := range args {	234		for _, a := range args {

R packages/agent/swarm/scheduler.go → packages/agent/subagents/scheduler.go +14 -14 renamed, 90% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

@@ -10,7 +10,7 @@ import (
10		"time"	10		"time"
11		)	11		)
12			12
13	-	func (f *Swarm) validateSpawnRequest(req SpawnRequest) error {	13	+	func (f *Supervisor) validateSpawnRequest(req SpawnRequest) error {
14		if err := f.validateSpawnOptions(req); err != nil {	14		if err := f.validateSpawnOptions(req); err != nil {
15		return err	15		return err
16		}	16		}

@@ -32,7 +32,7 @@ func (f *Swarm) validateSpawnRequest(req SpawnRequest) error {
32		return validateWorkspaceRoot(root, mode, allowedRoots)	32		return validateWorkspaceRoot(root, mode, allowedRoots)
33		}	33		}
34			34
35	-	func (f *Swarm) validateSpawnOptions(req SpawnRequest) error {	35	+	func (f *Supervisor) validateSpawnOptions(req SpawnRequest) error {
36		p := f.cfg.Policy	36		p := f.cfg.Policy
37		if req.MaxTurns < 0 \|\| req.MaxTurns > p.MaxTurns {	37		if req.MaxTurns < 0 \|\| req.MaxTurns > p.MaxTurns {
38		return fmt.Errorf("subagents: max_turns must be between 1 and %d", p.MaxTurns)	38		return fmt.Errorf("subagents: max_turns must be between 1 and %d", p.MaxTurns)

@@ -112,7 +112,7 @@ func containmentPath(path string) (string, error) {
112		return filepath.Clean(absolute), nil	112		return filepath.Clean(absolute), nil
113		}	113		}
114			114
115	-	func (f *Swarm) schedule() {	115	+	func (f *Supervisor) schedule() {
116		var starts []*Agent	116		var starts []*Agent
117		f.mu.Lock()	117		f.mu.Lock()
118		for len(f.queue) > 0 && f.active < f.cfg.Policy.MaxConcurrent {	118		for len(f.queue) > 0 && f.active < f.cfg.Policy.MaxConcurrent {

@@ -152,7 +152,7 @@ func (f *Swarm) schedule() {
152		}	152		}
153		}	153		}
154			154
155	-	func (f Swarm) startLifecycleMonitor(a Agent) {	155	+	func (f Supervisor) startLifecycleMonitor(a Agent) {
156		if a == nil \|\| f.cfg.Policy.IdleTimeout <= 0 {	156		if a == nil \|\| f.cfg.Policy.IdleTimeout <= 0 {
157		return	157		return
158		}	158		}

@@ -173,7 +173,7 @@ func (f Swarm) startLifecycleMonitor(a Agent) {
173		continue	173		continue
174		}	174		}
175		last := a.LastActivity()	175		last := a.LastActivity()
176	-	if a.protocolReady() && !last.IsZero() && heartbeatGrace > 0 && time.Since(last) >= heartbeatGrace {	176	+	if !last.IsZero() && heartbeatGrace > 0 && time.Since(last) >= heartbeatGrace {
177		if err := f.Ping(a.ID); err != nil {	177		if err := f.Ping(a.ID); err != nil {
178		a.setProcessState(ProcessDetached)	178		a.setProcessState(ProcessDetached)
179		a.setActivity("detached")	179		a.setActivity("detached")

@@ -192,7 +192,7 @@ func (f Swarm) startLifecycleMonitor(a Agent) {
192			192
193		// Ping asks a live worker for a heartbeat. A detached or terminal worker	193		// Ping asks a live worker for a heartbeat. A detached or terminal worker
194		// returns the same not-ready error as other inbox operations.	194		// returns the same not-ready error as other inbox operations.
195	-	func (f *Swarm) Ping(id string) error {	195	+	func (f *Supervisor) Ping(id string) error {
196		a := f.Get(id)	196		a := f.Get(id)
197		if a == nil {	197		if a == nil {
198		return fmt.Errorf("subagents: no such agent %q", id)	198		return fmt.Errorf("subagents: no such agent %q", id)

@@ -203,7 +203,7 @@ func (f *Swarm) Ping(id string) error {
203		return a.inbox.SendCommand(NewCommand(CommandAgentPing, a.ID, a.CurrentTurnID(), AgentPingPayload{}))	203		return a.inbox.SendCommand(NewCommand(CommandAgentPing, a.ID, a.CurrentTurnID(), AgentPingPayload{}))
204		}	204		}
205			205
206	-	func (f *Swarm) nextRunnableIndexLocked() int {	206	+	func (f *Supervisor) nextRunnableIndexLocked() int {
207		if f.active >= f.cfg.Policy.MaxConcurrent {	207		if f.active >= f.cfg.Policy.MaxConcurrent {
208		return -1	208		return -1
209		}	209		}

@@ -237,7 +237,7 @@ func parentKey(a *Agent) string {
237		return a.ParentID	237		return a.ParentID
238		}	238		}
239			239
240	-	func (f Swarm) armQueueTimeout(a Agent) {	240	+	func (f Supervisor) armQueueTimeout(a Agent) {
241		if a == nil {	241		if a == nil {
242		return	242		return
243		}	243		}

@@ -250,9 +250,9 @@ func (f Swarm) armQueueTimeout(a Agent) {
250		}()	250		}()
251		}	251		}
252			252
253	-	func (f *Swarm) expireQueued(id string) { f.cancelQueued(id, context.DeadlineExceeded) }	253	+	func (f *Supervisor) expireQueued(id string) { f.cancelQueued(id, context.DeadlineExceeded) }
254			254
255	-	func (f Swarm) removeQueued(a Agent) {	255	+	func (f Supervisor) removeQueued(a Agent) {
256		if a == nil {	256		if a == nil {
257		return	257		return
258		}	258		}

@@ -266,7 +266,7 @@ func (f Swarm) removeQueued(a Agent) {
266		f.mu.Unlock()	266		f.mu.Unlock()
267		}	267		}
268			268
269	-	func (f *Swarm) cancelQueued(id string, cause error) {	269	+	func (f *Supervisor) cancelQueued(id string, cause error) {
270		a := f.Get(id)	270		a := f.Get(id)
271		if a == nil {	271		if a == nil {
272		return	272		return

@@ -320,7 +320,7 @@ func (f *Swarm) cancelQueued(id string, cause error) {
320		f.schedule()	320		f.schedule()
321		}	321		}
322			322
323	-	func (f Swarm) releaseCapacity(a Agent) {	323	+	func (f Supervisor) releaseCapacity(a Agent) {
324		f.mu.Lock()	324		f.mu.Lock()
325		if f.active > 0 {	325		if f.active > 0 {
326		f.active--	326		f.active--

@@ -336,7 +336,7 @@ func (f Swarm) releaseCapacity(a Agent) {
336		f.schedule()	336		f.schedule()
337		}	337		}
338			338
339	-	func (f Swarm) persistAgent(a Agent) {	339	+	func (f Supervisor) persistAgent(a Agent) {
340		if a == nil {	340		if a == nil {
341		return	341		return
342		}	342		}

R packages/agent/swarm/scheduler_test.go → packages/agent/subagents/scheduler_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

R packages/agent/swarm/socketpath.go → packages/agent/subagents/socketpath.go +5 -5 renamed, 91% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"crypto/sha1"	4		"crypto/sha1"

@@ -18,7 +18,7 @@ import (
18		const maxUnixSocketPath = 100	18		const maxUnixSocketPath = 100
19			19
20		// inboxSocketPath returns a per-agent unix-socket path in a transient	20		// inboxSocketPath returns a per-agent unix-socket path in a transient
21	-	// runtime directory. Durable swarm state can live on filesystems such as	21	+	// runtime directory. Durable subagent state can live on filesystems such as
22		// NFS, 9p, or shared VM mounts that support regular files but reject unix	22		// NFS, 9p, or shared VM mounts that support regular files but reject unix
23		// socket nodes, so the socket must not be placed below root.	23		// socket nodes, so the socket must not be placed below root.
24		//	24		//

@@ -33,7 +33,7 @@ const maxUnixSocketPath = 100
33		// stable path across parent and child processes and across Resume calls.	33		// stable path across parent and child processes and across Resume calls.
34		func inboxSocketPath(root, agentID string) (string, error) {	34		func inboxSocketPath(root, agentID string) (string, error) {
35		if runtime.GOOS == "windows" {	35		if runtime.GOOS == "windows" {
36	-	// Keep swarm construction usable for callers with custom runners.	36	+	// Keep subagent construction usable for callers with custom runners.
37		// The production listener still reports that its unix transport is	37		// The production listener still reports that its unix transport is
38		// unavailable, as it did before runtime-directory probing was added.	38		// unavailable, as it did before runtime-directory probing was added.
39		return filepath.Join(root, "agents", agentID, "in.sock"), nil	39		return filepath.Join(root, "agents", agentID, "in.sock"), nil

@@ -65,7 +65,7 @@ func inboxSocketPath(root, agentID string) (string, error) {
65		}	65		}
66			66
67		func socketPathInBase(base, root, agentID string) (string, error) {	67		func socketPathInBase(base, root, agentID string) (string, error) {
68	-	dir := filepath.Join(base, "zot-swarm-"+rootTag(root))	68	+	dir := filepath.Join(base, "zot-subagents-"+rootTag(root))
69		if err := os.MkdirAll(dir, 0o700); err != nil {	69		if err := os.MkdirAll(dir, 0o700); err != nil {
70		return "", fmt.Errorf("socket dir %s: %w", dir, err)	70		return "", fmt.Errorf("socket dir %s: %w", dir, err)
71		}	71		}

@@ -109,7 +109,7 @@ func probeUnixSocket(dir string) error {
109		return errors.Join(closeErr, removeErr)	109		return errors.Join(closeErr, removeErr)
110		}	110		}
111			111
112	-	// rootTag returns a stable 8-hex-char tag for the swarm root. Used	112	+	// rootTag returns a stable 8-hex-char tag for the subagent root. Used
113		// in the runtime-directory name so two parallel zot instances with	113		// in the runtime-directory name so two parallel zot instances with
114		// different roots don't share sockets.	114		// different roots don't share sockets.
115		func rootTag(root string) string { return shortHash(root) }	115		func rootTag(root string) string { return shortHash(root) }

R packages/agent/swarm/socketpath_test.go → packages/agent/subagents/socketpath_test.go +4 -4 renamed, 89% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"os"	4		"os"

@@ -10,7 +10,7 @@ import (
10			10
11		func TestInboxSocketPathUsesRuntimeDirectory(t *testing.T) {	11		func TestInboxSocketPathUsesRuntimeDirectory(t *testing.T) {
12		if runtime.GOOS == "windows" {	12		if runtime.GOOS == "windows" {
13	-	t.Skip("swarm inbox transport uses Unix-domain sockets")	13	+	t.Skip("subagent inbox transport uses Unix-domain sockets")
14		}	14		}
15			15
16		runtimeDir := shortSocketDir(t)	16		runtimeDir := shortSocketDir(t)

@@ -31,7 +31,7 @@ func TestInboxSocketPathUsesRuntimeDirectory(t *testing.T) {
31			31
32		func TestInboxSocketPathFallsBackFromUnusableRuntimeDirectory(t *testing.T) {	32		func TestInboxSocketPathFallsBackFromUnusableRuntimeDirectory(t *testing.T) {
33		if runtime.GOOS == "windows" {	33		if runtime.GOOS == "windows" {
34	-	t.Skip("swarm inbox transport uses Unix-domain sockets")	34	+	t.Skip("subagent inbox transport uses Unix-domain sockets")
35		}	35		}
36			36
37		badRuntime := filepath.Join(shortSocketDir(t), "not-a-directory")	37		badRuntime := filepath.Join(shortSocketDir(t), "not-a-directory")

@@ -53,7 +53,7 @@ func TestInboxSocketPathFallsBackFromUnusableRuntimeDirectory(t *testing.T) {
53			53
54		func TestInboxSocketPathShortensLongAgentID(t *testing.T) {	54		func TestInboxSocketPathShortensLongAgentID(t *testing.T) {
55		if runtime.GOOS == "windows" {	55		if runtime.GOOS == "windows" {
56	-	t.Skip("swarm inbox transport uses Unix-domain sockets")	56	+	t.Skip("subagent inbox transport uses Unix-domain sockets")
57		}	57		}
58			58
59		t.Setenv("XDG_RUNTIME_DIR", shortSocketDir(t))	59		t.Setenv("XDG_RUNTIME_DIR", shortSocketDir(t))

R packages/agent/swarm/swarm.go → packages/agent/subagents/supervisor.go +47 -90 renamed, 89% similar

-// Package swarm implements zot's subagent supervisor.
+// Package subagents implements zot's subagent supervisor.
 //
-// A Swarm manages headless, long-lived zot subprocesses and keeps their
+// A Supervisor manages headless, long-lived zot subprocesses and keeps their
 // process/turn state, event logs, sessions, results, and optional worktree
-// artifacts durable across supervisor restarts. The canonical user-facing
+// artifacts durable across supervisor restarts.
-// name is "subagents"; this package and the /swarm command remain for
-// compatibility with existing callers.
 //
 // Shared workspaces preserve the historical behavior, while an explicit
 // worktree request gives a child an isolated checkout whose patch is captured
 // before cleanup. The Runner abstraction lets tests inject a fake process;
-// production uses `zot --subagent-worker ...` with the legacy flag accepted as
+// production uses `zot --subagent-worker ...`.
-// a compatibility alias.
+package subagents
-package swarm
 import (
 	"context"
 	StatusDetached Status = "detached" // reloaded from disk; no live runner
 )
-// Config configures a Swarm.
+// Config configures a Supervisor.
 type Config struct {
 	// Context is the supervisor lifetime. Child workers use it as their
 	// parent context rather than inheriting an individual tool/model-turn
 	Context context.Context
 	// Root is the directory under which per-agent state files live.
-	// Typically <ZotHome>/swarm, but tests pass a tempdir.
+	// Typically <ZotHome>/subagents, but tests pass a tempdir.
 	Root string
-	// LegacyRoots are older state roots that Reload also reads. New
-	// agents are always written below Root; this keeps the swarm ->
-	// subagents rename from making existing sessions disappear.
-	LegacyRoots []string
 	// Policy owns concurrency, timeout, output, and path safety limits.
 	Policy SubagentPolicy
 	InsecureTLS bool
 	// NewRunner produces the Runner for an Agent. If nil, the default
-	// `zot --swarm-agent ...` exec runner is used. Tests inject a fake
+	// `zot --subagent-worker ...` exec runner is used. Tests inject a fake
 	// here.
 	NewRunner func(a *Agent) Runner
 	Now func() time.Time
 }
-// Credential is the resolved authentication state inherited by a swarm child.
+// Credential is the resolved authentication state inherited by a subagent child.
 type Credential struct {
 	Value     string `json:"value"`
 	Method    string `json:"method"`
 //
 // Run should report progress by writing short human-readable strings
 // to the activity channel and final transcript text to transcript.
-// Both channels are non-blocking sinks owned by the Swarm; if the
+// Both channels are non-blocking sinks owned by the Supervisor; if the
 // dashboard isn't reading, sends are dropped.
 type Runner interface {
 	Run(ctx context.Context, sink Sink) error
 	Transcript(chunk string)
 }
-// Swarm supervises a set of Agents.
+// Supervisor supervises a set of Agents.
-type Swarm struct {
+type Supervisor struct {
 	cfg Config
 	mu             sync.Mutex
 	// activeSession is the host session id the dashboard is
 	// currently scoped to. When non-empty, SnapshotAll filters out
-	// agents whose SessionID doesn't match (legacy / unscoped
+	// agents whose SessionID doesn't match (unscoped
 	// agents with SessionID == "" are always shown). Spawn stamps
 	// new agents with this value so they appear only in the session
 	// that created them. When empty (the default), the historical
 	// "show everything" behaviour is preserved — important for
-	// tests and any scripted use of the Swarm that doesn't bother
+	// tests and any scripted use of the Supervisor that doesn't bother
 	// with sessions.
 	activeSession string
 }
-// New constructs a Swarm from cfg. Missing config fields are filled
+// New constructs a Supervisor from cfg. Missing config fields are filled
 // with defaults.
-func New(cfg Config) *Swarm {
+func New(cfg Config) *Supervisor {
 	if cfg.Now == nil {
 		cfg.Now = time.Now
 	}
 		lifetimeParent = context.Background()
 	}
 	lifetimeCtx, lifetimeCancel := context.WithCancel(lifetimeParent)
-	return &Swarm{
+	return &Supervisor{
 		cfg:            cfg,
 		lifetimeCtx:    lifetimeCtx,
 		lifetimeCancel: lifetimeCancel,
 // SetRepoRoot updates the shared working directory for subsequently
 // spawned agents. Existing agents keep the directory they were started
 // with; callers use this when the host session changes cwd.
-func (f *Swarm) workerContext(timeout time.Duration) (context.Context, context.CancelFunc) {
+func (f *Supervisor) workerContext(timeout time.Duration) (context.Context, context.CancelFunc) {
 	base := f.lifetimeCtx
 	if base == nil {
 		base = context.Background()
 	return context.WithCancel(base)
 }
-func (f *Swarm) SetRepoRoot(root string) {
+func (f *Supervisor) SetRepoRoot(root string) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.cfg.RepoRoot = root
 // RepoRoot returns the working directory used by subsequently spawned
 // agents.
-func (f *Swarm) RepoRoot() string {
+func (f *Supervisor) RepoRoot() string {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	return f.cfg.RepoRoot
 // SetFastMode updates the fast-mode setting for subsequently spawned
 // children. Existing agents keep the setting captured at their spawn
 // boundary so resumes remain deterministic.
-func (f *Swarm) SetFastMode(enabled bool) {
+func (f *Supervisor) SetFastMode(enabled bool) {
 	f.mu.Lock()
 	f.cfg.FastMode = enabled
 	f.mu.Unlock()
 }
 // FastMode reports the setting used for subsequently spawned children.
-func (f *Swarm) FastMode() bool {
+func (f *Supervisor) FastMode() bool {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	return f.cfg.FastMode
 // subsequently spawned children. Existing agents keep their persisted values
 // so a model/provider switch cannot silently change a running or resumed
 // worker's endpoint.
-func (f *Swarm) SetProvider(provider string) {
+func (f *Supervisor) SetProvider(provider string) {
 	f.mu.Lock()
 	f.cfg.Provider = strings.TrimSpace(provider)
 	f.mu.Unlock()
 }
-func (f *Swarm) SetProviderSettings(baseURL string, insecureTLS bool) {
+func (f *Supervisor) SetProviderSettings(baseURL string, insecureTLS bool) {
 	f.mu.Lock()
 	f.cfg.BaseURL = strings.TrimSpace(baseURL)
 	f.cfg.InsecureTLS = insecureTLS
 // ProviderSettings returns the settings used by subsequently spawned
 // children. It is primarily useful to host integrations that need to verify
 // the manager follows the active provider selection.
-func (f *Swarm) ProviderSettings() (string, bool) {
+func (f *Supervisor) ProviderSettings() (string, bool) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	return f.cfg.BaseURL, f.cfg.InsecureTLS
 // applied at snapshot time changes. So swapping the active session
 // with /sessions instantly re-narrows the dashboard without
 // touching any agent state.
-func (f *Swarm) SetActiveSession(id string) {
+func (f *Supervisor) SetActiveSession(id string) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.activeSession = id
 // ActiveSession returns the current scope, mostly for tests and
 // diagnostics. Empty means "no scope; show everything".
-func (f *Swarm) ActiveSession() string {
+func (f *Supervisor) ActiveSession() string {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	return f.activeSession
 //
 // The transient unix socket inbox lives in a probed runtime directory,
 // which may be on a different filesystem from this durable state.
-func (f *Swarm) agentStateDir(id string) string {
+func (f *Supervisor) agentStateDir(id string) string {
 	return filepath.Join(f.cfg.Root, "agents", id)
 }
-func (f *Swarm) uniqueAgentIDLocked(base string) string {
+func (f *Supervisor) uniqueAgentIDLocked(base string) string {
 	id := base
 	for suffix := 2; ; suffix++ {
 		_, inMemory := f.agents[id]
 // when the concurrency budget is full and transitions to running when a slot
 // opens. This is the historical signature; callers that want to override the
 // child's model or workspace use SpawnReq instead.
-func (f *Swarm) Spawn(ctx context.Context, task string) (*Agent, error) {
+func (f *Supervisor) Spawn(ctx context.Context, task string) (*Agent, error) {
 	return f.SpawnReq(ctx, SpawnRequest{Task: task})
 }
 // SpawnReq is the full-fat variant of Spawn that accepts a SpawnRequest.
 // Existing callers can keep using Spawn; new code that wants to pin the
 // child's model, policy, or workspace uses this.
-func (f *Swarm) SpawnReq(ctx context.Context, req SpawnRequest) (*Agent, error) {
+func (f *Supervisor) SpawnReq(ctx context.Context, req SpawnRequest) (*Agent, error) {
 	task := strings.TrimSpace(req.Task)
 	if task == "" {
 		return nil, errors.New("subagents: empty task")
 	return a, nil
 }
-// SendInput delivers msg to the agent's inbox. msg should already
-// include the leading kind ("user " + text, "cancel", "shutdown").
-// Returns an error wrapping ErrNotReady if the child hasn't opened
-// its listener yet; the caller can retry or surface the wait.
-func (f *Swarm) SendInput(id, msg string) error {
-	a := f.Get(id)
-	if a == nil {
-		return fmt.Errorf("no such agent %q", id)
-	}
-	if a.inbox == nil {
-		return fmt.Errorf("agent %s has no inbox", a.ID)
-	}
-	return a.inbox.SendInput(msg)
-}
 // SendUserTurn is sugar for the common "send the next user turn"
 // case. It quotes nothing and forwards verbatim; callers are
 // expected to have already trimmed and expanded the text.
 // CancelTurn requests cancellation of the current turn while keeping the
 // worker process alive for a later follow-up.
-func (f *Swarm) CancelTurn(id string) error {
+func (f *Supervisor) CancelTurn(id string) error {
 	a := f.Get(id)
 	if a == nil {
 		return fmt.Errorf("subagents: no such agent %q", id)
 		return fmt.Errorf("subagents: agent %s has no inbox", a.ID)
 	}
 	a.setTurnState(TurnCanceling, a.CurrentTurnID())
-	if !a.protocolReady() {
-		return a.inbox.SendInput("cancel")
-	}
 	return a.inbox.SendCommand(NewCommand(CommandTurnCancel, a.ID, a.CurrentTurnID(), TurnCancelPayload{Reason: "user"}))
 }
-func (f *Swarm) SendUserTurn(id, text string) error {
+func (f *Supervisor) SendUserTurn(id, text string) error {
 	a := f.Get(id)
 	if a == nil {
 		return fmt.Errorf("subagents: no such agent %q", id)
 	if a.inbox == nil {
 		return fmt.Errorf("subagents: agent %s has no inbox", a.ID)
 	}
-	if !a.protocolReady() {
-		// Until agent.ready arrives, use the legacy spelling so a prompt
-		// sent immediately after Spawn is not lost during compatibility
-		// negotiation. The worker accepts both forms.
-		return a.inbox.SendInput("user " + text)
-	}
 	return a.inbox.SendCommand(NewCommand(CommandTurnStart, a.ID, a.CurrentTurnID(), TurnStartPayload{Prompt: text}))
 }
-func (f *Swarm) run(a *Agent) {
+func (f *Supervisor) run(a *Agent) {
 	a.mu.Lock()
 	killedBeforeStart := a.status == StatusKilled
 	ctxErr := error(nil)
 // List returns a snapshot of every agent in creation order. The
 // returned slice is a copy; callers may iterate without holding the
-// swarm lock. Agent fields are read under their own mutex during
+// subagent lock. Agent fields are read under their own mutex during
 // formatting in Snapshot.
-func (f *Swarm) List() []*Agent {
+func (f *Supervisor) List() []*Agent {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	out := make([]*Agent, 0, len(f.order))
 // Get returns the agent with the given (possibly truncated) id, or
 // nil. Matching is prefix-based so the user can type the first few
 // characters of a long id.
-func (f *Swarm) Get(id string) *Agent {
+func (f *Supervisor) Get(id string) *Agent {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	if a, ok := f.agents[id]; ok {
 // Stop cancels the agent's context. The Runner should observe the
 // cancellation and return promptly; the goroutine then finalises the
 // agent in StatusKilled. Also closes the supervisor-side inbox handle
-// so any pending SendInput retries fail fast instead of dialing a
+// so any pending send retries fail fast instead of dialing a
 // socket about to be unlinked.
 //
 // Stop is a no-op for any agent that's not in a live runnable state
 // are probed first: if their worker survived the supervisor, Stop sends the
 // shutdown command through the durable inbox instead of pretending no
 // process exists.
-func (f *Swarm) Stop(id string) error {
+func (f *Supervisor) Stop(id string) error {
 	f.operationMu.Lock()
 	defer f.operationMu.Unlock()
 	a := f.Get(id)
 		path := a.InboxPath
 		inbox := a.inbox
 		pid := a.ProcessPIDValue()
-		protocolReady := a.protocolReady()
 		a.mu.Unlock()
 		f.mu.Unlock()
 		if inbox == nil || !inboxLive(path) {
 			return nil
 		}
-		var err error
+		err := inbox.SendCommand(NewCommand(CommandAgentShutdown, a.ID, a.CurrentTurnID(), AgentShutdownPayload{}))
-		if protocolReady {
-			err = inbox.SendCommand(NewCommand(CommandAgentShutdown, a.ID, a.CurrentTurnID(), AgentShutdownPayload{}))
-		} else {
-			err = inbox.SendInput("shutdown")
-		}
 		if err != nil {
 			return err
 		}
 	// safer than leaving a supervisor entry running forever.
 	graceful := false
 	if a.inbox != nil {
-		var err error
+		err := a.inbox.SendCommand(NewCommand(CommandAgentShutdown, a.ID, a.CurrentTurnID(), AgentShutdownPayload{}))
-		if a.protocolReady() {
-			err = a.inbox.SendCommand(NewCommand(CommandAgentShutdown, a.ID, a.CurrentTurnID(), AgentShutdownPayload{}))
-		} else {
-			err = a.inbox.SendInput("shutdown")
-		}
 		if err == nil {
 			graceful = true
 		}
 }
 // StopAll cancels every running agent. Used on shutdown.
-func (f *Swarm) StopAll() {
+func (f *Supervisor) StopAll() {
 	agents := f.List()
 	for _, a := range agents {
 		_ = f.Stop(a.ID)
 // agents have already captured their output and removed the isolated checkout
 // during finalization. Remove then deletes the agent's durable state directory
 // under <root>/agents/<id>/.
-func (f *Swarm) Remove(id string) error {
+func (f *Supervisor) Remove(id string) error {
 	f.operationMu.Lock()
 	defer f.operationMu.Unlock()
 	a := f.Get(id)
 	WorkspacePath string
 	// Paths to the agent's durable state. Surface them in the
-	// snapshot so the dashboard /subagents (or compatibility /swarm) view can
+	// snapshot so the dashboard /subagents view can
 	// read events.jsonl or resume the session without going back through the Agent.
 	InboxPath    string
 	EventLogPath string
 //   - activeSession == "": no filter, every agent is returned
 //     (historical behaviour; used by tests and scripted callers).
 //   - activeSession != "": include live agents whose SessionID matches
-//     activeSession, plus unscoped legacy agents. Detached and terminal
+//     activeSession, plus unscoped agents. Detached and terminal
 //     agents from another host session remain visible so restart/recovery
 //     does not hide durable work.
-func (f *Swarm) SnapshotAll() []AgentSnapshot {
+func (f *Supervisor) SnapshotAll() []AgentSnapshot {
 	agents := f.List()
 	f.mu.Lock()
 	active := f.activeSession
 	return out
 }
-// agentSink is the Sink the Swarm hands to each Runner.
+// agentSink is the Sink the Supervisor hands to each Runner.
 type agentSink struct{ a *Agent }
 func (s agentSink) Activity(msg string) { s.a.setActivity(msg) }

R packages/agent/swarm/swarm_test.go → packages/agent/subagents/supervisor_test.go +15 -15 renamed, 88% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

@@ -9,11 +9,11 @@ import (
9		"time"	9		"time"
10		)	10		)
11			11
12	-	// newTestSwarm builds a Swarm rooted in t.TempDir with the in-memory	12	+	// newTestSupervisor builds a Supervisor rooted in t.TempDir with the in-memory
13	-	// and a Runner factory the test controls. Returns the swarm plus a	13	+	// and a Runner factory the test controls. Returns the subagent plus a
14		// slice of runners keyed by spawn order so tests can assert they	14		// slice of runners keyed by spawn order so tests can assert they
15		// were actually invoked.	15		// were actually invoked.
16	-	func newTestSwarm(t testing.T, mk func(a Agent) Runner) *Swarm {	16	+	func newTestSupervisor(t testing.T, mk func(a Agent) Runner) *Supervisor {
17		t.Helper()	17		t.Helper()
18		root := t.TempDir()	18		root := t.TempDir()
19		return New(Config{	19		return New(Config{

@@ -25,7 +25,7 @@ func newTestSwarm(t testing.T, mk func(a Agent) Runner) *Swarm {
25			25
26		func TestSpawnRunsAndCompletes(t *testing.T) {	26		func TestSpawnRunsAndCompletes(t *testing.T) {
27		ran := make(chan string, 1)	27		ran := make(chan string, 1)
28	-	f := newTestSwarm(t, func(a *Agent) Runner {	28	+	f := newTestSupervisor(t, func(a *Agent) Runner {
29		return RunnerFunc(func(ctx context.Context, sink Sink) error {	29		return RunnerFunc(func(ctx context.Context, sink Sink) error {
30		ran <- a.Task	30		ran <- a.Task
31		sink.Activity("hello")	31		sink.Activity("hello")

@@ -65,7 +65,7 @@ func TestSpawnRunsAndCompletes(t *testing.T) {
65		// TestSpawnAgentSharesRepoRoot verifies the only-mode-we-support:	65		// TestSpawnAgentSharesRepoRoot verifies the only-mode-we-support:
66		// every spawned agent points its cwd at the parent zot's RepoRoot.	66		// every spawned agent points its cwd at the parent zot's RepoRoot.
67		func TestSpawnAgentSharesRepoRoot(t *testing.T) {	67		func TestSpawnAgentSharesRepoRoot(t *testing.T) {
68	-	f := newTestSwarm(t, func(a *Agent) Runner {	68	+	f := newTestSupervisor(t, func(a *Agent) Runner {
69		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })	69		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })
70		})	70		})
71		a, err := f.Spawn(context.Background(), "share me")	71		a, err := f.Spawn(context.Background(), "share me")

@@ -79,7 +79,7 @@ func TestSpawnAgentSharesRepoRoot(t *testing.T) {
79		}	79		}
80			80
81		func TestSetRepoRootAffectsSubsequentSpawns(t *testing.T) {	81		func TestSetRepoRootAffectsSubsequentSpawns(t *testing.T) {
82	-	f := newTestSwarm(t, func(a *Agent) Runner {	82	+	f := newTestSupervisor(t, func(a *Agent) Runner {
83		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })	83		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })
84		})	84		})
85		want := t.TempDir()	85		want := t.TempDir()

@@ -95,7 +95,7 @@ func TestSetRepoRootAffectsSubsequentSpawns(t *testing.T) {
95		}	95		}
96			96
97		func TestSpawnEmptyTaskFails(t *testing.T) {	97		func TestSpawnEmptyTaskFails(t *testing.T) {
98	-	f := newTestSwarm(t, func(a *Agent) Runner {	98	+	f := newTestSupervisor(t, func(a *Agent) Runner {
99		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })	99		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })
100		})	100		})
101		if _, err := f.Spawn(context.Background(), " "); err == nil {	101		if _, err := f.Spawn(context.Background(), " "); err == nil {

@@ -105,7 +105,7 @@ func TestSpawnEmptyTaskFails(t *testing.T) {
105			105
106		func TestRunnerErrorMarksFailed(t *testing.T) {	106		func TestRunnerErrorMarksFailed(t *testing.T) {
107		wantErr := errors.New("boom")	107		wantErr := errors.New("boom")
108	-	f := newTestSwarm(t, func(a *Agent) Runner {	108	+	f := newTestSupervisor(t, func(a *Agent) Runner {
109		return RunnerFunc(func(ctx context.Context, sink Sink) error { return wantErr })	109		return RunnerFunc(func(ctx context.Context, sink Sink) error { return wantErr })
110		})	110		})
111		a, _ := f.Spawn(context.Background(), "explode")	111		a, _ := f.Spawn(context.Background(), "explode")

@@ -123,7 +123,7 @@ func TestRunnerErrorMarksFailed(t *testing.T) {
123			123
124		func TestStopCancelsRunningAgent(t *testing.T) {	124		func TestStopCancelsRunningAgent(t *testing.T) {
125		started := make(chan struct{})	125		started := make(chan struct{})
126	-	f := newTestSwarm(t, func(a *Agent) Runner {	126	+	f := newTestSupervisor(t, func(a *Agent) Runner {
127		return RunnerFunc(func(ctx context.Context, sink Sink) error {	127		return RunnerFunc(func(ctx context.Context, sink Sink) error {
128		close(started)	128		close(started)
129		<-ctx.Done()	129		<-ctx.Done()

@@ -142,7 +142,7 @@ func TestStopCancelsRunningAgent(t *testing.T) {
142		}	142		}
143			143
144		func TestStopAfterDoneIsNoop(t *testing.T) {	144		func TestStopAfterDoneIsNoop(t *testing.T) {
145	-	f := newTestSwarm(t, func(a *Agent) Runner {	145	+	f := newTestSupervisor(t, func(a *Agent) Runner {
146		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })	146		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })
147		})	147		})
148		a, _ := f.Spawn(context.Background(), "quick")	148		a, _ := f.Spawn(context.Background(), "quick")

@@ -156,7 +156,7 @@ func TestStopAfterDoneIsNoop(t *testing.T) {
156		}	156		}
157			157
158		func TestGetPrefixMatch(t *testing.T) {	158		func TestGetPrefixMatch(t *testing.T) {
159	-	f := newTestSwarm(t, func(a *Agent) Runner {	159	+	f := newTestSupervisor(t, func(a *Agent) Runner {
160		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })	160		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })
161		})	161		})
162		a, _ := f.Spawn(context.Background(), "alpha task")	162		a, _ := f.Spawn(context.Background(), "alpha task")

@@ -177,7 +177,7 @@ func TestGetPrefixMatch(t *testing.T) {
177			177
178		func TestRemoveRequiresTerminalState(t *testing.T) {	178		func TestRemoveRequiresTerminalState(t *testing.T) {
179		hold := make(chan struct{})	179		hold := make(chan struct{})
180	-	f := newTestSwarm(t, func(a *Agent) Runner {	180	+	f := newTestSupervisor(t, func(a *Agent) Runner {
181		return RunnerFunc(func(ctx context.Context, sink Sink) error {	181		return RunnerFunc(func(ctx context.Context, sink Sink) error {
182		<-hold	182		<-hold
183		return nil	183		return nil

@@ -204,7 +204,7 @@ func TestRemoveRequiresTerminalState(t *testing.T) {
204		func TestSnapshotIsStableAcrossAccess(t *testing.T) {	204		func TestSnapshotIsStableAcrossAccess(t *testing.T) {
205		var wg sync.WaitGroup	205		var wg sync.WaitGroup
206		wg.Add(1)	206		wg.Add(1)
207	-	f := newTestSwarm(t, func(a *Agent) Runner {	207	+	f := newTestSupervisor(t, func(a *Agent) Runner {
208		return RunnerFunc(func(ctx context.Context, sink Sink) error {	208		return RunnerFunc(func(ctx context.Context, sink Sink) error {
209		defer wg.Done()	209		defer wg.Done()
210		for i := 0; i < 200; i++ {	210		for i := 0; i < 200; i++ {

@@ -251,7 +251,7 @@ func TestTaskSlug(t *testing.T) {
251		}	251		}
252			252
253		func TestSnapshotAllSorted(t *testing.T) {	253		func TestSnapshotAllSorted(t *testing.T) {
254	-	f := newTestSwarm(t, func(a *Agent) Runner {	254	+	f := newTestSupervisor(t, func(a *Agent) Runner {
255		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })	255		return RunnerFunc(func(ctx context.Context, sink Sink) error { return nil })
256		})	256		})
257		a1, _ := f.Spawn(context.Background(), "first")	257		a1, _ := f.Spawn(context.Background(), "first")

R packages/agent/swarm/testdata/cmd/stubchild/main.go → packages/agent/subagents/testdata/cmd/stubchild/main.go +14 -25 renamed, 76% similar

-// stubchild is a minimal swarm-agent stand-in used by the runner
+// stubchild is a minimal subagent-worker stand-in used by the runner
 // end-to-end test. It speaks the daemon protocol the real zot
 // binary will implement next:
 //
-//   - parses --swarm-agent <path>, --session <path>, --cwd <path>,
+//   - parses --subagent-worker <path>, --session <path>, --cwd <path>,
 //     and an optional positional task,
 //   - opens a unix-socket listener at the inbox path so the
 //     supervisor's Inbox can dial through,
 //     so the runner sees the dialogue happen.
 //
 // The runner test compiles this binary into a tempdir, points
-// swarm's execRunner at it via Command, and asserts the events
+// subagent's execRunner at it via Command, and asserts the events
 // flow through correctly without needing the full zot model
 // machinery.
 package main
 	"sync"
 	"time"
-	"github.com/patriceckhart/zot/packages/agent/swarm"
+	"github.com/patriceckhart/zot/packages/agent/subagents"
 )
 func main() {
 		cwd         string
 	)
 	flag.StringVar(&inboxPath, "subagent-worker", "", "inbox socket path")
-	flag.StringVar(&inboxPath, "swarm-agent", "", "compatibility inbox socket path")
 	flag.StringVar(&sessionPath, "session", "", "session file path")
 	flag.StringVar(&cwd, "cwd", "", "working directory")
 	flag.Parse()
 	if inboxPath == "" {
-		fmt.Fprintln(os.Stderr, "stubchild: --swarm-agent required")
+		fmt.Fprintln(os.Stderr, "stubchild: --subagent-worker required")
 		os.Exit(2)
 	}
 	// Open the inbox listener BEFORE doing any work so the supervisor
 	// can dial through as soon as it sees the agent_ready event. If we
-	// processed the initial task first, the parent's SendInput call
+	// processed the initial task first, the parent's send call
 	// would race the stub's net.Listen and trip ErrNotReady.
 	ln, err := net.Listen("unix", inboxPath)
 	if err != nil {
 			line, err := br.ReadString('\n')
 			if line != "" {
 				msg := trimNL(line)
-				if command, parseErr := swarm.ParseCommand(msg); parseErr == nil {
+				command, parseErr := subagents.ParseCommand(msg)
+				if parseErr == nil {
 					switch command.Type {
-					case swarm.CommandAgentShutdown:
+					case subagents.CommandAgentShutdown:
 						emit("agent_stopped", map[string]any{"reason": "shutdown"})
 						_ = c.Close()
 						return
-					case swarm.CommandTurnCancel:
+					case subagents.CommandTurnCancel:
 						emit("turn_end", map[string]any{"stop": "cancelled"})
-					case swarm.CommandTurnStart:
+					case subagents.CommandTurnStart:
-						var payload swarm.TurnStartPayload
+						var payload subagents.TurnStartPayload
 						if command.DecodePayload(&payload) == nil {
 							runTurn(emit, payload.Prompt, turn)
 							turn++
 						}
 					}
-				} else {
-					switch {
-					case msg == "shutdown":
-						emit("agent_stopped", map[string]any{"reason": "shutdown"})
-						_ = c.Close()
-						return
-					case msg == "cancel":
-						emit("turn_end", map[string]any{"stop": "cancelled"})
-					case len(msg) > 5 && msg[:5] == "user ":
-						runTurn(emit, msg[5:], turn)
-						turn++
-					}
 				}
 			}
 			if err != nil {
 				_ = c.Close()
 				break
 			data = map[string]any{}
 		}
 		if versioned {
-			envelope := swarm.NewEventEnvelope(typ, "stub-agent", "", data)
+			envelope := subagents.NewEventEnvelope(typ, "stub-agent", "", data)
 			_ = enc.Encode(envelope)
 			return
 		}

R packages/agent/swarm/workspace.go → packages/agent/subagents/workspace.go +2 -2 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"bytes"	4		"bytes"

@@ -49,7 +49,7 @@ type WorkspaceHandle interface {
49		}	49		}
50			50
51		// SharedWorkspace leaves the host checkout untouched by the supervisor; a	51		// SharedWorkspace leaves the host checkout untouched by the supervisor; a
52	-	// child may edit it exactly as older swarm workers did.	52	+	// child may edit it exactly as older subagent workers did.
53		type SharedWorkspace struct {	53		type SharedWorkspace struct {
54		Root string	54		Root string
55		}	55		}

R packages/agent/swarm/workspace_manager_test.go → packages/agent/subagents/workspace_manager_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

R packages/agent/swarm/workspace_test.go → packages/agent/subagents/workspace_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package swarm	1	+	package subagents
2			2
3		import (	3		import (
4		"context"	4		"context"

D packages/agent/swarm/aliases.go +0 -11

@@ -1,11 +0,0 @@
1	-	package swarm
2	-
3	-	// Canonical domain names. The swarm package remains as a source-compatible
4	-	// implementation boundary while callers migrate to subagent terminology.
5	-	type SubagentManager = Swarm
6	-	type SubagentConfig = Config
7	-	type Subagent = Agent
8	-	type SubagentSnapshot = AgentSnapshot
9	-	type SubagentRequest = SpawnRequest
10	-
11	-	func NewSubagentManager(cfg SubagentConfig) *SubagentManager { return New(cfg) }

R packages/agent/tools/swarm_spawn.go → packages/agent/tools/subagent_spawn.go +28 -41 renamed, 82% similar


@@ -8,29 +8,24 @@ import (
8		"time"	8		"time"
9			9
10		"github.com/patriceckhart/zot/packages/agent/subagents"	10		"github.com/patriceckhart/zot/packages/agent/subagents"
11	-	"github.com/patriceckhart/zot/packages/agent/swarm"
12		"github.com/patriceckhart/zot/packages/core"	11		"github.com/patriceckhart/zot/packages/core"
13		"github.com/patriceckhart/zot/packages/provider"	12		"github.com/patriceckhart/zot/packages/provider"
14		)	13		)
15			14
16	-	// SwarmSpawnTool lets the main agent fork a background sub-agent	15	+	// SubagentSpawnTool lets the main agent fork a background sub-agent
17	-	// against the host's cwd via swarm.Swarm.SpawnReq. The sub-agent runs	16	+	// against the host's cwd via subagents.Supervisor.SpawnReq. The sub-agent runs
18		// in parallel: the tool returns the agent id immediately and the main	17		// in parallel: the tool returns the agent id immediately and the main
19		// turn continues uninterrupted. The user can monitor / chat with the	18		// turn continues uninterrupted. The user can monitor / chat with the
20	-	// spawned agent via /swarm.	19	+	// spawned agent via /subagents.
21		//	20		//
22	-	// Gated by the auto_swarm_enabled config flag at call time so a user	21	+	// Gated by the auto_subagents_enabled config flag at call time so a user
23		// can flip it off mid-session and the next call refuses cleanly	22		// can flip it off mid-session and the next call refuses cleanly
24		// without re-registering the tool.	23		// without re-registering the tool.
25	-	type SwarmSpawnTool struct {	24	+	type SubagentSpawnTool struct {
26	-	// ToolName selects the public spelling. Empty preserves the historical	25	+	// Supervisor is the supervisor used to spawn agents. Nil means
27	-	// swarm_spawn alias; the CLI registers the canonical subagent_spawn name.	26	+	// "auto-subagents not available in this mode" and the tool always
28	-	ToolName string
29	-
30	-	// Swarm is the supervisor used to spawn agents. Nil means
31	-	// "auto-swarm not available in this mode" and the tool always
32		// errors.	27		// errors.
33	-	Swarm *swarm.Swarm	28	+	Supervisor *subagents.Supervisor
34			29
35		// Enabled reads the live config flag. Lets users toggle from	30		// Enabled reads the live config flag. Lets users toggle from
36		// /settings without rebuilding the agent. When nil, the tool	31		// /settings without rebuilding the agent. When nil, the tool

@@ -39,7 +34,7 @@ type SwarmSpawnTool struct {
39			34
40		// DefaultModel and DefaultProvider return the host agent's resolved	35		// DefaultModel and DefaultProvider return the host agent's resolved
41		// model and provider. They are used when the tool call omits both	36		// model and provider. They are used when the tool call omits both
42	-	// fields and does not select a named profile, so auto-swarm follows	37	+	// fields and does not select a named profile, so auto-subagents follows
43		// the same auth route as the user sees in the parent session.	38		// the same auth route as the user sees in the parent session.
44		DefaultModel func() string	39		DefaultModel func() string
45		DefaultProvider func() string	40		DefaultProvider func() string

@@ -53,14 +48,10 @@ type SwarmSpawnTool struct {
53		// the new agent + the task it was started with. Used by the	48		// the new agent + the task it was started with. Used by the
54		// interactive host to track agents and surface a summary back	49		// interactive host to track agents and surface a summary back
55		// in chat when all sub-agents finish.	50		// in chat when all sub-agents finish.
56	-	OnSpawned func(agent *swarm.Agent, task string)	51	+	OnSpawned func(agent *subagents.Agent, task string)
57		}	52		}
58			53
59	-	// SubagentSpawnTool is the canonical spelling; SwarmSpawnTool remains an	54	+	type subagentSpawnArgs struct {
60	-	// alias for integrations that used the original API.
61	-	type SubagentSpawnTool = SwarmSpawnTool
62	-
63	-	type swarmSpawnArgs struct {
64		Task string `json:"task"`	55		Task string `json:"task"`
65		Agent string `json:"agent,omitempty"`	56		Agent string `json:"agent,omitempty"`
66		Model string `json:"model,omitempty"`	57		Model string `json:"model,omitempty"`

@@ -72,7 +63,7 @@ type swarmSpawnArgs struct {
72		MaxTurns int `json:"max_turns,omitempty"`	63		MaxTurns int `json:"max_turns,omitempty"`
73		}	64		}
74			65
75	-	const swarmSpawnSchema = `{	66	+	const subagentSpawnSchema = `{
76		"type": "object",	67		"type": "object",
77		"properties": {	68		"properties": {
78		"task": {	69		"task": {

@@ -104,7 +95,7 @@ const swarmSpawnSchema = `{
104		"isolation": {	95		"isolation": {
105		"type": "string",	96		"type": "string",
106		"enum": ["shared", "worktree"],	97		"enum": ["shared", "worktree"],
107	-	"description": "Workspace mode. Shared preserves legacy behavior; worktree captures a patch without merging it."	98	+	"description": "Workspace mode. Shared preserves existing behavior; worktree captures a patch without merging it."
108		},	99		},
109		"timeout": {	100		"timeout": {
110		"type": "string",	101		"type": "string",

@@ -119,26 +110,22 @@ const swarmSpawnSchema = `{
119		"required": ["task"]	110		"required": ["task"]
120		}`	111		}`
121			112
122	-	func (t *SwarmSpawnTool) Name() string {	113	+	func (t *SubagentSpawnTool) Name() string { return "subagent_spawn" }
123	-	if strings.TrimSpace(t.ToolName) != "" {	114	+	func (t *SubagentSpawnTool) Description() string {
124	-	return strings.TrimSpace(t.ToolName)	115	+	return "Spawn a background sub-agent to work on a parallel sub-task. Optionally select a named markdown profile, model/provider/reasoning, timeout, turn limit, and shared/worktree isolation, and fast-mode preference. Returns the sub-agent id immediately; completion arrives through the result/event path."
125	-	}	116	+
126	-	return "swarm_spawn"
127	-	}
128	-	func (t *SwarmSpawnTool) Description() string {
129	-	return "Spawn a background sub-agent to work on a parallel sub-task. Optionally select a named markdown profile, model/provider/reasoning, timeout, turn limit, shared/worktree isolation, and fast-mode preference. Returns the sub-agent id immediately; completion arrives through the result/event path."
130		}	117		}
131	-	func (t *SwarmSpawnTool) Schema() json.RawMessage { return json.RawMessage(swarmSpawnSchema) }	118	+	func (t *SubagentSpawnTool) Schema() json.RawMessage { return json.RawMessage(subagentSpawnSchema) }
132			119
133	-	func (t *SwarmSpawnTool) Execute(ctx context.Context, raw json.RawMessage, progress func(string)) (core.ToolResult, error) {	120	+	func (t *SubagentSpawnTool) Execute(ctx context.Context, raw json.RawMessage, progress func(string)) (core.ToolResult, error) {
134		prefix := t.Name()	121		prefix := t.Name()
135	-	if t.Swarm == nil {	122	+	if t.Supervisor == nil {
136	-	return protocolToolError(prefix + ": swarm supervisor not available in this mode")	123	+	return protocolToolError(prefix + ": subagent supervisor not available in this mode")
137		}	124		}
138		if t.Enabled == nil \|\| !t.Enabled() {	125		if t.Enabled == nil \|\| !t.Enabled() {
139	-	return protocolToolError(prefix + ": auto-swarm is disabled. Ask the user to enable it from /settings before delegating sub-tasks.")	126	+	return protocolToolError(prefix + ": auto-subagents is disabled. Ask the user to enable it from /settings before delegating sub-tasks.")
140		}	127		}
141	-	var a swarmSpawnArgs	128	+	var a subagentSpawnArgs
142		if err := json.Unmarshal(raw, &a); err != nil {	129		if err := json.Unmarshal(raw, &a); err != nil {
143		return core.ToolResult{}, fmt.Errorf("invalid args: %w", err)	130		return core.ToolResult{}, fmt.Errorf("invalid args: %w", err)
144		}	131		}

@@ -147,10 +134,10 @@ func (t *SwarmSpawnTool) Execute(ctx context.Context, raw json.RawMessage, progr
147		return protocolToolError(prefix + ": task is required")	134		return protocolToolError(prefix + ": task is required")
148		}	135		}
149			136
150	-	workspaceMode := swarm.WorkspaceShared	137	+	workspaceMode := subagents.WorkspaceShared
151		if value := strings.TrimSpace(a.Isolation); value != "" {	138		if value := strings.TrimSpace(a.Isolation); value != "" {
152	-	workspaceMode = swarm.WorkspaceMode(value)	139	+	workspaceMode = subagents.WorkspaceMode(value)
153	-	if workspaceMode != swarm.WorkspaceShared && workspaceMode != swarm.WorkspaceWorktree {	140	+	if workspaceMode != subagents.WorkspaceShared && workspaceMode != subagents.WorkspaceWorktree {
154		return protocolToolError(prefix + ": isolation must be shared or worktree")	141		return protocolToolError(prefix + ": isolation must be shared or worktree")
155		}	142		}
156		}	143		}

@@ -230,7 +217,7 @@ func (t *SwarmSpawnTool) Execute(ctx context.Context, raw json.RawMessage, progr
230		}	217		}
231		}	218		}
232			219
233	-	agent, err := t.Swarm.SpawnReq(ctx, swarm.SpawnRequest{	220	+	agent, err := t.Supervisor.SpawnReq(ctx, subagents.SpawnRequest{
234		Task: task,	221		Task: task,
235		Model: model,	222		Model: model,
236		Provider: providerID,	223		Provider: providerID,

@@ -287,7 +274,7 @@ func (t *SwarmSpawnTool) Execute(ctx context.Context, raw json.RawMessage, progr
287		"state": agent.Status(),	274		"state": agent.Status(),
288		"process_state": string(agent.ProcessState()),	275		"process_state": string(agent.ProcessState()),
289		"turn_state": string(agent.TurnState()),	276		"turn_state": string(agent.TurnState()),
290	-	"result_ref": swarm.ResultRef(agent.ID),	277	+	"result_ref": subagents.ResultRef(agent.ID),
291		},	278		},
292		}, nil	279		}, nil
293		}	280		}

R packages/agent/tools/swarm_spawn_test.go → packages/agent/tools/subagent_spawn_test.go +39 -39 renamed, 76% similar

 	"testing"
 	"github.com/patriceckhart/zot/packages/agent/subagents"
-	"github.com/patriceckhart/zot/packages/agent/swarm"
 	"github.com/patriceckhart/zot/packages/provider"
 )
-type noopSwarmRunner struct{}
+type noopSupervisorRunner struct{}
-func (noopSwarmRunner) Run(context.Context, swarm.Sink) error { return nil }
+func (noopSupervisorRunner) Run(context.Context, subagents.Sink) error { return nil }
-func newTestSwarm(t *testing.T) *swarm.Swarm {
+func newTestSupervisor(t *testing.T) *subagents.Supervisor {
 	t.Helper()
 	root := t.TempDir()
-	manager := swarm.New(swarm.Config{
+	manager := subagents.New(subagents.Config{
-		Root:     filepath.Join(root, "swarm"),
+		Root:     filepath.Join(root, "subagents"),
 		RepoRoot: root,
-		NewRunner: func(*swarm.Agent) swarm.Runner {
+		NewRunner: func(*subagents.Agent) subagents.Runner {
-			return noopSwarmRunner{}
+			return noopSupervisorRunner{}
 		},
 	})
 	t.Cleanup(manager.StopAll)
 	return manager
 }
-func TestSwarmSpawnInheritsHostModelAndProviderWhenOmitted(t *testing.T) {
+func TestSubagentSpawnInheritsHostModelAndProviderWhenOmitted(t *testing.T) {
-	tool := &SwarmSpawnTool{
+	tool := &SubagentSpawnTool{
-		Swarm:            newTestSwarm(t),
+		Supervisor:       newTestSupervisor(t),
 		Enabled:          func() bool { return true },
 		DefaultModel:     func() string { return "gpt-5" },
 		DefaultProvider:  func() string { return "openai-codex" },
 		t.Fatalf("result text missing inherited model/provider:\n%s", text)
 	}
-	agents := tool.Swarm.List()
+	agents := tool.Supervisor.List()
 	if len(agents) != 1 {
 		t.Fatalf("spawned agents = %d, want 1", len(agents))
 	}
 	}
 }
-func TestSwarmSpawnSelectsProfileAndReasoning(t *testing.T) {
+func TestSubagentSpawnSelectsProfileAndReasoning(t *testing.T) {
-	tool := &SwarmSpawnTool{
+	tool := &SubagentSpawnTool{
-		Swarm:   newTestSwarm(t),
+		Supervisor: newTestSupervisor(t),
-		Enabled: func() bool { return true },
+		Enabled:    func() bool { return true },
 		ResolveSubagent: func(name string) (*subagents.Profile, error) {
 			if name != "reviewer" {
 				return nil, nil
 			t.Fatalf("result text missing %q:\n%s", want, text)
 		}
 	}
-	agents := tool.Swarm.List()
+	agents := tool.Supervisor.List()
 	if len(agents) != 1 || agents[0].Subagent != "reviewer" || agents[0].Reasoning != "high" {
 		t.Fatalf("agent profile/reasoning = %#v", agents)
 	}
 	}
 }
-func TestSwarmSpawnAppliesProfileFastModeRestriction(t *testing.T) {
+func TestSubagentSpawnAppliesProfileFastModeRestriction(t *testing.T) {
 	root := t.TempDir()
 	profileFastMode := false
-	f := swarm.New(swarm.Config{
+	f := subagents.New(subagents.Config{
-		Root:     filepath.Join(root, "swarm"),
+		Root:     filepath.Join(root, "subagents"),
 		RepoRoot: root,
 		FastMode: true,
-		NewRunner: func(*swarm.Agent) swarm.Runner {
+		NewRunner: func(*subagents.Agent) subagents.Runner {
-			return noopSwarmRunner{}
+			return noopSupervisorRunner{}
 		},
 	})
-	tool := &SwarmSpawnTool{
+	t.Cleanup(f.StopAll)
-		Swarm:   f,
+	tool := &SubagentSpawnTool{
-		Enabled: func() bool { return true },
+		Supervisor: f,
+		Enabled:    func() bool { return true },
 		ResolveSubagent: func(name string) (*subagents.Profile, error) {
 			if name != "reviewer" {
 				return nil, nil
 	}
 }
-func TestSwarmSpawnUsesProfileReasoningWhenOmitted(t *testing.T) {
+func TestSubagentSpawnUsesProfileReasoningWhenOmitted(t *testing.T) {
-	tool := &SwarmSpawnTool{
+	tool := &SubagentSpawnTool{
-		Swarm:   newTestSwarm(t),
+		Supervisor: newTestSupervisor(t),
-		Enabled: func() bool { return true },
+		Enabled:    func() bool { return true },
 		ResolveSubagent: func(name string) (*subagents.Profile, error) {
 			if name != "reviewer" {
 				return nil, nil
 	if res.IsError {
 		t.Fatalf("unexpected tool error: %s", textResult(res.Content))
 	}
-	agents := tool.Swarm.List()
+	agents := tool.Supervisor.List()
 	if len(agents) != 1 || agents[0].Reasoning != "low" {
 		t.Fatalf("agent reasoning = %#v, want low", agents)
 	}
 }
-func TestSwarmSpawnRejectsUnknownProfile(t *testing.T) {
+func TestSubagentSpawnRejectsUnknownProfile(t *testing.T) {
-	tool := &SwarmSpawnTool{
+	tool := &SubagentSpawnTool{
-		Swarm:   newTestSwarm(t),
+		Supervisor: newTestSupervisor(t),
-		Enabled: func() bool { return true },
+		Enabled:    func() bool { return true },
 		ResolveSubagent: func(string) (*subagents.Profile, error) {
 			return nil, nil
 		},
 	if !res.IsError || !strings.Contains(textResult(res.Content), "unknown subagent profile") {
 		t.Fatalf("result = %#v, want unknown profile error", res)
 	}
-	if got := len(tool.Swarm.List()); got != 0 {
+	if got := len(tool.Supervisor.List()); got != 0 {
 		t.Fatalf("spawned agents = %d, want 0", got)
 	}
 }
-func TestSwarmSpawnRejectsPartialModelProviderOverride(t *testing.T) {
+func TestSubagentSpawnRejectsPartialModelProviderOverride(t *testing.T) {
-	tool := &SwarmSpawnTool{
+	tool := &SubagentSpawnTool{
-		Swarm:           newTestSwarm(t),
+		Supervisor:      newTestSupervisor(t),
 		Enabled:         func() bool { return true },
 		DefaultModel:    func() string { return "gpt-5" },
 		DefaultProvider: func() string { return "openai-codex" },
 	if got := textResult(res.Content); !strings.Contains(got, "omit both model/provider") {
 		t.Fatalf("error text = %q", got)
 	}
-	if got := len(tool.Swarm.List()); got != 0 {
+	if got := len(tool.Supervisor.List()); got != 0 {
 		t.Fatalf("spawned agents = %d, want 0", got)
 	}
 }

M packages/core/core_test.go +2 -2


@@ -116,11 +116,11 @@ func TestSessionRoundTripPreservesThoughtSignatures(t *testing.T) {
116		}	116		}
117		}	117		}
118			118
119	-	// TestNewSessionAtPathCreatesAtExplicitPath proves the swarm child's	119	+	// TestNewSessionAtPathCreatesAtExplicitPath proves the subagent worker's
120		// session-persistence fallback works: NewSessionAtPath creates the	120		// session-persistence fallback works: NewSessionAtPath creates the
121		// file (and parent dirs) at the exact path the caller chose,	121		// file (and parent dirs) at the exact path the caller chose,
122		// independent of SessionsDir(root, cwd). Without this helper, the	122		// independent of SessionsDir(root, cwd). Without this helper, the
123	-	// swarm child's --session <path> with a non-existent path would	123	+	// subagent worker's --session <path> with a non-existent path would
124		// fall through to NewSession and write the session under a	124		// fall through to NewSession and write the session under a
125		// different (autogenerated) name, leaving the supervisor-chosen	125		// different (autogenerated) name, leaving the supervisor-chosen
126		// path empty.	126		// path empty.

M packages/core/session.go +1 -1


@@ -153,7 +153,7 @@ func NewSession(root, cwd, providerName, model, version string) (*Session, error
153		}	153		}
154			154
155		// NewSessionAtPath creates a session at an explicit file path. Used	155		// NewSessionAtPath creates a session at an explicit file path. Used
156	-	// by callers (notably the swarm-agent child) that need the session	156	+	// by callers (notably the subagent worker) that need the session
157		// file to live at a path chosen by their parent rather than under	157		// file to live at a path chosen by their parent rather than under
158		// SessionsDir. Returns an error if the file already exists — use	158		// SessionsDir. Returns an error if the file already exists — use
159		// OpenSession for that case.	159		// OpenSession for that case.

M packages/tui/render.go +1 -1


@@ -476,7 +476,7 @@ func (r *Renderer) DrawLog(chat, bottom []string, cursorBottomRow, cursorCol int
476		// alternative — always writing SeqHideCursor + cursor-position +	476		// alternative — always writing SeqHideCursor + cursor-position +
477		// SeqShowCursor — resets the terminal's cursor blink timer on	477		// SeqShowCursor — resets the terminal's cursor blink timer on
478		// every tick. At our 120ms animation cadence that means the	478		// every tick. At our 120ms animation cadence that means the
479	-	// caret in an idle dialog editor (e.g. an open swarm transcript	479	+	// caret in an idle dialog editor (e.g. an open subagent transcript
480		// for an agent that's currently idle) appears as a solid block	480		// for an agent that's currently idle) appears as a solid block
481		// that never blinks, because we keep "showing" it before the	481		// that never blinks, because we keep "showing" it before the
482		// terminal can blink it off. Bailing out here lets the OS run	482		// terminal can blink it off. Bailing out here lets the OS run

M packages/tui/render_test.go +1 -1


@@ -14,7 +14,7 @@ import (
14		// used to always emit SeqHideCursor + cursor-position +	14		// used to always emit SeqHideCursor + cursor-position +
15		// SeqShowCursor, which resets the terminal's blink timer. Faster	15		// SeqShowCursor, which resets the terminal's blink timer. Faster
16		// than the OS blink interval, so an idle dialog editor (e.g. a	16		// than the OS blink interval, so an idle dialog editor (e.g. a
17	-	// re-opened swarm transcript whose agent isn't producing output)	17	+	// re-opened subagent transcript whose agent isn't producing output)
18		// rendered the caret as a solid non-blinking block.	18		// rendered the caret as a solid non-blinking block.
19		//	19		//
20		// With the no-op fast path the renderer leaves the screen alone	20		// With the no-op fast path the renderer leaves the screen alone