2d66a41 merge: integrate origin/main · zut

M README.md +2 -2


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

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

M docs/subagents.md +10 -4

 ## Selecting a profile
-When **auto-subagents** is enabled in `/settings`, the interactive primary agent runs in strict orchestrator mode. It must delegate all implementation, debugging/testing, and code-review work to an appropriately named profile, or to a clearly described general worker when no profile fits. The primary agent must not write or edit code, make direct implementation tool calls, inspect or review code, or apply worker patches. It may decompose requests, select and spawn workers, check status, coordinate follow-ups, and synthesize their results. This is a prompt-level behavior contract; the normal tool registry is not narrowed by this setting.
+When **auto-subagents** is enabled in `/settings`, the interactive primary agent runs in strict orchestrator mode. It must delegate all implementation, debugging/testing, and code-review work to an appropriately named profile, or to a clearly described general worker when no profile fits. The primary agent must not write or edit code, make direct implementation tool calls, inspect or review code, or apply worker patches. It may decompose requests, select and spawn workers, check status, coordinate follow-ups, and synthesize their results.
+When auto-subagents is disabled, the canonical subagent tools remain available subject to launch-time policy. The primary may use them when the user requests delegation or an active skill workflow requires delegation. It continues to perform work itself otherwise and does not receive the profile manifest or strict orchestrator contract. The setting changes prompting, not tool availability.
 When `subagent_spawn` is available, the orchestrator receives a compact `[subagents_list]` section in its system prompt and should select the profile whose description best matches each worker task. If launch-time policy withholds `subagent_spawn`, strict orchestrator guidance remains active, profile metadata is omitted, and the primary must report that delegation is unavailable rather than implementing directly. If no profile fits when spawning is available, omit `agent` to use a general worker:
 subagent://<id>/patch
 ```
+`events.jsonl` is appended as the worker emits events, including partial `message.delta` output. The dashboard and `subagent://<id>/history` replay those deltas, so output received before a worker finishes remains recoverable rather than waiting for a final assistant message.
+When a subagent deadline expires, the supervisor requests worker shutdown and allows the configured grace period for the worker to cancel its turn and write its session and result. The terminal result remains a failure with error code `deadline_exceeded`, preserves any output already received, and directs the caller to its history. If the worker does not stop during that grace period, the supervisor forcefully cancels it to preserve the timeout limit.
 Use `/subagents resume-session <id>` to continue the existing session without replaying its original task. Use `/subagents restart-task <id>` only when intentionally starting the stored task again. Cancellation requests graceful shutdown first, then forcefully cancels after the configured grace period.
-When auto-subagents is enabled and permitted by launch-time policy, the model can manage workers with `subagent_status`, `subagent_stop`, and `subagent_resume`. Call `subagent_status` with `{}` to list workers visible to the active supervisor session, or pass `{"agent_id":"<id-or-unique-prefix>"}` to query one worker. Queries use in-process snapshots and never wait for a worker turn or process to finish; repeated calls or state inspection are not completion signals. The JSON response contains the worker id, a normalized lifecycle state (`starting`, `running`, `completed`, `failed`, `cancelled`, or `detached`), the underlying `process_state` and `turn_state`, start/update/finish timestamps, a bounded first-line task summary, and terminal-result metadata/reference when available. It intentionally omits prompts, transcripts, result output, credentials, provider settings, and filesystem paths.
+When auto-subagents is enabled and permitted by launch-time policy, the model can manage workers with `subagent_status`, `subagent_stop`, and `subagent_resume`. Call `subagent_status` with `{}` to list workers visible to the active supervisor session, or pass `{"agent_id":"<id-or-unique-prefix>"}` to query one worker. Queries use in-process snapshots and never wait for a worker turn or process to finish; repeated calls or state inspection are not completion signals. The JSON response contains the worker id, a normalized lifecycle state (`starting`, `running`, `completed`, `failed`, `cancelled`, or `detached`), the underlying `process_state` and `turn_state`, `lifetime_turns` and `current_run_turns` counters, start/update/finish timestamps, a bounded first-line task summary, and terminal-result metadata/reference when available. It intentionally omits prompts, transcripts, result output, credentials, provider settings, and filesystem paths.
-Use `subagent_stop` with an `agent_id` to request termination of a stuck worker through the normal graceful-then-forceful supervisor lifecycle. Its `stop_requested` result confirms that shutdown has started; wait for the host completion update before attempting a restart. Use `subagent_resume` with an `agent_id` and `prompt` to send a new follow-up to an idle worker or to restart a terminal worker from its retained session with that follow-up as the initial turn. It never replays the original task, and its completion is delivered to the manager through the normal auto-subagent update. An unknown or ambiguous id is returned as a model-visible tool error; the existing `/subagents` dashboard and final-result notifications remain unchanged. An explicit `--tools` allowlist must include each manager tool that the model needs, and `subagent_status` must not be polled solely to wait for completion.
+Use `subagent_stop` with an `agent_id` to request termination of a stuck worker through the normal graceful-then-forceful supervisor lifecycle. Its `stop_requested` result confirms that shutdown has started; wait for the host completion update before attempting a restart. Use `subagent_resume` with an `agent_id` and `prompt` to start a fresh max-turn budget while retaining the transcript/session/context, send the follow-up to an idle worker, queue it for the next available message turn when the worker is active, or restart a terminal worker from its retained session with that follow-up as the initial turn. A follow-up remains durably pending until its matching user message is flushed to the session and the delegated `turn.started` boundary is recorded; a worker-ready event alone does not acknowledge it. Automatic retries, model loops, and compaction remain within the current run budget; multiple active follow-ups are delivered in order. Commands have stable identities so cancellation or an ambiguous socket-write outcome can be retried without replaying an accepted command. It never replays the original task, and its completion is delivered to the manager through the normal auto-subagent update. An unknown or ambiguous id is returned as a model-visible tool error; the existing `/subagents` dashboard and final-result notifications remain unchanged. An explicit `--tools` allowlist must include each manager tool that the model needs, and `subagent_status` must not be polled solely to wait for completion.
 ## Resource policy
-The persisted `subagents` config object supports `max_concurrent`, `max_concurrent_per_parent`, `queue_timeout`, `default_timeout`, `max_turns`, output caps, allowed tools/roots, heartbeat and idle timeouts. Previously saved `max_total_spawned` values are accepted but ignored. A missing or non-positive configured `max_turns` uses the default ceiling of 3. The `max_turns` field in `subagent_spawn` is optional: omit it to use the policy ceiling, or provide a value from 1 through the configured maximum. Concurrency limits apply to slash commands, `subagent_spawn`, and batch operations. A child cannot create descendants in v1. Per-agent timeouts are retained across reload/resume. Packaged `zut run` agents keep their declared capability ceiling by disabling subagent delegation; profiles are not a substitute for that permission boundary. A primary whose launch-time policy disables delegation still receives the strict orchestrator contract, but does not receive actionable profile metadata or a replacement implementation path.
+The persisted `subagents` config object supports `max_concurrent`, `max_concurrent_per_parent`, `queue_timeout`, `default_timeout`, `max_turns`, output caps, allowed tools/roots, heartbeat and idle timeouts. `max_turns` bounds one active worker run; lifetime and current-run turn counters remain persisted and visible in worker status. An explicit `subagent_resume` starts a new run with a fresh budget without replaying the original task or losing session context. Previously saved `max_total_spawned` values are accepted but ignored. A missing or non-positive configured `max_turns` uses the default ceiling of 3. The `max_turns` field in `subagent_spawn` is optional: omit it to use the policy ceiling, or provide a value from 1 through the configured maximum. Concurrency limits apply to slash commands, `subagent_spawn`, and batch operations. A child cannot create descendants in v1. Per-agent timeouts are retained across reload/resume. Packaged `zut run` agents keep their declared capability ceiling by disabling subagent delegation; profiles are not a substitute for that permission boundary. A primary whose launch-time policy disables delegation still receives the strict orchestrator contract, but does not receive actionable profile metadata or a replacement implementation path.

M packages/agent/args.go +26 -1


@@ -139,8 +139,13 @@ type Args struct {
139		// --subagent-worker.	139		// --subagent-worker.
140		SubagentWorker string	140		SubagentWorker string
141			141
142	-	// SubagentMaxTurns limits prompt-level turns in worker mode.	142	+	// SubagentMaxTurns limits message turns in one worker run.
143		SubagentMaxTurns int	143		SubagentMaxTurns int
			144	+	// SubagentLifetimeTurns and SubagentRunTurns are supervisor-provided
			145	+	// counters used to resume a worker without losing observability or its
			146	+	// current-run budget. They are internal worker flags, not user policy.
			147	+	SubagentLifetimeTurns int
			148	+	SubagentRunTurns int
144			149
145		// Subagent selects a named markdown profile for a subagent child.	150		// Subagent selects a named markdown profile for a subagent child.
146		// It is intentionally an internal child flag; the parent subagent tool	151		// It is intentionally an internal child flag; the parent subagent tool

@@ -371,6 +376,26 @@ func ParseArgs(in []string) (Args, error) {
371		return a, fmt.Errorf("--max-turns must be a positive integer")	376		return a, fmt.Errorf("--max-turns must be a positive integer")
372		}	377		}
373		a.SubagentMaxTurns = n	378		a.SubagentMaxTurns = n
			379	+	case "--subagent-lifetime-turns":
			380	+	v, err := want(&i, arg)
			381	+	if err != nil {
			382	+	return a, err
			383	+	}
			384	+	var n int
			385	+	if _, err := fmt.Sscanf(v, "%d", &n); err != nil \|\| n < 0 {
			386	+	return a, fmt.Errorf("--subagent-lifetime-turns must be a non-negative integer")
			387	+	}
			388	+	a.SubagentLifetimeTurns = n
			389	+	case "--subagent-run-turns":
			390	+	v, err := want(&i, arg)
			391	+	if err != nil {
			392	+	return a, err
			393	+	}
			394	+	var n int
			395	+	if _, err := fmt.Sscanf(v, "%d", &n); err != nil \|\| n < 0 {
			396	+	return a, fmt.Errorf("--subagent-run-turns must be a non-negative integer")
			397	+	}
			398	+	a.SubagentRunTurns = n
374		default:	399		default:
375		if strings.HasPrefix(arg, "-") && arg != "-" {	400		if strings.HasPrefix(arg, "-") && arg != "-" {
376		return a, fmt.Errorf("unknown flag %q", arg)	401		return a, fmt.Errorf("unknown flag %q", arg)

M packages/agent/build.go +2 -0


@@ -870,6 +870,8 @@ func Resolve(args Args, requireCred bool) (Resolved, error) {
870	autoSubagentsStopToolAllowed(args),	870		autoSubagentsStopToolAllowed(args),
871	autoSubagentsResumeToolAllowed(args),	871		autoSubagentsResumeToolAllowed(args),
872	))	872		))
		873	+	} else if selectedProfile == nil && interactiveMode && autoSubagentsAnyToolAllowed(args) {
		874	+	append_ = append(append_, OnDemandSubagentsSystemAddendum)
873	}	875		}
874	if selectedProfile != nil && selectedProfile.SystemPromptMode != "replace" && selectedProfile.SystemPrompt != "" {	876		if selectedProfile != nil && selectedProfile.SystemPromptMode != "replace" && selectedProfile.SystemPrompt != "" {
875	append_ = append(append_, selectedProfile.SystemPrompt)	877		append_ = append(append_, selectedProfile.SystemPrompt)

M packages/agent/build_test.go +8 -0


@@ -501,6 +501,14 @@ func TestResolveOmitsAutoSubagentsOrchestratorContractWhenDisabled(t *testing.T)
501	t.Fatalf("disabled system prompt contains auto-subagents contract %q:\n%s", unwanted, r.SystemPrompt)	501		t.Fatalf("disabled system prompt contains auto-subagents contract %q:\n%s", unwanted, r.SystemPrompt)
502	}	502		}
503	}	503		}
		504	+	for _, required := range []string{
		505	+	"user asks you to delegate",
		506	+	"active skill workflow requires delegation",
		507	+	} {
		508	+	if !strings.Contains(r.SystemPrompt, required) {
		509	+	t.Fatalf("disabled system prompt omits permitted delegation path %q:\n%s", required, r.SystemPrompt)
		510	+	}
		511	+	}
504	}	512		}
505		513
506	func TestResolveAppliesSelectedSubagentProfile(t *testing.T) {	514		func TestResolveAppliesSelectedSubagentProfile(t *testing.T) {

M packages/agent/cli.go +32 -37


@@ -1496,23 +1496,17 @@ func runInteractive(ctx context.Context, args Args, version string) (runErr erro
1496		return findSubagentProfile(r.CWD, name)	1496		return findSubagentProfile(r.CWD, name)
1497		}	1497		}
1498			1498
1499	-	// Inject the auto-subagent tools only when /settings -> auto-subagents	1499	+	// Register the canonical subagent tools whenever launch-time policy permits
1500	-	// is currently enabled. Registering them unconditionally leaves the model	1500	+	// them. The auto-subagents setting controls strict orchestration guidance,
1501	-	// trying to call them (and getting a polite error) even when the user has	1501	+	// not explicit user-requested delegation.
1502	-	// switched the feature off. The /settings toggle live-mutates the running
1503	-	// agent's registry separately so flipping the flag mid-session takes effect
1504	-	// on the next turn.
1505		injectSubagentTools := func(reg core.Registry) core.Registry {	1502		injectSubagentTools := func(reg core.Registry) core.Registry {
1506		if reg == nil \|\| subagentsMgr == nil \|\| !autoSubagentsAnyToolAllowed(args) {	1503		if reg == nil \|\| subagentsMgr == nil \|\| !autoSubagentsAnyToolAllowed(args) {
1507		return reg	1504		return reg
1508		}	1505		}
1509	-	if !AutoSubagentsEnabled() {
1510	-	return reg
1511	-	}
1512		if autoSubagentsToolAllowed(args) {	1506		if autoSubagentsToolAllowed(args) {
1513		canonical := &tools.SubagentSpawnTool{	1507		canonical := &tools.SubagentSpawnTool{
1514		Supervisor: subagentsMgr,	1508		Supervisor: subagentsMgr,
1515	-	Enabled: AutoSubagentsEnabled,	1509	+	Enabled: func() bool { return true },
1516		DefaultModel: func() string {	1510		DefaultModel: func() string {
1517		persistMu.Lock()	1511		persistMu.Lock()
1518		defer persistMu.Unlock()	1512		defer persistMu.Unlock()

@@ -1532,14 +1526,14 @@ func runInteractive(ctx context.Context, args Args, version string) (runErr erro
1532		if autoSubagentsStatusToolAllowed(args) {	1526		if autoSubagentsStatusToolAllowed(args) {
1533		statusTool := &tools.SubagentStatusTool{	1527		statusTool := &tools.SubagentStatusTool{
1534		Supervisor: subagentsMgr,	1528		Supervisor: subagentsMgr,
1535	-	Enabled: AutoSubagentsEnabled,	1529	+	Enabled: func() bool { return true },
1536		}	1530		}
1537		reg[statusTool.Name()] = statusTool	1531		reg[statusTool.Name()] = statusTool
1538		}	1532		}
1539		if autoSubagentsStopToolAllowed(args) {	1533		if autoSubagentsStopToolAllowed(args) {
1540		stopTool := &tools.SubagentStopTool{	1534		stopTool := &tools.SubagentStopTool{
1541		Supervisor: subagentsMgr,	1535		Supervisor: subagentsMgr,
1542	-	Enabled: AutoSubagentsEnabled,	1536	+	Enabled: func() bool { return true },
1543		OnStopRequested: onStopRequestedSupervisor,	1537		OnStopRequested: onStopRequestedSupervisor,
1544		}	1538		}
1545		reg[stopTool.Name()] = stopTool	1539		reg[stopTool.Name()] = stopTool

@@ -1547,7 +1541,7 @@ func runInteractive(ctx context.Context, args Args, version string) (runErr erro
1547		if autoSubagentsResumeToolAllowed(args) {	1541		if autoSubagentsResumeToolAllowed(args) {
1548		resumeTool := &tools.SubagentResumeTool{	1542		resumeTool := &tools.SubagentResumeTool{
1549		Supervisor: subagentsMgr,	1543		Supervisor: subagentsMgr,
1550	-	Enabled: AutoSubagentsEnabled,	1544	+	Enabled: func() bool { return true },
1551		OnResumed: onResumedSupervisor,	1545		OnResumed: onResumedSupervisor,
1552		}	1546		}
1553		reg[resumeTool.Name()] = resumeTool	1547		reg[resumeTool.Name()] = resumeTool

@@ -2341,30 +2335,31 @@ func runInteractive(ctx context.Context, args Args, version string) (runErr erro
2341		autoSubagentsStopToolAllowedForSession,	2335		autoSubagentsStopToolAllowedForSession,
2342		autoSubagentsResumeToolAllowedForSession,	2336		autoSubagentsResumeToolAllowedForSession,
2343		),	2337		),
2344	-	SubagentsSystemAddendum: subagentsAddendum,	2338	+	OnDemandSubagentsSystemAddendum: OnDemandSubagentsSystemAddendum,
2345	-	SettingsStore: configSettingsStore{},	2339	+	SubagentsSystemAddendum: subagentsAddendum,
2346	-	Model: r.Model,	2340	+	SettingsStore: configSettingsStore{},
2347	-	Provider: r.Provider,	2341	+	Model: r.Model,
2348	-	AuthMethod: r.AuthMethod,	2342	+	Provider: r.Provider,
2349	-	BaseURL: r.BaseURL,	2343	+	AuthMethod: r.AuthMethod,
2350	-	Reasoning: r.Reasoning,	2344	+	BaseURL: r.BaseURL,
2351	-	SystemPrompt: r.SystemPrompt,	2345	+	Reasoning: r.Reasoning,
2352	-	Tools: r.ToolRegistry,	2346	+	SystemPrompt: r.SystemPrompt,
2353	-	MaxSteps: r.MaxSteps,	2347	+	Tools: r.ToolRegistry,
2354	-	CWD: r.CWD,	2348	+	MaxSteps: r.MaxSteps,
2355	-	StartupAgentName: args.AgentName,	2349	+	CWD: r.CWD,
2356	-	StartupContextPaths: instructionContextPaths(r.ContextFiles),	2350	+	StartupAgentName: args.AgentName,
2357	-	StartupExtensionNames: startupExtensionNames(extMgr.All()),	2351	+	StartupContextPaths: instructionContextPaths(r.ContextFiles),
2358	-	StartupExtensionErrors: startupExtensionErrors,	2352	+	StartupExtensionNames: startupExtensionNames(extMgr.All()),
2359	-	StartupSkillNames: startupSkillNames(startupSkills),	2353	+	StartupExtensionErrors: startupExtensionErrors,
2360	-	ShowInstructionsAtStartup: initialCfg.ShowInstructionsAtStartup,	2354	+	StartupSkillNames: startupSkillNames(startupSkills),
2361	-	ZutHome: ZutHome(),	2355	+	ShowInstructionsAtStartup: initialCfg.ShowInstructionsAtStartup,
2362	-	SessionsRoot: agentSessionsRoot(ZutHome(), args),	2356	+	ZutHome: ZutHome(),
2363	-	Version: version,	2357	+	SessionsRoot: agentSessionsRoot(ZutHome(), args),
2364	-	UpdateInfoChan: updateCh,	2358	+	Version: version,
2365	-	Sandbox: sharedSandbox,	2359	+	UpdateInfoChan: updateCh,
2366	-	Agent: ag,	2360	+	Sandbox: sharedSandbox,
2367	-	InitialCompactHandoff: currentCompactHandoff(),	2361	+	Agent: ag,
			2362	+	InitialCompactHandoff: currentCompactHandoff(),
2368		InitialSessionTitle: func() string {	2363		InitialSessionTitle: func() string {
2369		if sess == nil \|\| sessionTitlePending {	2364		if sess == nil \|\| sessionTitlePending {
2370		return ""	2365		return ""

M packages/agent/modes/auto_subagents_policy_test.go +28 -2


@@ -155,7 +155,7 @@ func TestAutoSubagentsToolRegistrationHonorsLaunchPolicy(t *testing.T) {
155		dirty: make(chan struct{}, 1),	155		dirty: make(chan struct{}, 1),
156		}	156		}
157			157
158	-	iv.applyAutoSubagentsTool(true)	158	+	iv.applyAutoSubagentsTool()
159		if _, ok := iv.agent.Tools["subagent_spawn"]; ok {	159		if _, ok := iv.agent.Tools["subagent_spawn"]; ok {
160		t.Fatal("subagent_spawn registered despite launch-time policy")	160		t.Fatal("subagent_spawn registered despite launch-time policy")
161		}	161		}

@@ -220,7 +220,7 @@ func TestAutoSubagentsToolRegistrationHonorsSeparateLaunchPolicies(t *testing.T)
220		dirty: make(chan struct{}, 1),	220		dirty: make(chan struct{}, 1),
221		}	221		}
222			222
223	-	iv.applyAutoSubagentsTool(true)	223	+	iv.applyAutoSubagentsTool()
224		_, gotSpawn := iv.agent.Tools["subagent_spawn"]	224		_, gotSpawn := iv.agent.Tools["subagent_spawn"]
225		_, gotStatus := iv.agent.Tools["subagent_status"]	225		_, gotStatus := iv.agent.Tools["subagent_status"]
226		_, gotStop := iv.agent.Tools["subagent_stop"]	226		_, gotStop := iv.agent.Tools["subagent_stop"]

@@ -232,6 +232,32 @@ func TestAutoSubagentsToolRegistrationHonorsSeparateLaunchPolicies(t *testing.T)
232		}	232		}
233		}	233		}
234			234
			235	+	func TestAutoSubagentsDisabledKeepsToolsForExplicitUserRequests(t *testing.T) {
			236	+	enabled := false
			237	+	allowed := true
			238	+	supervisor := subagents.New(subagents.Config{Root: t.TempDir(), RepoRoot: t.TempDir()})
			239	+	t.Cleanup(supervisor.StopAll)
			240	+	iv := NewInteractive(InteractiveConfig{
			241	+	Agent: &core.Agent{Tools: core.Registry{}},
			242	+	AutoSubagentsEnabled: &enabled,
			243	+	AutoSubagentsToolAllowed: &allowed,
			244	+	AutoSubagentsSystemAddendum: "primary-agent orchestrator",
			245	+	Supervisor: supervisor,
			246	+	})
			247	+
			248	+	spawn, ok := iv.agent.ToolsSnapshot()["subagent_spawn"].(*tools.SubagentSpawnTool)
			249	+	if !ok {
			250	+	t.Fatal("subagent_spawn is unavailable when automatic subagents are disabled")
			251	+	}
			252	+	if spawn.Enabled == nil \|\| !spawn.Enabled() {
			253	+	t.Fatal("subagent_spawn is disabled when a user explicitly requests delegation")
			254	+	}
			255	+	system, _ := iv.agent.PromptConfig()
			256	+	if strings.Contains(system, "primary-agent orchestrator") {
			257	+	t.Fatalf("disabled automatic subagents retained the orchestrator contract: %q", system)
			258	+	}
			259	+	}
			260	+
235		type serializedAutoSubagentsClient struct {	261		type serializedAutoSubagentsClient struct {
236		started chan struct{}	262		started chan struct{}
237		request chan provider.Request	263		request chan provider.Request

M packages/agent/modes/auto_subagents_test.go +11 -4

 	"github.com/bnema/zut/packages/provider"
 )
+const autoSubagentsTestTimeout = 10 * time.Second
 func TestAutoSubagentsSystemPromptTogglesProfileManifestWithDelegationGuidance(t *testing.T) {
+	const onDemand = "delegate only on an explicit user request"
 	iv := &Interactive{
 		agent: &core.Agent{System: "base system"},
 		cfg: InteractiveConfig{
-			AutoSubagentsSystemAddendum: "auto-subagents guidance",
+			AutoSubagentsSystemAddendum:     "auto-subagents guidance",
-			SubagentsSystemAddendum:     "[subagents_list]\n- reviewer\n[/subagents_list]",
+			OnDemandSubagentsSystemAddendum: onDemand,
-			Supervisor:                  &subagents.Supervisor{},
+			SubagentsSystemAddendum:         "[subagents_list]\n- reviewer\n[/subagents_list]",
+			Supervisor:                      &subagents.Supervisor{},
 		},
 	}
 	if strings.Contains(iv.agent.System, "[subagents_list]") || strings.Contains(iv.agent.System, "auto-subagents guidance") {
 		t.Fatalf("disabled system prompt retained subagent blocks: %q", iv.agent.System)
 	}
+	if !strings.Contains(iv.agent.System, onDemand) {
+		t.Fatalf("disabled system prompt omitted on-demand delegation guidance: %q", iv.agent.System)
+	}
 }
 func TestAutoSubagentsTogglePreservesMatchingBasePromptBlocks(t *testing.T) {
 func waitForQueuedPrompt(t *testing.T, iv *Interactive) string {
 	t.Helper()
-	deadline := time.NewTimer(time.Second)
+	deadline := time.NewTimer(autoSubagentsTestTimeout)
 	defer deadline.Stop()
 	ticker := time.NewTicker(time.Millisecond)
 	defer ticker.Stop()

M packages/agent/modes/interactive.go +67 -85


@@ -179,12 +179,15 @@ type InteractiveConfig struct {
179		// ExtensionThemes returns themes bundled with loaded extensions.	179		// ExtensionThemes returns themes bundled with loaded extensions.
180		ExtensionThemes func() []tui.ThemeOption	180		ExtensionThemes func() []tui.ThemeOption
181			181
182	-	// AutoSubagentsSystemAddendum is the system-prompt block that gets	182	+	// AutoSubagentsSystemAddendum is the strict orchestrator block that gets
183	-	// appended/stripped when the user toggles auto-subagents at runtime.	183	+	// appended when the user enables auto-subagents at runtime. Plumbed in from
184	-	// Plumbed in from the cli so this package doesn't have to import	184	+	// the cli so this package doesn't have to import agent (cycle).
185	-	// agent (cycle).
186		AutoSubagentsSystemAddendum string	185		AutoSubagentsSystemAddendum string
187			186
			187	+	// OnDemandSubagentsSystemAddendum limits delegation to explicit user
			188	+	// requests while auto-subagents is disabled.
			189	+	OnDemandSubagentsSystemAddendum string
			190	+
188		// SubagentsSystemAddendum is the metadata-only [subagents_list]	191		// SubagentsSystemAddendum is the metadata-only [subagents_list]
189		// block that is added or removed together with auto-subagents.	192		// block that is added or removed together with auto-subagents.
190		SubagentsSystemAddendum string	193		SubagentsSystemAddendum string

@@ -974,9 +977,7 @@ func NewInteractive(cfg InteractiveConfig) *Interactive {
974		baseURL, _, err := cfg.LlamaCPPConfig()	977		baseURL, _, err := cfg.LlamaCPPConfig()
975		i.llamaConfigured = err == nil && baseURL != ""	978		i.llamaConfigured = err == nil && baseURL != ""
976		}	979		}
977	-	if cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {	980	+	i.managedAutoSubagentsAddenda = autoSubagentsAddenda(cfg, cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled)
978	-	i.managedAutoSubagentsAddenda = autoSubagentsAddenda(cfg)
979	-	}
980		if cfg.Agent != nil {	981		if cfg.Agent != nil {
981		i.agent = cfg.Agent	982		i.agent = cfg.Agent
982		i.view.Messages = filterHiddenTranscriptMessages(cfg.Agent.Messages())	983		i.view.Messages = filterHiddenTranscriptMessages(cfg.Agent.Messages())

@@ -1003,9 +1004,7 @@ func NewInteractive(cfg InteractiveConfig) *Interactive {
1003		i.titleRealPromptSeen = i.sessionTitle != "" \|\| hasRealUserPrompt(i.view.Messages)	1004		i.titleRealPromptSeen = i.sessionTitle != "" \|\| hasRealUserPrompt(i.view.Messages)
1004		i.titleGenerationStarted = i.titleRealPromptSeen	1005		i.titleGenerationStarted = i.titleRealPromptSeen
1005		}	1006		}
1006	-	if cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {	1007	+	i.applyAutoSubagentsTool()
1007	-	i.applyAutoSubagentsTool(true)
1008	-	}
1009		return i	1008		return i
1010		}	1009		}
1011			1010

@@ -1343,10 +1342,9 @@ func (i *Interactive) requestRendererTheme(theme tui.Theme) {
1343			1342
1344		func (i *Interactive) invalidate() {	1343		func (i *Interactive) invalidate() {
1345		i.renderRevision.Add(1)	1344		i.renderRevision.Add(1)
1346	-	if scheduler := i.renderScheduler.Load(); scheduler != nil {	1345	+	// Keep ordinary state changes on the main-loop throttle. The scheduler
1347	-	scheduler.request(false, false)	1346	+	// owns terminal output, but scheduling it here would bypass
1348	-	return	1347	+	// redrawMinInterval and paint every intermediate tool-event frame.
1349	-	}
1350		select {	1348		select {
1351		case i.dirty <- struct{}{}:	1349		case i.dirty <- struct{}{}:
1352		default:	1350		default:

@@ -2224,11 +2222,6 @@ func (i *Interactive) redraw() {
2224		i.subagentActivityActive = !dashboardActive && len(subagentLines) > 0	2222		i.subagentActivityActive = !dashboardActive && len(subagentLines) > 0
2225			2223
2226		chatRows := rows - len(bottom)	2224		chatRows := rows - len(bottom)
2227	-	if rightBarActive {
2228	-	// DrawRightBar keeps the renderer-owned bottom margin inside the
2229	-	// fixed frame, so reserve that row before selecting visible chat.
2230	-	chatRows--
2231	-	}
2232		if chatRows < 1 {	2225		if chatRows < 1 {
2233		chatRows = 1	2226		chatRows = 1
2234		}	2227		}

@@ -4018,11 +4011,7 @@ func (i Interactive) applyChangedCWD(ag core.Agent, provider, model, cwd strin
4018		i.agent = ag	4011		i.agent = ag
4019		i.cfg.CWD = cwd	4012		i.cfg.CWD = cwd
4020		i.cfg.SubagentsSystemAddendum = subagentsAddendum	4013		i.cfg.SubagentsSystemAddendum = subagentsAddendum
4021	-	if i.autoSubagentsEnabledLocked() {	4014	+	i.managedAutoSubagentsAddenda = autoSubagentsAddenda(i.cfg, i.autoSubagentsEnabledLocked())
4022	-	i.managedAutoSubagentsAddenda = autoSubagentsAddenda(i.cfg)
4023	-	} else {
4024	-	i.managedAutoSubagentsAddenda = nil
4025	-	}
4026		i.cfg.StartupContextPaths = append([]string(nil), startupContextPaths...)	4015		i.cfg.StartupContextPaths = append([]string(nil), startupContextPaths...)
4027		i.view.StartupContextPaths = nil	4016		i.view.StartupContextPaths = nil
4028		i.view.InvalidateRenderCache()	4017		i.view.InvalidateRenderCache()

@@ -5244,14 +5233,12 @@ func (i *Interactive) applySettingToggle(key string, value bool) {
5244		return	5233		return
5245		}	5234		}
5246		}	5235		}
5247	-	// Add/remove the auto-subagent tools on the live agent so the	5236	+	// The subagent tools remain available for explicit user requests.
5248	-	// model's tools[] list reflects the toggle on the next turn.	5237	+	// Swap only the system-prompt guidance between strict orchestration and
5249	-	// Without this the tools stay advertised after a disable and	5238	+	// on-demand delegation.
5250	-	// the model keeps trying to call them.	5239	+	i.applyAutoSubagentsTool()
5251	-	i.applyAutoSubagentsTool(value)	5240	+	// Also swap the system-prompt addendum so the model knows whether it
5252	-	// Also swap the system-prompt addendum in/out so the model	5241	+	// should orchestrate proactively or delegate only on user request.
5253	-	// knows to use the tools proactively (or stops referencing them
5254	-	// after a disable).
5255		i.applyAutoSubagentsSystemPrompt(value)	5242		i.applyAutoSubagentsSystemPrompt(value)
5256		i.mu.Lock()	5243		i.mu.Lock()
5257		i.statusOK = "auto-subagents " + onOff(value)	5244		i.statusOK = "auto-subagents " + onOff(value)

@@ -6909,7 +6896,7 @@ func (i *Interactive) swapModelUnserialized(prov, model string, builder func(str
6909		// dynamically-registered tools need to be reattached. The apply	6896		// dynamically-registered tools need to be reattached. The apply
6910		// helpers are no-ops when their feature is inactive, so the	6897		// helpers are no-ops when their feature is inactive, so the
6911		// cross-provider path still works on a vanilla setup.	6898		// cross-provider path still works on a vanilla setup.
6912	-	i.applyAutoSubagentsTool(i.autoSubagentsEnabled())	6899	+	i.applyAutoSubagentsTool()
6913		i.applyTelegramTools(i.telegramBridge != nil)	6900		i.applyTelegramTools(i.telegramBridge != nil)
6914		if i.cfg.PersistModel != nil {	6901		if i.cfg.PersistModel != nil {
6915		i.cfg.PersistModel(p, md)	6902		i.cfg.PersistModel(p, md)

@@ -6952,7 +6939,7 @@ func (i *Interactive) handleAuthEvent(ev auth.Event) {
6952		if oldAgent != nil {	6939		if oldAgent != nil {
6953		_ = tools.CloseLSPManagers(oldAgent.ToolsSnapshot())	6940		_ = tools.CloseLSPManagers(oldAgent.ToolsSnapshot())
6954		}	6941		}
6955	-	i.applyAutoSubagentsTool(i.autoSubagentsEnabled())	6942	+	i.applyAutoSubagentsTool()
6956		i.applyTelegramTools(i.telegramBridge != nil)	6943		i.applyTelegramTools(i.telegramBridge != nil)
6957		// Authentication can change the provider used by the live	6944		// Authentication can change the provider used by the live
6958		// agent. Persist it on the active session just like /model.	6945		// agent. Persist it on the active session just like /model.

@@ -8851,8 +8838,18 @@ func truncateForSummary(s string, n int) string {
8851		}	8838		}
8852			8839
8853		// autoSubagentsAddenda returns the prompt blocks owned by the auto-subagents	8840		// autoSubagentsAddenda returns the prompt blocks owned by the auto-subagents
8854	-	// toggle, in the same order Resolve appends them to a new agent.	8841	+	// setting, in the same order Resolve appends them to a new agent.
8855	-	func autoSubagentsAddenda(cfg InteractiveConfig) []string {	8842	+	func autoSubagentsAddenda(cfg InteractiveConfig, orchestrating bool) []string {
			8843	+	if !orchestrating {
			8844	+	if cfg.Supervisor == nil \|\| !autoSubagentsAnyToolAllowedConfig(cfg) {
			8845	+	return nil
			8846	+	}
			8847	+	if addendum := strings.TrimSpace(cfg.OnDemandSubagentsSystemAddendum); addendum != "" {
			8848	+	return []string{addendum}
			8849	+	}
			8850	+	return nil
			8851	+	}
			8852	+
8856		addenda := make([]string, 0, 2)	8853		addenda := make([]string, 0, 2)
8857		if cfg.Supervisor != nil && autoSubagentsToolAllowedConfig(cfg) {	8854		if cfg.Supervisor != nil && autoSubagentsToolAllowedConfig(cfg) {
8858		if addendum := strings.TrimSpace(cfg.SubagentsSystemAddendum); addendum != "" {	8855		if addendum := strings.TrimSpace(cfg.SubagentsSystemAddendum); addendum != "" {

@@ -8865,15 +8862,6 @@ func autoSubagentsAddenda(cfg InteractiveConfig) []string {
8865		return addenda	8862		return addenda
8866		}	8863		}
8867			8864
8868	-	func containsAutoSubagentsAddendum(addenda []string, want string) bool {
8869	-	for _, addendum := range addenda {
8870	-	if addendum == want {
8871	-	return true
8872	-	}
8873	-	}
8874	-	return false
8875	-	}
8876	-
8877		// removeLastAutoSubagentsAddendum removes one occurrence of a block known to	8865		// removeLastAutoSubagentsAddendum removes one occurrence of a block known to
8878		// have been appended by auto-subagents. Resolve appends owned blocks at the	8866		// have been appended by auto-subagents. Resolve appends owned blocks at the
8879		// end, so removing the last occurrence preserves an identical base block.	8867		// end, so removing the last occurrence preserves an identical base block.

@@ -8885,11 +8873,10 @@ func removeLastAutoSubagentsAddendum(system, addendum string) (string, bool) {
8885		return system[:idx] + system[idx+len(addendum):], true	8873		return system[:idx] + system[idx+len(addendum):], true
8886		}	8874		}
8887			8875
8888	-	// applyAutoSubagentsSystemPrompt appends (active=true) or strips	8876	+	// applyAutoSubagentsSystemPrompt swaps the prompt blocks owned by the
8889	-	// (active=false) the auto-subagents prompt blocks on the running agent.	8877	+	// auto-subagents setting on the running agent. The profile manifest belongs
8890	-	// The profile manifest and delegation guidance are managed together so	8878	+	// only to strict orchestration; disabled mode keeps on-demand guidance.
8891	-	// toggling auto-subagents never leaves the model with names but no tool.	8879	+	func (i *Interactive) applyAutoSubagentsSystemPrompt(orchestrating bool) {
8892	-	func (i *Interactive) applyAutoSubagentsSystemPrompt(active bool) {
8893		// i.mu is sufficient here: this path updates the existing agent's system	8880		// i.mu is sufficient here: this path updates the existing agent's system
8894		// prompt and managed addenda in place; it does not replace the agent or	8881		// prompt and managed addenda in place; it does not replace the agent or
8895		// its tool registry, so agentMu is not required.	8882		// its tool registry, so agentMu is not required.

@@ -8898,22 +8885,6 @@ func (i *Interactive) applyAutoSubagentsSystemPrompt(active bool) {
8898		if i.agent == nil {	8885		if i.agent == nil {
8899		return	8886		return
8900		}	8887		}
8901	-	addenda := autoSubagentsAddenda(i.cfg)
8902	-	if active {
8903	-	sys, _ := i.agent.PromptConfig()
8904	-	for _, addendum := range addenda {
8905	-	if containsAutoSubagentsAddendum(i.managedAutoSubagentsAddenda, addendum) {
8906	-	continue
8907	-	}
8908	-	if sys != "" && !strings.HasSuffix(sys, "\n\n") {
8909	-	sys += "\n\n"
8910	-	}
8911	-	sys += addendum
8912	-	i.managedAutoSubagentsAddenda = append(i.managedAutoSubagentsAddenda, addendum)
8913	-	}
8914	-	i.agent.SetSystemPrompt(sys)
8915	-	return
8916	-	}
8917			8888
8918		sys, _ := i.agent.PromptConfig()	8889		sys, _ := i.agent.PromptConfig()
8919		changed := false	8890		changed := false

@@ -8923,16 +8894,33 @@ func (i *Interactive) applyAutoSubagentsSystemPrompt(active bool) {
8923		changed = changed \|\| removed	8894		changed = changed \|\| removed
8924		}	8895		}
8925		i.managedAutoSubagentsAddenda = nil	8896		i.managedAutoSubagentsAddenda = nil
8926	-	if changed {	8897	+
8927	-	i.agent.SetSystemPrompt(strings.TrimRight(sys, "\n") + "\n")	8898	+	addenda := autoSubagentsAddenda(i.cfg, orchestrating)
			8899	+	if changed && len(addenda) > 0 {
			8900	+	sys = strings.TrimRight(sys, "\n")
8928		}	8901		}
			8902	+	for _, addendum := range addenda {
			8903	+	if sys != "" {
			8904	+	sys += "\n\n"
			8905	+	}
			8906	+	sys += addendum
			8907	+	i.managedAutoSubagentsAddenda = append(i.managedAutoSubagentsAddenda, addendum)
			8908	+	changed = true
			8909	+	}
			8910	+	if !changed {
			8911	+	return
			8912	+	}
			8913	+	if len(addenda) == 0 {
			8914	+	sys = strings.TrimRight(sys, "\n") + "\n"
			8915	+	}
			8916	+	i.agent.SetSystemPrompt(sys)
8929		}	8917		}
8930			8918
8931	-	// applyAutoSubagentsTool registers (active=true) or removes (active=false)	8919	+	// applyAutoSubagentsTool registers the canonical subagent tools whenever
8932	-	// the auto-subagent tools on the running agent so the model only sees them	8920	+	// launch-time policy permits them. Auto-subagents controls prompt behavior,
8933	-	// when /settings -> auto-subagents is enabled. Mirrors applyTelegramTools'	8921	+	// while the tools remain available for explicit user-requested delegation.
8934	-	// snapshot+mutate pattern so extension tools and /reload-ext additions	8922	+	// Mirrors applyTelegramTools' snapshot+mutate pattern so extension tools and
8935	-	// survive a toggle.	8923	+	// /reload-ext additions survive a settings change.
8936		func (i *Interactive) autoSubagentsAvailable() bool {	8924		func (i *Interactive) autoSubagentsAvailable() bool {
8937		return i.cfg.Supervisor != nil && autoSubagentsAnyToolAllowedConfig(i.cfg)	8925		return i.cfg.Supervisor != nil && autoSubagentsAnyToolAllowedConfig(i.cfg)
8938		}	8926		}

@@ -8998,17 +8986,11 @@ func (i *Interactive) autoSubagentsResumeToolAllowed() bool {
8998		return autoSubagentsResumeToolAllowedConfig(i.cfg)	8986		return autoSubagentsResumeToolAllowedConfig(i.cfg)
8999		}	8987		}
9000			8988
9001	-	func (i *Interactive) autoSubagentsEnabled() bool {
9002	-	i.mu.Lock()
9003	-	defer i.mu.Unlock()
9004	-	return i.autoSubagentsEnabledLocked()
9005	-	}
9006	-
9007		func (i *Interactive) autoSubagentsEnabledLocked() bool {	8989		func (i *Interactive) autoSubagentsEnabledLocked() bool {
9008		return i.cfg.AutoSubagentsEnabled != nil && *i.cfg.AutoSubagentsEnabled && i.autoSubagentsAvailable()	8990		return i.cfg.AutoSubagentsEnabled != nil && *i.cfg.AutoSubagentsEnabled && i.autoSubagentsAvailable()
9009		}	8991		}
9010			8992
9011	-	func (i *Interactive) applyAutoSubagentsTool(active bool) {	8993	+	func (i *Interactive) applyAutoSubagentsTool() {
9012		i.agentMu.Lock()	8994		i.agentMu.Lock()
9013		defer i.agentMu.Unlock()	8995		defer i.agentMu.Unlock()
9014		i.mu.Lock()	8996		i.mu.Lock()

@@ -9024,11 +9006,11 @@ func (i *Interactive) applyAutoSubagentsTool(active bool) {
9024		}	9006		}
9025		next[name] = t	9007		next[name] = t
9026		}	9008		}
9027	-	if active && i.autoSubagentsAvailable() {	9009	+	if i.autoSubagentsAvailable() {
9028		if i.autoSubagentsToolAllowed() {	9010		if i.autoSubagentsToolAllowed() {
9029		canonical := &tools.SubagentSpawnTool{	9011		canonical := &tools.SubagentSpawnTool{
9030		Supervisor: i.cfg.Supervisor,	9012		Supervisor: i.cfg.Supervisor,
9031	-	Enabled: func() bool { return i.autoSubagentsEnabled() },	9013	+	Enabled: func() bool { return true },
9032		DefaultModel: func() string { return i.cfg.Model },	9014		DefaultModel: func() string { return i.cfg.Model },
9033		DefaultProvider: func() string { return i.cfg.Provider },	9015		DefaultProvider: func() string { return i.cfg.Provider },
9034		DefaultReasoning: func() string { return i.cfg.Reasoning },	9016		DefaultReasoning: func() string { return i.cfg.Reasoning },

@@ -9040,14 +9022,14 @@ func (i *Interactive) applyAutoSubagentsTool(active bool) {
9040		if i.autoSubagentsStatusToolAllowed() {	9022		if i.autoSubagentsStatusToolAllowed() {
9041		statusTool := &tools.SubagentStatusTool{	9023		statusTool := &tools.SubagentStatusTool{
9042		Supervisor: i.cfg.Supervisor,	9024		Supervisor: i.cfg.Supervisor,
9043	-	Enabled: func() bool { return i.autoSubagentsEnabled() },	9025	+	Enabled: func() bool { return true },
9044		}	9026		}
9045		next[statusTool.Name()] = statusTool	9027		next[statusTool.Name()] = statusTool
9046		}	9028		}
9047		if i.autoSubagentsStopToolAllowed() {	9029		if i.autoSubagentsStopToolAllowed() {
9048		stopTool := &tools.SubagentStopTool{	9030		stopTool := &tools.SubagentStopTool{
9049		Supervisor: i.cfg.Supervisor,	9031		Supervisor: i.cfg.Supervisor,
9050	-	Enabled: func() bool { return i.autoSubagentsEnabled() },	9032	+	Enabled: func() bool { return true },
9051		OnStopRequested: i.TrackStoppedSubagentWorker,	9033		OnStopRequested: i.TrackStoppedSubagentWorker,
9052		}	9034		}
9053		next[stopTool.Name()] = stopTool	9035		next[stopTool.Name()] = stopTool

@@ -9055,7 +9037,7 @@ func (i *Interactive) applyAutoSubagentsTool(active bool) {
9055		if i.autoSubagentsResumeToolAllowed() {	9037		if i.autoSubagentsResumeToolAllowed() {
9056		resumeTool := &tools.SubagentResumeTool{	9038		resumeTool := &tools.SubagentResumeTool{
9057		Supervisor: i.cfg.Supervisor,	9039		Supervisor: i.cfg.Supervisor,
9058	-	Enabled: func() bool { return i.autoSubagentsEnabled() },	9040	+	Enabled: func() bool { return true },
9059		OnResumed: i.TrackResumedSubagentWorker,	9041		OnResumed: i.TrackResumedSubagentWorker,
9060		}	9042		}
9061		next[resumeTool.Name()] = resumeTool	9043		next[resumeTool.Name()] = resumeTool

M packages/agent/modes/interactive_render_test.go +28 -0


@@ -65,6 +65,34 @@ func TestLatestFrameSchedulerKeepsNewestRequest(t *testing.T) {
65	}	65		}
66	}	66		}
67		67
		68	+	func TestToolEventBurstUsesThrottledInvalidationPath(t *testing.T) {
		69	+	scheduler := newLatestFrameScheduler()
		70	+	i := &Interactive{
		71	+	dirty: make(chan struct{}, 1),
		72	+	toolCalls: make(map[string]*tui.ToolCallView),
		73	+	toolGate: make(map[string]int),
		74	+	}
		75	+	i.renderScheduler.Store(scheduler)
		76	+
		77	+	i.handleEventForPresentation(core.EvToolUseStart{ID: "call", Name: "bash"})
		78	+	i.handleEventForPresentation(core.EvToolUseArgs{ID: "call", Delta: `{"command":"pwd"}`})
		79	+	i.handleEventForPresentation(core.EvToolUseEnd{ID: "call"})
		80	+
		81	+	if got := len(scheduler.wake); got != 0 {
		82	+	t.Fatalf("tool events bypassed the main-loop redraw throttle: %d direct request", got)
		83	+	}
		84	+	select {
		85	+	case <-i.dirty:
		86	+	default:
		87	+	t.Fatal("tool events did not wake the throttled redraw path")
		88	+	}
		89	+	select {
		90	+	case <-i.dirty:
		91	+	t.Fatal("tool event burst queued more than one throttled redraw")
		92	+	default:
		93	+	}
		94	+	}
		95	+
68	func TestStableChatCacheTracksViewInvalidation(t *testing.T) {	96		func TestStableChatCacheTracksViewInvalidation(t *testing.T) {
69	i := &Interactive{	97		i := &Interactive{
70	view: &tui.View{	98		view: &tui.View{

M packages/agent/modes/session_dialog_test.go +8 -6

 	"github.com/bnema/zut/packages/tui"
 )
+const sessionDialogTestTimeout = 10 * time.Second
 func TestFormatSessionRowPlainSanitizesControlBytes(t *testing.T) {
 	row := formatSessionRowPlain(core.SessionSummary{
 		Provider:      "test\x1b]0;bad\a",
 			t.Fatalf("first load event = %+v, open %v; want sessionLoadStarted", event, ok)
 		}
 		d.ApplyLoad(event)
-	case <-time.After(time.Second):
+	case <-time.After(sessionDialogTestTimeout):
 		t.Fatal("timed out waiting for sessionLoadStarted")
 	}
 	select {
 	case <-entered:
-	case <-time.After(time.Second):
+	case <-time.After(sessionDialogTestTimeout):
 		t.Fatal("timed out waiting for the session worker")
 	}
 				t.Fatal("canceled load emitted sessionLoadFinished")
 			}
 			d.ApplyLoad(event)
-		case <-time.After(time.Second):
+		case <-time.After(sessionDialogTestTimeout):
 			t.Fatal("timed out waiting for canceled session load to close")
 		}
 	}
 			t.Fatalf("first load event = %+v, open %v; want sessionLoadStarted", event, ok)
 		}
 		d.ApplyLoad(event)
-	case <-time.After(time.Second):
+	case <-time.After(sessionDialogTestTimeout):
 		t.Fatal("timed out waiting for the first load to start")
 	}
 	select {
 	case <-entered:
-	case <-time.After(time.Second):
+	case <-time.After(sessionDialogTestTimeout):
 		t.Fatal("timed out waiting for the first worker")
 	}
 			t.Fatalf("third load event = %+v, open %v; want sessionLoadStarted after barrier", event, ok)
 		}
 		d.ApplyLoad(event)
-	case <-time.After(time.Second):
+	case <-time.After(sessionDialogTestTimeout):
 		t.Fatal("timed out waiting for third load after releasing the first")
 	}
 	cancelThird()

M packages/agent/modes/subagents_slash_test.go +13 -13


@@ -290,20 +290,20 @@ func TestRunSupervisorWaitReportsCompletionBeforeCancellation(t *testing.T) {
290		if err != nil {	290		if err != nil {
291		t.Fatal(err)	291		t.Fatal(err)
292		}	292		}
			293	+	watcherDone := make(chan struct{})
			294	+	iv.subagentsWaitWatcherDone = func() { close(watcherDone) }
293		iv.runSubagents(context.Background(), []string{"wait", a.ID})	295		iv.runSubagents(context.Background(), []string{"wait", a.ID})
294	-	deadline := time.After(time.Second)	296	+	select {
295	-	for {	297	+	case <-watcherDone:
296	-	iv.mu.Lock()	298	+	case <-time.After(5 * time.Second):
297	-	status := iv.statusOK	299	+	t.Fatal("timed out waiting for wait watcher to report completion")
298	-	iv.mu.Unlock()	300	+	}
299	-	if status == "completed "+a.ID {	301	+
300	-	return	302	+	iv.mu.Lock()
301	-	}	303	+	status := iv.statusOK
302	-	select {	304	+	iv.mu.Unlock()
303	-	case <-deadline:	305	+	if status != "completed "+a.ID {
304	-	t.Fatalf("wait did not report completion; status = %q", status)	306	+	t.Fatalf("wait completion status = %q; want %q", status, "completed "+a.ID)
305	-	case <-time.After(time.Millisecond):
306	-	}
307		}	307		}
308		}	308		}
309			309

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

 	return SaveConfig(cfg)
 }
-// AutoSubagentsEnabled reads the current auto-subagents flag from config.
+// AutoSubagentsEnabled reads whether the interactive primary agent runs in
-// The build/CLI startup path uses it when initially injecting
+// strict orchestrator mode. The canonical subagent tools remain available for
-// the auto-subagent tools into the tool registry; interactive mode mirrors
+// user-requested delegation and skill-mandated workflows when disabled.
-// the setting into the live tool registry when its settings toggle changes.
 func AutoSubagentsEnabled() bool {
 	cfg, err := LoadConfig()
 	if err != nil {
 // AutoSubagentsSystemAddendum is appended to the system prompt when
 // auto-subagents is enabled. It makes the interactive primary agent an
-// orchestrator while preserving the normal prompt and tools when disabled.
+// orchestrator.
 const AutoSubagentsSystemAddendum = `Auto-subagents are enabled. You are the primary-agent orchestrator, not an implementer.
 Delegate all implementation, debugging/testing, and code-review work to an appropriately named subagent profile, or to a clearly described general worker when no profile fits. Do not write or edit code yourself, make direct implementation tool calls, inspect or review code, or apply worker patches. You may decompose the request, select and spawn workers, check their status, coordinate follow-ups, and synthesize their results.
 When workers finish, use the host update's agent ID, status, task, optional error, and final response or tail to coordinate any follow-up and summarize the outcome. Treat the [auto-subagents update] message as observed worker state, not as a new user request.`
+// OnDemandSubagentsSystemAddendum keeps the canonical subagent tools
+// available without enabling proactive primary-agent orchestration.
+const OnDemandSubagentsSystemAddendum = `Subagent tools are available when the user asks you to delegate or an active skill workflow requires delegation. Use them only in those cases. Do not delegate proactively or switch into an orchestrator role; otherwise perform the work yourself.`
 // AutoSubagentsDelegationUnavailableAddendum explains why the strict
 // orchestrator contract still applies when launch-time policy withholds the
 // spawn tool.

M packages/agent/subagent_worker.go +161 -48

 // production; tests use the stubchild binary under
 // packages/agent/subagents/testdata/cmd/stubchild instead of the real model
 // loop.
+// workerTurnBudget is deliberately independent of the model loop: one
+// admitted message turn consumes one current-run and lifetime turn, while
+// retries, compaction, and provider/tool loops remain inside that turn.
+type workerTurnBudget struct {
+	sequence int
+	lifetime int
+	current  int
+}
+type sessionPersistenceState struct {
+	mu       sync.Mutex
+	errValue error
+}
+func (s *sessionPersistenceState) record(err error) {
+	if err == nil {
+		return
+	}
+	s.mu.Lock()
+	if s.errValue == nil {
+		s.errValue = err
+	}
+	s.mu.Unlock()
+}
+func (s *sessionPersistenceState) failed() bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.errValue != nil
+}
+func (s *sessionPersistenceState) err() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.errValue
+}
+func (b *workerTurnBudget) start(maxTurns int, newRun bool) (step, lifetime, current int, admitted bool) {
+	if newRun {
+		b.current = 0
+	}
+	b.sequence++
+	if maxTurns > 0 && b.current >= maxTurns {
+		return b.sequence, b.lifetime, b.current, false
+	}
+	b.lifetime++
+	b.current++
+	return b.sequence, b.lifetime, b.current, true
+}
 func runSubagentWorkerMode(ctx context.Context, args Args, version string) (runErr error) {
 	if args.SubagentWorker == "" {
 		return fmt.Errorf("--subagent-worker requires a socket path")
 	if err != nil {
 		return err
 	}
+	var sessionPersistence sessionPersistenceState
 	if sess != nil {
 		var providerName, model string
 		sess, ag, providerName, model, err = applyInitialSessionResume(ctx, args, r, extMgr, sess, ag)
 		}
 		r.Provider, r.Model = providerName, model
 		ag.OnToolResult = func(_ string, result core.ToolResult) { persistExtensionToolResult(extMgr, sess, result) }
+		// A prompt is acknowledged by the supervisor only after this callback
+		// has appended and synced the matching user message. This closes the
+		// crash window between accepting a follow-up and writing session.json.
+		ag.OnMessageAppended = func(message provider.Message) {
+			if err := sess.AppendMessage(message); err != nil {
+				sessionPersistence.record(err)
+				return
+			}
+			if err := sess.Sync(); err != nil {
+				sessionPersistence.record(err)
+			}
+		}
+		ag.OnUsage = func(usage provider.Usage) {
+			if err := sess.AppendUsage(usage, usage); err != nil {
+				sessionPersistence.record(err)
+			}
+		}
 		defer func() { runErr = joinSessionCloseError(runErr, sess) }()
 	}
 	announceSession(extMgr, sess)
 	em := newSubagentEmitter(os.Stdout, logMirror)
 	em.setProtocolIdentity(os.Getenv("ZUT_SUBAGENT_AGENT_ID"))
 	em.emit("agent.ready", map[string]any{
-		"version": version,
+		"version":           version,
-		"cwd":     r.CWD,
+		"cwd":               r.CWD,
-		"model":   r.Model,
+		"model":             r.Model,
+		"lifetime_turns":    args.SubagentLifetimeTurns,
+		"current_run_turns": args.SubagentRunTurns,
+		"max_turns":         args.SubagentMaxTurns,
 	})
 	// Heartbeats make a live-but-detached child distinguishable from a
 	// Keep a per-turn cancel so the "cancel" inbox message can interrupt
 	// an in-flight turn without tearing down the whole daemon.
 	var (
-		mu           sync.Mutex
+		mu       sync.Mutex
-		cancelFn     context.CancelFunc
+		cancelFn context.CancelFunc
-		busyTurn     bool
+		busyTurn bool
-		turnNo       = initialTurnNumber(os.Getenv("ZUT_SUBAGENT_EVENT_LOG"))
+		budget   = workerTurnBudget{
+			sequence: initialTurnNumber(os.Getenv("ZUT_SUBAGENT_EVENT_LOG")),
+			lifetime: args.SubagentLifetimeTurns,
+			current:  args.SubagentRunTurns,
+		}
 		turnWG       sync.WaitGroup
 		closing      bool
+		turnPending  bool
+		seenCommands = make(map[string]struct{})
 		shutdown     = make(chan struct{})
 		shutdownOnce sync.Once
 	)
 	maxOutputBytes, maxOutputLines := workerOutputLimits()
-	runOne := func(prompt string) {
+	runOne := func(prompt string, newRun bool, commandID string) {
 		mu.Lock()
 		// launchTurn admits the goroutine to turnWG before it starts so
 		// shutdown can join it. A shutdown can win the scheduling race
 		// after that admission but before this goroutine acquires mu; in
 		// that case do not start a new Prompt after waitForActiveTurn has
 		// declared the worker closing.
-		if closing {
+		if closing || busyTurn {
 			mu.Unlock()
+			em.emit("error", map[string]any{"code": "turn_rejected", "reason": "busy", "command_id": commandID, "message": "worker is busy"})
 			return
 		}
-		if args.SubagentMaxTurns > 0 && turnNo >= args.SubagentMaxTurns {
+		busyTurn = true
-			// Consume a unique rejected attempt so repeated prompts after
+		turnPending = false
-			// the limit cannot reuse the same turn id in the event log.
+		step, lifetime, currentRun, admitted := budget.start(args.SubagentMaxTurns, newRun)
-			turnNo++
+		if !admitted {
-			step := turnNo
+			busyTurn = false
 			mu.Unlock()
 			turnID := fmt.Sprintf("turn-%d", step)
-			errPayload := map[string]any{"code": "max_turns", "message": "maximum subagent turns reached"}
+			errPayload := map[string]any{"code": "turn_rejected", "reason": "max_turns", "command_id": commandID, "message": "maximum subagent turns reached"}
+			em.emit("error", errPayload)
 			em.emit("turn.result", map[string]any{"status": "failed", "turn_id": turnID, "error": errPayload})
 			em.emit("turn.failed", map[string]any{"turn_id": turnID, "error": errPayload})
 			em.emit("turn_end", map[string]any{"step": step, "turn_id": turnID, "error": errPayload["message"]})
-			em.emit("agent.idle", map[string]any{"turn_id": turnID})
+			// Max-turn rejection ends the current run, but the worker remains
-			return
+			// alive and can accept a queued follow-up as a fresh run.
-		}
+			em.emit("agent.idle", map[string]any{
-		if busyTurn {
+				"turn_id":           turnID,
-			// Drop concurrent turns rather than queuing. The
+				"lifetime_turns":    lifetime,
-			// supervisor protocol assumes one outstanding turn per
+				"current_run_turns": currentRun,
-			// agent; if a user really wants to interrupt and start
+			})
-			// another, they should send "cancel" first.
-			mu.Unlock()
-			em.emit("error", map[string]any{"message": "agent busy; send 'cancel' first"})
 			return
 		}
-		busyTurn = true
+		turnID := fmt.Sprintf("turn-%d", step)
-		turnNo++
-		step := turnNo
 		c, cancel := context.WithCancel(ctx)
 		cancelFn = cancel
 		mu.Unlock()
-		turnID := fmt.Sprintf("turn-%d", step)
+		turnStarted := false
-		em.emit("turn.started", map[string]any{"step": step, "turn_id": turnID})
 		sink := func(ev core.AgentEvent) {
-			em.emit(ev.Type(), subagentEventData(ev))
+			data := subagentEventData(ev)
+			if ev.Type() == "user_message" && !turnStarted {
+				// Prompt invokes OnMessageAppended before delivering this sink
+				// event, so the session row is durable before the lifecycle
+				// acknowledgement is written.
+				em.emit(ev.Type(), data)
+				if !sessionPersistence.failed() {
+					em.emit("turn.started", map[string]any{"step": step, "turn_id": turnID, "command_id": commandID, "lifetime_turns": lifetime, "current_run_turns": currentRun})
+					turnStarted = true
+				}
+				return
+			}
+			if ev.Type() == "turn_start" {
+				// A provider/model-loop turn is nested inside the one delegated
+				// message turn admitted above. Mark it on the wire so the
+				// supervisor cannot mistake it for a new worker turn.
+				data["nested_turn"] = true
+			}
+			em.emit(ev.Type(), data)
 		}
 		baseline := workerTranscriptState{
 			AutoCompactThreshold: cfg.AutoCompactThreshold,
 		})
 		output := finalAssistantText(ag.Messages()[recovery.OutputStart:])
-		if persistErr := persistWorkerTranscript(c, ag, sess, recovery.OutputStart, recovery.Compacted, baseline); persistErr != nil {
+		// Message and usage callbacks persist ordinary turns incrementally. A
-			if err != nil {
+		// compacted turn still needs one atomic replacement checkpoint so the
-				err = errors.Join(err, persistErr)
+		// durable transcript cannot mix generations.
-			} else {
+		if recovery.Compacted || ag.OnMessageAppended == nil {
-				err = persistErr
+			if persistErr := persistWorkerTranscript(c, ag, sess, recovery.OutputStart, recovery.Compacted, baseline); persistErr != nil {
+				if err != nil {
+					err = errors.Join(err, persistErr)
+				} else {
+					err = persistErr
+				}
 			}
 		}
+		if sessionErr := sessionPersistence.err(); err == nil && sessionErr != nil {
+			err = sessionErr
+		}
 		resultStatus := "succeeded"
 		if err != nil {
 		// The supervisor treats agent.idle as permission to start a follow-up.
 		// Publish it only after the busy gate has opened, otherwise a manager
 		// can send a turn that the inbox loop drops as still busy.
-		em.emit("agent.idle", map[string]any{"turn_id": turnID})
+		em.emit("agent.idle", map[string]any{"turn_id": turnID, "lifetime_turns": lifetime, "current_run_turns": currentRun})
 	}
-	launchTurn := func(prompt string) {
+	launchTurn := func(prompt string, newRun bool, commandID string) bool {
 		mu.Lock()
-		if closing {
+		if closing || busyTurn || turnPending {
 			mu.Unlock()
-			return
+			em.emit("error", map[string]any{"code": "turn_rejected", "reason": "busy", "command_id": commandID, "message": "worker is busy"})
+			return false
 		}
-		// Register the goroutine before launching it. Shutdown can then
+		// Reserve the worker before launching the goroutine. A second command
-		// close the gate and wait for every turn that was admitted, even
+		// cannot be accepted in the gap before runOne acquires mu.
-		// if runOne has not acquired mu and set busyTurn yet.
+		turnPending = true
 		turnWG.Add(1)
 		mu.Unlock()
 		go func() {
 			defer turnWG.Done()
-			runOne(prompt)
+			runOne(prompt, newRun, commandID)
 		}()
+		return true
 	}
 	waitForActiveTurn := func(cancel bool) {
 	// "starts working" the moment it boots, matching what users
 	// expect from `/subagents new <task>`.
 	if args.Prompt != "" {
-		launchTurn(args.Prompt)
+		launchTurn(args.Prompt, false, "")
 	}
 	// Inbox loop: one supervisor message at a time. We don't spawn
 			case subagents.CommandTurnStart:
 				var payload subagents.TurnStartPayload
 				if err := command.DecodePayload(&payload); err != nil {
-					em.emit("error", map[string]any{"message": "invalid turn.start payload"})
+					em.emit("error", map[string]any{"code": "turn_rejected", "reason": "invalid_payload", "command_id": command.MessageID, "message": "invalid turn.start payload"})
 					continue
 				}
-				launchTurn(payload.Prompt)
+				mu.Lock()
+				_, duplicate := seenCommands[command.MessageID]
+				mu.Unlock()
+				if duplicate && command.MessageID != "" {
+					continue
+				}
+				if launchTurn(payload.Prompt, payload.NewRun, command.MessageID) && command.MessageID != "" {
+					mu.Lock()
+					seenCommands[command.MessageID] = struct{}{}
+					mu.Unlock()
+				}
 			default:
 				// Unknown commands are rejected rather than interpreted as
 				// child-originated control requests.
 	}
 	maxStep := 0
 	for _, ev := range events {
+		if !subagents.IsDelegatedTurnStart(ev) {
+			continue
+		}
 		if step, ok := ev.Data["step"].(float64); ok && int(step) > maxStep {
 			maxStep = int(step)
 		}

M packages/agent/subagent_worker_test.go +46 -0


@@ -857,3 +857,49 @@ func TestSupervisorEmitterStdoutShapeMatchesSupervisorParser(t *testing.T) {
857	t.Errorf("payload step field missing or wrong: %v", object["payload"])	857		t.Errorf("payload step field missing or wrong: %v", object["payload"])
858	}	858		}
859	}	859		}
		860	+
		861	+	func TestInitialTurnNumberIgnoresNestedProviderTurns(t *testing.T) {
		862	+	path := filepath.Join(t.TempDir(), "events.jsonl")
		863	+	log, err := subagents.OpenEventLog(path)
		864	+	if err != nil {
		865	+	t.Fatal(err)
		866	+	}
		867	+	if err := log.Append(subagents.NewEvent(subagents.EventTurnStarted, map[string]any{
		868	+	"step": float64(1), "lifetime_turns": 1, "current_run_turns": 1,
		869	+	})); err != nil {
		870	+	t.Fatal(err)
		871	+	}
		872	+	if err := log.Append(subagents.NewEvent(subagents.EventTurnStarted, map[string]any{
		873	+	"step": float64(99), "nested_turn": true,
		874	+	})); err != nil {
		875	+	t.Fatal(err)
		876	+	}
		877	+	if err := log.Close(); err != nil {
		878	+	t.Fatal(err)
		879	+	}
		880	+	if got := initialTurnNumber(path); got != 1 {
		881	+	t.Fatalf("initial turn number = %d, want 1", got)
		882	+	}
		883	+	}
		884	+
		885	+	func TestWorkerTurnBudgetFreshAllowanceOnlyForExplicitRun(t *testing.T) {
		886	+	var budget workerTurnBudget
		887	+
		888	+	if _, lifetime, current, admitted := budget.start(2, false); !admitted \|\| lifetime != 1 \|\| current != 1 {
		889	+	t.Fatalf("first turn = (%d, %d, %v), want (1, 1, true)", lifetime, current, admitted)
		890	+	}
		891	+	// Provider retries, model loops, and compaction stay inside the admitted
		892	+	// turn and therefore do not call start or consume another allowance.
		893	+	if budget.lifetime != 1 \|\| budget.current != 1 {
		894	+	t.Fatalf("nested work changed budget to (lifetime=%d, current=%d)", budget.lifetime, budget.current)
		895	+	}
		896	+	if _, lifetime, current, admitted := budget.start(2, false); !admitted \|\| lifetime != 2 \|\| current != 2 {
		897	+	t.Fatalf("second turn = (%d, %d, %v), want (2, 2, true)", lifetime, current, admitted)
		898	+	}
		899	+	if _, lifetime, current, admitted := budget.start(2, false); admitted \|\| lifetime != 2 \|\| current != 2 {
		900	+	t.Fatalf("exhausted turn = (%d, %d, %v), want (2, 2, false)", lifetime, current, admitted)
		901	+	}
		902	+	if _, lifetime, current, admitted := budget.start(2, true); !admitted \|\| lifetime != 3 \|\| current != 1 {
		903	+	t.Fatalf("explicit resumed turn = (%d, %d, %v), want (3, 1, true)", lifetime, current, admitted)
		904	+	}
		905	+	}

A packages/agent/subagents/ack_test.go +65 -0

@@ -0,0 +1,65 @@
	1	+	package subagents
	2	+
	3	+	import (
	4	+	"testing"
	5	+	"time"
	6	+	)
	7	+
	8	+	func TestResumePromptAcknowledgementRequiresDurableUserMessageAndTurnStart(t *testing.T) {
	9	+	acceptedAt := time.Now().Add(-time.Second)
	10	+	prompt := "follow-up prompt"
	11	+	user := NewEvent("user_message", map[string]any{
	12	+	"content": []any{map[string]any{"type": "text", "text": prompt}},
	13	+	})
	14	+	started := NewEvent(EventTurnStarted, map[string]any{
	15	+	"lifetime_turns": 2,
	16	+	"current_run_turns": 1,
	17	+	})
	18	+
	19	+	if resumePromptAcknowledged([]Event{started}, prompt, acceptedAt) {
	20	+	t.Fatal("turn.started alone acknowledged a pending prompt")
	21	+	}
	22	+	if resumePromptAcknowledged([]Event{user}, prompt, acceptedAt) {
	23	+	t.Fatal("crash point after durable user message acknowledged before turn.started")
	24	+	}
	25	+	if !resumePromptAcknowledged([]Event{user, started}, prompt, acceptedAt) {
	26	+	t.Fatal("matching durable user message followed by delegated turn.started was not acknowledged")
	27	+	}
	28	+	}
	29	+
	30	+	func TestResumePromptAcknowledgementIgnoresNestedTurnStart(t *testing.T) {
	31	+	acceptedAt := time.Now().Add(-time.Second)
	32	+	prompt := "follow-up prompt"
	33	+	user := NewEvent("user_message", map[string]any{
	34	+	"content": []any{map[string]any{"type": "text", "text": prompt}},
	35	+	})
	36	+	nested := NewEvent(EventTurnStarted, map[string]any{"nested_turn": true})
	37	+	if resumePromptAcknowledged([]Event{user, nested}, prompt, acceptedAt) {
	38	+	t.Fatal("nested turn.started acknowledged a pending delegated prompt")
	39	+	}
	40	+	}
	41	+
	42	+	func TestResumePromptAcknowledgementIgnoresStaleMatchingUserMessage(t *testing.T) {
	43	+	acceptedAt := time.Now()
	44	+	prompt := "follow-up prompt"
	45	+	user := NewEvent("user_message", map[string]any{
	46	+	"content": []any{map[string]any{"type": "text", "text": prompt}},
	47	+	})
	48	+	user.Time = acceptedAt.Add(-time.Millisecond)
	49	+	started := NewEvent(EventTurnStarted, map[string]any{"lifetime_turns": 2, "current_run_turns": 1})
	50	+	if resumePromptAcknowledged([]Event{user, started}, prompt, acceptedAt) {
	51	+	t.Fatal("stale matching user message acknowledged a pending prompt")
	52	+	}
	53	+	}
	54	+
	55	+	func TestResumePromptAcknowledgementIgnoresAmbiguousUserMessage(t *testing.T) {
	56	+	acceptedAt := time.Now().Add(-time.Second)
	57	+	prompt := "follow-up prompt"
	58	+	user := NewEvent("user_message", map[string]any{
	59	+	"content": []any{map[string]any{"type": "text", "text": "older prompt"}},
	60	+	})
	61	+	started := NewEvent(EventTurnStarted, map[string]any{"lifetime_turns": 2, "current_run_turns": 1})
	62	+	if resumePromptAcknowledged([]Event{user, started}, prompt, acceptedAt) {
	63	+	t.Fatal("ambiguous user message acknowledged a pending prompt")
	64	+	}
	65	+	}

M packages/agent/subagents/agent.go +377 -43


@@ -7,6 +7,8 @@ import (
7		"strings"	7		"strings"
8		"sync"	8		"sync"
9		"time"	9		"time"
			10	+
			11	+	"github.com/google/uuid"
10		)	12		)
11			13
12		// Agent is one supervised task. Public fields are immutable after	14		// Agent is one supervised task. Public fields are immutable after

@@ -17,6 +19,18 @@ type turnEndNotice struct {
17		errMsg string	19		errMsg string
18		}	20		}
19			21
			22	+	type queuedResumePrompt struct {
			23	+	Prompt string `json:"prompt"`
			24	+	AcceptedAt time.Time `json:"accepted_at"`
			25	+	CommandID string `json:"command_id,omitempty"`
			26	+	}
			27	+
			28	+	type resumePromptSnapshot struct {
			29	+	Prompt string
			30	+	AcceptedAt time.Time
			31	+	CommandID string
			32	+	}
			33	+
20		type Agent struct {	34		type Agent struct {
21		ID string	35		ID string
22		Task string	36		Task string

@@ -36,6 +50,14 @@ type Agent struct {
36		WorkspaceBase string	50		WorkspaceBase string
37		WorkspaceCapture CaptureMode	51		WorkspaceCapture CaptureMode
38		MaxTurns int	52		MaxTurns int
			53	+
			54	+	// LifetimeTurns counts every accepted message turn for this worker across
			55	+	// all explicit runs. CurrentRunTurns resets only when an explicit
			56	+	// subagent_resume follow-up starts a new run; retries, model loops,
			57	+	// compaction, and cancellation do not reset it.
			58	+	LifetimeTurns int
			59	+	CurrentRunTurns int
			60	+
39		// Timeout is the effective per-agent lifetime, persisted so a resumed	61		// Timeout is the effective per-agent lifetime, persisted so a resumed
40		// worker keeps the timeout selected at its spawn boundary.	62		// worker keeps the timeout selected at its spawn boundary.
41		Timeout time.Duration	63		Timeout time.Duration

@@ -80,12 +102,15 @@ type Agent struct {
80		// Not persisted — every Resume sets it explicitly.	102		// Not persisted — every Resume sets it explicitly.
81		Resuming bool	103		Resuming bool
82			104
83	-	// resumePromptText is an optional manager follow-up passed to a resumed	105	+	// resumePromptText is the manager follow-up currently handed to the
84	-	// child as its initial prompt. It remains in durable metadata until the	106	+	// child. It remains in durable metadata until the child reports
85	-	// child reports turn.started, so a host exit while the worker is queued	107	+	// turn.started, so a host exit while the worker is queued cannot lose it.
86	-	// cannot lose it. Access it through ResumePromptInfo.	108	+	// Additional follow-ups accepted while the child is busy stay in
87	-	resumePromptText string	109	+	// resumePromptQueue until the next agent idle turn.
88	-	resumePromptAt time.Time	110	+	resumePromptText string
			111	+	resumePromptAt time.Time
			112	+	resumePromptID string
			113	+	resumePromptQueue []queuedResumePrompt
89			114
90		// InboxPath is the unix socket the child agent listens on for	115		// InboxPath is the unix socket the child agent listens on for
91		// follow-up prompts and control messages. The supervisor opens	116		// follow-up prompts and control messages. The supervisor opens

@@ -116,16 +141,20 @@ type Agent struct {
116		// Supervisor.Spawn so callers do not need to manage the socket directly.	141		// Supervisor.Spawn so callers do not need to manage the socket directly.
117		inbox *Inbox	142		inbox *Inbox
118			143
119	-	mu sync.Mutex	144	+	mu sync.Mutex
120	-	status Status	145	+	status Status
121	-	activity string	146	+	activity string
122	-	transcript []string	147	+	transcript []string
123	-	lastAssistant string	148	+	lastAssistant string
124	-	finished time.Time	149	+	streamingAssistantText string
125	-	lastErr error	150	+	streamingAssistantTruncated bool
126	-	transcriptLoaded bool	151	+	streamingAssistantStart int
127	-	legacyEventState bool	152	+	streamingAssistantLines int
128	-	transcriptMu sync.Mutex	153	+	finished time.Time
			154	+	lastErr error
			155	+	transcriptLoaded bool
			156	+	legacyEventState bool
			157	+	transcriptMu sync.Mutex
129			158
130		lifecycleMu sync.Mutex	159		lifecycleMu sync.Mutex
131		processState ProcessState	160		processState ProcessState

@@ -142,10 +171,12 @@ type Agent struct {
142		outputTruncated bool	171		outputTruncated bool
143		maxOutputBytes int	172		maxOutputBytes int
144		maxOutputLines int	173		maxOutputLines int
145	-	persistFn func(*Agent)	174	+	persistFn func(*Agent) error
			175	+	persistMu sync.Mutex
146		stateDir string	176		stateDir string
147		workspaceCleanup func() error	177		workspaceCleanup func() error
148		workspaceCapture func() (WorkspaceCapture, error)	178		workspaceCapture func() (WorkspaceCapture, error)
			179	+	onTurnIdle func()
149			180
150		// OnTurnEnd, if set, fires once per prompt-level turn_end event	181		// OnTurnEnd, if set, fires once per prompt-level turn_end event
151		// emitted by the subagent daemon wrapper. Provider/tool-loop	182		// emitted by the subagent daemon wrapper. Provider/tool-loop

@@ -230,6 +261,66 @@ func (a *Agent) AttemptValue() int {
230		return a.Attempt	261		return a.Attempt
231		}	262		}
232			263
			264	+	// LifetimeTurnsValue returns the number of accepted message turns across all
			265	+	// explicit runs of this worker.
			266	+	func (a *Agent) LifetimeTurnsValue() int {
			267	+	a.lifecycleMu.Lock()
			268	+	defer a.lifecycleMu.Unlock()
			269	+	return a.LifetimeTurns
			270	+	}
			271	+
			272	+	// CurrentRunTurnsValue returns the number of accepted message turns in the
			273	+	// current explicit run.
			274	+	func (a *Agent) CurrentRunTurnsValue() int {
			275	+	a.lifecycleMu.Lock()
			276	+	defer a.lifecycleMu.Unlock()
			277	+	return a.CurrentRunTurns
			278	+	}
			279	+
			280	+	func (a *Agent) setTurnCounts(lifetime, currentRun int) {
			281	+	if lifetime < 0 {
			282	+	lifetime = 0
			283	+	}
			284	+	if currentRun < 0 {
			285	+	currentRun = 0
			286	+	}
			287	+	a.lifecycleMu.Lock()
			288	+	a.LifetimeTurns = lifetime
			289	+	a.CurrentRunTurns = currentRun
			290	+	a.updatedAt = time.Now()
			291	+	a.lifecycleMu.Unlock()
			292	+	}
			293	+
			294	+	func (a *Agent) incrementTurnCounts() (lifetime, currentRun int) {
			295	+	a.lifecycleMu.Lock()
			296	+	a.LifetimeTurns++
			297	+	a.CurrentRunTurns++
			298	+	a.updatedAt = time.Now()
			299	+	lifetime = a.LifetimeTurns
			300	+	currentRun = a.CurrentRunTurns
			301	+	a.lifecycleMu.Unlock()
			302	+	return lifetime, currentRun
			303	+	}
			304	+
			305	+	func (a *Agent) resetCurrentRunTurns() (previous int) {
			306	+	a.lifecycleMu.Lock()
			307	+	previous = a.CurrentRunTurns
			308	+	a.CurrentRunTurns = 0
			309	+	a.updatedAt = time.Now()
			310	+	a.lifecycleMu.Unlock()
			311	+	return previous
			312	+	}
			313	+
			314	+	func (a *Agent) setCurrentRunTurns(currentRun int) {
			315	+	if currentRun < 0 {
			316	+	currentRun = 0
			317	+	}
			318	+	a.lifecycleMu.Lock()
			319	+	a.CurrentRunTurns = currentRun
			320	+	a.updatedAt = time.Now()
			321	+	a.lifecycleMu.Unlock()
			322	+	}
			323	+
233		// ProcessPIDValue returns the current worker pid, when known.	324		// ProcessPIDValue returns the current worker pid, when known.
234		func (a *Agent) ProcessPIDValue() int {	325		func (a *Agent) ProcessPIDValue() int {
235		a.lifecycleMu.Lock()	326		a.lifecycleMu.Lock()

@@ -400,13 +491,45 @@ func (a *Agent) ResumePromptInfo() (string, time.Time) {
400		return a.resumePromptText, a.resumePromptAt	491		return a.resumePromptText, a.resumePromptAt
401		}	492		}
402			493
403	-	func (a *Agent) setResumePrompt(prompt string, acceptedAt time.Time) (string, time.Time) {	494	+	func (a *Agent) setResumePrompt(prompt string, acceptedAt time.Time) resumePromptSnapshot {
404		a.mu.Lock()	495		a.mu.Lock()
405		defer a.mu.Unlock()	496		defer a.mu.Unlock()
406	-	previousPrompt, previousAcceptedAt := a.resumePromptText, a.resumePromptAt	497	+	previous := resumePromptSnapshot{
			498	+	Prompt: a.resumePromptText,
			499	+	AcceptedAt: a.resumePromptAt,
			500	+	CommandID: a.resumePromptID,
			501	+	}
407		a.resumePromptText = prompt	502		a.resumePromptText = prompt
408		a.resumePromptAt = acceptedAt	503		a.resumePromptAt = acceptedAt
409	-	return previousPrompt, previousAcceptedAt	504	+	a.resumePromptID = uuid.NewString()
			505	+	return previous
			506	+	}
			507	+
			508	+	func (a *Agent) restoreResumePrompt(previous resumePromptSnapshot) {
			509	+	a.mu.Lock()
			510	+	defer a.mu.Unlock()
			511	+	a.resumePromptText = previous.Prompt
			512	+	a.resumePromptAt = previous.AcceptedAt
			513	+	a.resumePromptID = previous.CommandID
			514	+	if a.resumePromptText != "" && a.resumePromptID == "" {
			515	+	a.resumePromptID = uuid.NewString()
			516	+	}
			517	+	}
			518	+
			519	+	func (a *Agent) resumePromptState() resumePromptSnapshot {
			520	+	a.mu.Lock()
			521	+	defer a.mu.Unlock()
			522	+	return resumePromptSnapshot{
			523	+	Prompt: a.resumePromptText,
			524	+	AcceptedAt: a.resumePromptAt,
			525	+	CommandID: a.resumePromptID,
			526	+	}
			527	+	}
			528	+
			529	+	func (a *Agent) resumePromptCommandID() string {
			530	+	a.mu.Lock()
			531	+	defer a.mu.Unlock()
			532	+	return a.resumePromptID
410		}	533		}
411			534
412		func (a *Agent) clearResumePrompt() bool {	535		func (a *Agent) clearResumePrompt() bool {

@@ -417,9 +540,110 @@ func (a *Agent) clearResumePrompt() bool {
417		}	540		}
418		a.resumePromptText = ""	541		a.resumePromptText = ""
419		a.resumePromptAt = time.Time{}	542		a.resumePromptAt = time.Time{}
			543	+	a.resumePromptID = ""
			544	+	return true
			545	+	}
			546	+
			547	+	func (a *Agent) queueResumePrompt(prompt string, acceptedAt time.Time) string {
			548	+	commandID := uuid.NewString()
			549	+	a.mu.Lock()
			550	+	a.resumePromptQueue = append(a.resumePromptQueue, queuedResumePrompt{Prompt: prompt, AcceptedAt: acceptedAt, CommandID: commandID})
			551	+	a.mu.Unlock()
			552	+	return commandID
			553	+	}
			554	+
			555	+	func (a *Agent) removeQueuedResumePrompt(commandID string) bool {
			556	+	if commandID == "" {
			557	+	return false
			558	+	}
			559	+	a.mu.Lock()
			560	+	defer a.mu.Unlock()
			561	+	for i := len(a.resumePromptQueue) - 1; i >= 0; i-- {
			562	+	if a.resumePromptQueue[i].CommandID == commandID {
			563	+	a.resumePromptQueue = append(a.resumePromptQueue[:i], a.resumePromptQueue[i+1:]...)
			564	+	return true
			565	+	}
			566	+	}
			567	+	return false
			568	+	}
			569	+
			570	+	func (a *Agent) resumePromptQueueSnapshot() []queuedResumePrompt {
			571	+	a.mu.Lock()
			572	+	defer a.mu.Unlock()
			573	+	return append([]queuedResumePrompt(nil), a.resumePromptQueue...)
			574	+	}
			575	+
			576	+	func (a *Agent) hasQueuedResumePrompt() bool {
			577	+	a.mu.Lock()
			578	+	defer a.mu.Unlock()
			579	+	return len(a.resumePromptQueue) != 0
			580	+	}
			581	+
			582	+	// startQueuedResumePrompt moves the oldest active follow-up into the
			583	+	// in-flight prompt slot. The caller must persist the returned state before
			584	+	// delivering the command so a host exit cannot lose the prompt.
			585	+	func (a *Agent) startQueuedResumePrompt() (string, time.Time, string, bool) {
			586	+	a.mu.Lock()
			587	+	defer a.mu.Unlock()
			588	+	if a.resumePromptText != "" \|\| len(a.resumePromptQueue) == 0 {
			589	+	return "", time.Time{}, "", false
			590	+	}
			591	+	queued := a.resumePromptQueue[0]
			592	+	a.resumePromptQueue = a.resumePromptQueue[1:]
			593	+	a.resumePromptText = queued.Prompt
			594	+	a.resumePromptAt = queued.AcceptedAt
			595	+	a.resumePromptID = queued.CommandID
			596	+	if a.resumePromptID == "" {
			597	+	a.resumePromptID = uuid.NewString()
			598	+	}
			599	+	return queued.Prompt, queued.AcceptedAt, a.resumePromptID, true
			600	+	}
			601	+
			602	+	func (a *Agent) restoreResumePromptToQueue(prompt string, acceptedAt time.Time) bool {
			603	+	a.mu.Lock()
			604	+	defer a.mu.Unlock()
			605	+	if a.resumePromptText != prompt \|\| !a.resumePromptAt.Equal(acceptedAt) {
			606	+	return false
			607	+	}
			608	+	commandID := a.resumePromptID
			609	+	if commandID == "" {
			610	+	commandID = uuid.NewString()
			611	+	}
			612	+	a.resumePromptText = ""
			613	+	a.resumePromptAt = time.Time{}
			614	+	a.resumePromptID = ""
			615	+	a.resumePromptQueue = append([]queuedResumePrompt{{Prompt: prompt, AcceptedAt: acceptedAt, CommandID: commandID}}, a.resumePromptQueue...)
420		return true	616		return true
421		}	617		}
422			618
			619	+	func (a *Agent) rejectActiveResumePrompt() bool {
			620	+	a.mu.Lock()
			621	+	defer a.mu.Unlock()
			622	+	if a.resumePromptText == "" {
			623	+	return false
			624	+	}
			625	+	a.resumePromptQueue = append([]queuedResumePrompt{{Prompt: a.resumePromptText, AcceptedAt: a.resumePromptAt, CommandID: a.resumePromptID}}, a.resumePromptQueue...)
			626	+	a.resumePromptText = ""
			627	+	a.resumePromptAt = time.Time{}
			628	+	a.resumePromptID = ""
			629	+	return true
			630	+	}
			631	+
			632	+	func (a *Agent) setOnTurnIdle(fn func()) {
			633	+	a.mu.Lock()
			634	+	a.onTurnIdle = fn
			635	+	a.mu.Unlock()
			636	+	}
			637	+
			638	+	func (a *Agent) notifyTurnIdle() {
			639	+	a.mu.Lock()
			640	+	fn := a.onTurnIdle
			641	+	a.mu.Unlock()
			642	+	if fn != nil {
			643	+	fn()
			644	+	}
			645	+	}
			646	+
423		func (a *Agent) SetOnTurnEnd(fn func(step int, errMsg string)) {	647		func (a *Agent) SetOnTurnEnd(fn func(step int, errMsg string)) {
424		a.mu.Lock()	648		a.mu.Lock()
425		a.OnTurnEnd = fn	649		a.OnTurnEnd = fn

@@ -433,6 +657,20 @@ func (a *Agent) SetOnTurnEnd(fn func(step int, errMsg string)) {
433		}	657		}
434		}	658		}
435			659
			660	+	func (a *Agent) recordPersistenceError(err error) {
			661	+	if a == nil \|\| err == nil {
			662	+	return
			663	+	}
			664	+	a.mu.Lock()
			665	+	if a.lastErr == nil {
			666	+	a.lastErr = fmt.Errorf("subagent metadata persistence: %w", err)
			667	+	}
			668	+	if a.status != StatusDone && a.status != StatusFailed && a.status != StatusKilled {
			669	+	a.activity = "metadata error: " + truncate(err.Error(), 120)
			670	+	}
			671	+	a.mu.Unlock()
			672	+	}
			673	+
436		func (a *Agent) setActivity(msg string) {	674		func (a *Agent) setActivity(msg string) {
437		a.mu.Lock()	675		a.mu.Lock()
438		a.activity = strings.TrimSpace(msg)	676		a.activity = strings.TrimSpace(msg)

@@ -441,25 +679,114 @@ func (a *Agent) setActivity(msg string) {
441		}	679		}
442			680
443		func (a *Agent) appendTranscript(chunk string) {	681		func (a *Agent) appendTranscript(chunk string) {
444	-	a.appendTranscriptLocked(chunk, "", false)	682	+	a.appendTranscriptChunk(chunk, "", false)
445		}	683		}
446			684
447		func (a *Agent) appendUserMessage(text string) {	685		func (a *Agent) appendUserMessage(text string) {
448	-	a.appendTranscriptLocked(text, "user: ", false)	686	+	a.appendTranscriptChunk(text, "user: ", false)
449		}	687		}
450			688
451		func (a *Agent) appendAssistantMessage(text string) {	689		func (a *Agent) appendAssistantMessage(text string) {
452	-	a.appendTranscriptLocked(text, "", true)	690	+	if text == "" {
			691	+	return
			692	+	}
			693	+	a.mu.Lock()
			694	+	if a.streamingAssistantText != "" {
			695	+	a.replaceStreamingAssistantLocked(text)
			696	+	a.clearStreamingAssistantLocked()
			697	+	} else {
			698	+	a.appendTranscriptLinesLocked(text, "", true)
			699	+	a.boundTranscriptLocked()
			700	+	}
			701	+	a.mu.Unlock()
			702	+	a.markActivity(time.Now())
			703	+	}
			704	+
			705	+	// appendAssistantDelta exposes an in-progress assistant response in the
			706	+	// dashboard without duplicating it when the final assistant_message arrives.
			707	+	// The JSONL event log remains the durable source; this maintains its live and
			708	+	// replayed in-memory projection.
			709	+	func (a *Agent) appendAssistantDelta(text string) {
			710	+	if text == "" {
			711	+	return
			712	+	}
			713	+	a.mu.Lock()
			714	+	if !a.streamingAssistantTruncated {
			715	+	value := a.streamingAssistantText + text
			716	+	byteCap, lineCap := a.outputLimits()
			717	+	a.streamingAssistantText = boundInlineText(value, byteCap, lineCap)
			718	+	a.streamingAssistantTruncated = a.streamingAssistantText != value
			719	+	}
			720	+	a.replaceStreamingAssistantLocked(a.streamingAssistantText)
			721	+	a.mu.Unlock()
			722	+	a.markActivity(time.Now())
			723	+	}
			724	+
			725	+	func (a *Agent) appendTranscriptChunk(chunk, linePrefix string, assistant bool) {
			726	+	if strings.TrimRight(chunk, "\n") == "" {
			727	+	return
			728	+	}
			729	+	a.mu.Lock()
			730	+	a.appendTranscriptLinesLocked(chunk, linePrefix, assistant)
			731	+	a.boundTranscriptLocked()
			732	+	a.mu.Unlock()
			733	+	a.markActivity(time.Now())
453		}	734		}
454			735
455	-	func (a *Agent) appendTranscriptLocked(chunk, linePrefix string, assistant bool) {	736	+	func (a *Agent) resetStreamingAssistant() {
			737	+	a.mu.Lock()
			738	+	a.clearStreamingAssistantLocked()
			739	+	a.mu.Unlock()
			740	+	}
			741	+
			742	+	func (a *Agent) replaceStreamingAssistantLocked(text string) {
			743	+	a.removeStreamingAssistantLocked()
			744	+	a.streamingAssistantStart = len(a.transcript)
			745	+	a.streamingAssistantLines = a.appendTranscriptLinesLocked(text, "", true)
			746	+	a.boundTranscriptLocked()
			747	+	}
			748	+
			749	+	func (a *Agent) removeStreamingAssistantLocked() {
			750	+	if a.streamingAssistantLines == 0 {
			751	+	return
			752	+	}
			753	+	start := a.streamingAssistantStart
			754	+	if start < 0 {
			755	+	start = 0
			756	+	}
			757	+	if start > len(a.transcript) {
			758	+	start = len(a.transcript)
			759	+	}
			760	+	end := start + a.streamingAssistantLines
			761	+	if end > len(a.transcript) {
			762	+	end = len(a.transcript)
			763	+	}
			764	+	for _, line := range a.transcript[start:end] {
			765	+	a.outputBytes -= len(line) + 1
			766	+	a.outputLines--
			767	+	}
			768	+	a.transcript = append(a.transcript[:start], a.transcript[end:]...)
			769	+	a.streamingAssistantLines = 0
			770	+	if a.outputLines == 0 {
			771	+	a.outputBytes = 0
			772	+	}
			773	+	}
			774	+
			775	+	func (a *Agent) clearStreamingAssistantLocked() {
			776	+	a.streamingAssistantText = ""
			777	+	a.streamingAssistantTruncated = false
			778	+	a.streamingAssistantStart = 0
			779	+	a.streamingAssistantLines = 0
			780	+	}
			781	+
			782	+	func (a *Agent) appendTranscriptLinesLocked(chunk, linePrefix string, assistant bool) int {
456		message := chunk	783		message := chunk
457		chunk = strings.TrimRight(chunk, "\n")	784		chunk = strings.TrimRight(chunk, "\n")
458		if chunk == "" {	785		if chunk == "" {
459	-	return	786	+	return 0
460		}	787		}
461	-	a.mu.Lock()	788	+	lines := strings.Split(chunk, "\n")
462	-	for _, line := range strings.Split(chunk, "\n") {	789	+	for _, line := range lines {
463		line = linePrefix + line	790		line = linePrefix + line
464		a.transcript = append(a.transcript, line)	791		a.transcript = append(a.transcript, line)
465		a.outputBytes += len(line) + 1	792		a.outputBytes += len(line) + 1

@@ -468,35 +795,42 @@ func (a *Agent) appendTranscriptLocked(chunk, linePrefix string, assistant bool)
468		if assistant {	795		if assistant {
469		a.lastAssistant = boundInlineText(message, a.maxOutputBytes, a.maxOutputLines)	796		a.lastAssistant = boundInlineText(message, a.maxOutputBytes, a.maxOutputLines)
470		}	797		}
471	-	// Bound the inline dashboard copy. The durable event log and session	798	+	return len(lines)
472	-	// remain available through the logical history reference.	799	+	}
473	-	lineCap := a.maxOutputLines	800	+
474	-	if lineCap <= 0 {	801	+	func (a *Agent) outputLimits() (byteCap, lineCap int) {
475	-	lineCap = 2_000	802	+	byteCap = a.maxOutputBytes
476	-	}
477	-	byteCap := a.maxOutputBytes
478		if byteCap <= 0 {	803		if byteCap <= 0 {
479		byteCap = 500_000	804		byteCap = 500_000
480		}	805		}
481	-	for a.outputLines > lineCap {	806	+	lineCap = a.maxOutputLines
482	-	line := a.transcript[0]	807	+	if lineCap <= 0 {
483	-	a.transcript = a.transcript[1:]	808	+	lineCap = 2_000
484	-	a.outputBytes -= len(line) + 1
485	-	a.outputLines--
486	-	a.outputTruncated = true
487		}	809		}
488	-	for a.outputLines > 0 && a.outputBytes > byteCap {	810	+	return byteCap, lineCap
			811	+	}
			812	+
			813	+	func (a *Agent) boundTranscriptLocked() {
			814	+	// Bound the inline dashboard copy. The durable event log and session
			815	+	// remain available through the logical history reference.
			816	+	byteCap, lineCap := a.outputLimits()
			817	+	for a.outputLines > lineCap \|\| (a.outputLines > 0 && a.outputBytes > byteCap) {
489		line := a.transcript[0]	818		line := a.transcript[0]
490		a.transcript = a.transcript[1:]	819		a.transcript = a.transcript[1:]
491		a.outputBytes -= len(line) + 1	820		a.outputBytes -= len(line) + 1
492		a.outputLines--	821		a.outputLines--
			822	+	if a.streamingAssistantLines > 0 {
			823	+	if a.streamingAssistantStart > 0 {
			824	+	a.streamingAssistantStart--
			825	+	} else {
			826	+	a.streamingAssistantLines--
			827	+	}
			828	+	}
493		a.outputTruncated = true	829		a.outputTruncated = true
494		}	830		}
495		if a.outputLines == 0 {	831		if a.outputLines == 0 {
496		a.outputBytes = 0	832		a.outputBytes = 0
497		}	833		}
498	-	a.mu.Unlock()
499	-	a.markActivity(time.Now())
500		}	834		}
501			835
502		// newAgentID returns a short, mostly-collision-free identifier of the	836		// newAgentID returns a short, mostly-collision-free identifier of the

M packages/agent/subagents/agent_test.go +31 -1

@@ -1,6 +1,9 @@
1		package subagents	1		package subagents
2			2
3	-	import "testing"	3	+	import (
			4	+	"sync"
			5	+	"testing"
			6	+	)
4			7
5		func TestAgentAttemptValueAndTranscriptAccounting(t *testing.T) {	8		func TestAgentAttemptValueAndTranscriptAccounting(t *testing.T) {
6		a := &Agent{maxOutputBytes: 6, maxOutputLines: 10}	9		a := &Agent{maxOutputBytes: 6, maxOutputLines: 10}

@@ -47,3 +50,30 @@ func TestAgentTranscriptLineCapAccounting(t *testing.T) {
47		t.Fatalf("line-cap accounting = (%d bytes, %d lines), want (10, 2)", a.outputBytes, a.outputLines)	50		t.Fatalf("line-cap accounting = (%d bytes, %d lines), want (10, 2)", a.outputBytes, a.outputLines)
48		}	51		}
49		}	52		}
			53	+
			54	+	func TestAgentSnapshotConcurrentTranscriptTruncation(t *testing.T) {
			55	+	a := &Agent{maxOutputBytes: 8, maxOutputLines: 1}
			56	+	start := make(chan struct{})
			57	+	var wg sync.WaitGroup
			58	+	wg.Add(2)
			59	+	go func() {
			60	+	defer wg.Done()
			61	+	<-start
			62	+	for range 10_000 {
			63	+	a.appendTranscript("overflow")
			64	+	}
			65	+	}()
			66	+	go func() {
			67	+	defer wg.Done()
			68	+	<-start
			69	+	for range 10_000 {
			70	+	_ = a.Snapshot()
			71	+	}
			72	+	}()
			73	+	close(start)
			74	+	wg.Wait()
			75	+
			76	+	if !a.Snapshot().OutputTruncated {
			77	+	t.Fatal("snapshot did not report transcript truncation")
			78	+	}
			79	+	}

M packages/agent/subagents/inbox.go +33 -12

 		}
 		defer conn.SetWriteDeadline(time.Time{})
 	}
-	if _, err := conn.Write(data); err != nil {
+	n, writeErr := conn.Write(data)
-		// Drop the connection so the next call redials. The previous error is
+	if writeErr != nil {
-		// more informative than the redial's would be, so surface this one.
+		// Drop the connection so the next call redials. Once any bytes have
+		// crossed the socket boundary, the outcome is ambiguous; returning the
+		// caller's context error would invite a duplicate command with a new
+		// identity.
 		stopCancel()
-		b.mu.Lock()
+		b.dropConnection(conn)
-		if b.conn == conn {
+		if n > 0 {
-			_ = b.conn.Close()
+			return fmt.Errorf("%w: wrote %d of %d bytes: %v", ErrDeliveryUnknown, n, len(data), writeErr)
-			b.conn = nil
 		}
-		b.mu.Unlock()
 		if ctxErr := ctx.Err(); ctxErr != nil {
 			return ctxErr
 		}
-		return err
+		return writeErr
+	}
+	if n != len(data) {
+		stopCancel()
+		b.dropConnection(conn)
+		return fmt.Errorf("%w: wrote %d of %d bytes", ErrDeliveryUnknown, n, len(data))
 	}
 	if !stopCancel() {
-		// Cancellation closed this connection after the write completed. Drop it
+		// Cancellation closed this connection after the complete command was
-		// so the next command redials instead of reusing a closed stream.
+		// written. The worker can parse the newline-delimited command, so the
+		// delivery succeeded even though the context is now canceled.
 		b.mu.Lock()
 		if b.conn == conn {
 			b.conn = nil
 		}
 		b.mu.Unlock()
-		return ctx.Err()
 	}
 	return nil
 }
+func (b *Inbox) dropConnection(conn net.Conn) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if b.conn == conn {
+		_ = b.conn.Close()
+		b.conn = nil
+	}
+}
 func (b *Inbox) acquireSend(ctx context.Context) (chan struct{}, error) {
 	b.mu.Lock()
 	if b.send == nil {
 // the TUI surfaces it as "agent <id> not listening yet".
 var ErrNotReady = errors.New("subagent: agent inbox not ready")
+// ErrDeliveryUnknown means a command write made progress but did not finish.
+// Callers must not replace the command with a fresh identity: the worker may
+// have received enough bytes to parse it, so retries must reuse the same
+// message id and be handled idempotently.
+var ErrDeliveryUnknown = errors.New("subagent: command delivery unknown")
 // dialUnixContext retries a Unix-socket connection briefly so the happy path
 // "child just started, supervisor sends right away" works without forcing the
 // caller to poll. Errors collapse onto ErrNotReady whenever the failure means

M packages/agent/subagents/inbox_test.go +60 -0


@@ -127,6 +127,32 @@ func (c *blockingWriteConn) Close() error {
127	return c.Conn.Close()	127		return c.Conn.Close()
128	}	128		}
129		129
		130	+	type cancelAfterWriteConn struct {
		131	+	net.Conn
		132	+	cancel context.CancelFunc
		133	+	}
		134	+
		135	+	func (c *cancelAfterWriteConn) Write(data []byte) (int, error) {
		136	+	c.cancel()
		137	+	return len(data), nil
		138	+	}
		139	+
		140	+	type partialWriteConn struct {
		141	+	net.Conn
		142	+	withError bool
		143	+	}
		144	+
		145	+	func (c *partialWriteConn) Write(data []byte) (int, error) {
		146	+	written := len(data) / 2
		147	+	if written == 0 {
		148	+	written = 1
		149	+	}
		150	+	if c.withError {
		151	+	return written, errors.New("partial write")
		152	+	}
		153	+	return written, nil
		154	+	}
		155	+
130	type notifyingContext struct {	156		type notifyingContext struct {
131	context.Context	157		context.Context
132	doneCalled chan struct{}	158		doneCalled chan struct{}

@@ -138,6 +164,40 @@ func (c *notifyingContext) Done() <-chan struct{} {
138	return c.Context.Done()	164		return c.Context.Done()
139	}	165		}
140		166
		167	+	func TestInboxSendContextTreatsCompleteWriteBeforeCancellationAsDelivered(t *testing.T) {
		168	+	local, remote := net.Pipe()
		169	+	defer remote.Close()
		170	+	ctx, cancel := context.WithCancel(context.Background())
		171	+	inbox := NewInbox("unused")
		172	+	inbox.conn = &cancelAfterWriteConn{Conn: local, cancel: cancel}
		173	+	defer inbox.Close()
		174	+
		175	+	if err := inbox.sendBytesContext(ctx, []byte("follow-up\n")); err != nil {
		176	+	t.Fatalf("complete write after cancellation = %v, want success", err)
		177	+	}
		178	+	}
		179	+
		180	+	func TestInboxSendContextTreatsPartialWritesAsUnknownDelivery(t *testing.T) {
		181	+	for _, withError := range []bool{false, true} {
		182	+	name := "short write"
		183	+	if withError {
		184	+	name = "partial write error"
		185	+	}
		186	+	t.Run(name, func(t *testing.T) {
		187	+	local, remote := net.Pipe()
		188	+	defer remote.Close()
		189	+	inbox := NewInbox("unused")
		190	+	inbox.conn = &partialWriteConn{Conn: local, withError: withError}
		191	+	defer inbox.Close()
		192	+
		193	+	err := inbox.sendBytesContext(context.Background(), []byte("follow-up\n"))
		194	+	if !errors.Is(err, ErrDeliveryUnknown) {
		195	+	t.Fatalf("partial write error = %v, want ErrDeliveryUnknown", err)
		196	+	}
		197	+	})
		198	+	}
		199	+	}
		200	+
141	func TestInboxSendContextCancelsBlockedWrite(t *testing.T) {	201		func TestInboxSendContextCancelsBlockedWrite(t *testing.T) {
142	local, remote := net.Pipe()	202		local, remote := net.Pipe()
143	defer remote.Close()	203		defer remote.Close()

M packages/agent/subagents/persist.go +324 -82

 	"sort"
 	"strings"
 	"time"
+	"github.com/google/uuid"
 )
 // agentMeta is the durable identity record for one agent. Only fields
 	WorkspaceBase    string          `json:"workspace_base,omitempty"`
 	WorkspaceCapture CaptureMode     `json:"workspace_capture,omitempty"`
 	MaxTurns         int             `json:"max_turns,omitempty"`
+	LifetimeTurns    int             `json:"lifetime_turns,omitempty"`
+	CurrentRunTurns  int             `json:"current_run_turns,omitempty"`
 	Timeout          time.Duration   `json:"timeout,omitempty"`
 	Tools            []string        `json:"tools,omitempty"`
 	WebSearchPolicy  WebSearchPolicy `json:"web_search_policy,omitempty"`
 	// ResumePrompt is a follow-up accepted by subagent_resume but not yet
 	// acknowledged by the child with a turn.started event. It is durable so a
 	// host exit while the worker is queued does not lose the manager signal.
-	ResumePrompt   string    `json:"resume_prompt,omitempty"`
+	ResumePrompt   string               `json:"resume_prompt,omitempty"`
-	ResumePromptAt time.Time `json:"resume_prompt_at,omitempty"`
+	ResumePromptAt time.Time            `json:"resume_prompt_at,omitempty"`
+	ResumePromptID string               `json:"resume_prompt_id,omitempty"`
+	ResumeQueue    []queuedResumePrompt `json:"resume_queue,omitempty"`
 	// SessionID, when non-empty, scopes the agent to a particular
 	// host zut session: the dashboard only shows agents whose
 // write is atomic (tmp + rename) so a crash mid-write can't leave a
 // half-parsable file that fails Reload.
 func writeAgentMeta(stateDir string, a *Agent) error {
+	if a == nil {
+		return errors.New("subagent meta: nil agent")
+	}
+	a.persistMu.Lock()
+	defer a.persistMu.Unlock()
 	fastMode := a.FastMode
 	webSearchPolicy := childWebSearchPolicy(a.WebSearchPolicy, a.Subagent, a.Tools)
 	a.mu.Lock()
 	finished := a.finished
 	resumePrompt := a.resumePromptText
 	resumePromptAt := a.resumePromptAt
+	resumePromptID := a.resumePromptID
+	resumeQueue := append([]queuedResumePrompt(nil), a.resumePromptQueue...)
 	errText := ""
 	if a.lastErr != nil {
 		errText = a.lastErr.Error()
 	processState := a.processState
 	turnState := a.turnState
 	currentTurnID := a.currentTurnID
+	lifetimeTurns := a.LifetimeTurns
+	currentRunTurns := a.CurrentRunTurns
 	attempt := a.Attempt
 	processPID := a.ProcessPID
 	updatedAt := a.updatedAt
 		WorkspaceBase:    a.WorkspaceBase,
 		WorkspaceCapture: a.WorkspaceCapture,
 		MaxTurns:         a.MaxTurns,
+		LifetimeTurns:    lifetimeTurns,
+		CurrentRunTurns:  currentRunTurns,
 		Timeout:          a.Timeout,
 		Tools:            append([]string(nil), a.Tools...),
 		WebSearchPolicy:  webSearchPolicy,
 		SessionPath:      a.SessionPath,
 		ResumePrompt:     resumePrompt,
 		ResumePromptAt:   resumePromptAt,
+		ResumePromptID:   resumePromptID,
+		ResumeQueue:      resumeQueue,
 		SessionID:        a.SessionID,
 	}
 	b, err := json.MarshalIndent(m, "", "  ")
 		return fmt.Errorf("subagents meta dir: %w", err)
 	}
 	final := metaPath(stateDir)
-	tmp := final + ".tmp"
+	// Use a unique temporary file while holding the per-agent persistence
-	if err := os.WriteFile(tmp, append(b, '\n'), 0o600); err != nil {
+	// lock. A fixed meta.json.tmp is vulnerable to a concurrent writer (or a
+	// stale file after a crash) replacing another writer's snapshot.
+	tmpFile, err := os.CreateTemp(stateDir, ".meta.json.tmp-*")
+	if err != nil {
+		return fmt.Errorf("subagents meta temp: %w", err)
+	}
+	tmp := tmpFile.Name()
+	removeTemp := true
+	defer func() {
+		_ = tmpFile.Close()
+		if removeTemp {
+			_ = os.Remove(tmp)
+		}
+	}()
+	if err := tmpFile.Chmod(0o600); err != nil {
+		return fmt.Errorf("subagents meta permissions: %w", err)
+	}
+	if _, err := tmpFile.Write(append(b, '\n')); err != nil {
 		return fmt.Errorf("subagents meta write: %w", err)
 	}
+	if err := tmpFile.Sync(); err != nil {
+		return fmt.Errorf("subagents meta sync: %w", err)
+	}
+	if err := tmpFile.Close(); err != nil {
+		return fmt.Errorf("subagents meta close: %w", err)
+	}
 	if err := os.Rename(tmp, final); err != nil {
-		_ = os.Remove(tmp)
 		return fmt.Errorf("subagent meta rename: %w", err)
 	}
+	removeTemp = false
+	// Sync the containing directory so the rename itself survives a host
+	// crash, not just the bytes in the temporary file.
+	dir, err := os.Open(stateDir)
+	if err != nil {
+		return fmt.Errorf("subagents meta directory open: %w", err)
+	}
+	if err := dir.Sync(); err != nil {
+		_ = dir.Close()
+		return fmt.Errorf("subagents meta directory sync: %w", err)
+	}
+	if err := dir.Close(); err != nil {
+		return fmt.Errorf("subagents meta directory close: %w", err)
+	}
 	return nil
 }
 		agentStateDir = filepath.Dir(m.EventLogPath)
 	}
 	a := &Agent{
-		ID:               m.ID,
+		ID:                m.ID,
-		Task:             m.Task,
+		Task:              m.Task,
-		OriginalTask:     firstNonEmpty(m.OriginalTask, m.Task),
+		OriginalTask:      firstNonEmpty(m.OriginalTask, m.Task),
-		Dir:              dir,
+		Dir:               dir,
-		RepositoryRoot:   firstNonEmpty(m.RepositoryRoot, f.cfg.RepoRoot),
+		RepositoryRoot:    firstNonEmpty(m.RepositoryRoot, f.cfg.RepoRoot),
-		Started:          m.Started,
+		Started:           m.Started,
-		ParentID:         m.ParentID,
+		ParentID:          m.ParentID,
-		BatchID:          m.BatchID,
+		BatchID:           m.BatchID,
-		RootSessionID:    m.RootSessionID,
+		RootSessionID:     m.RootSessionID,
-		Model:            m.Model,
+		Model:             m.Model,
-		Provider:         m.Provider,
+		Provider:          m.Provider,
-		BaseURL:          m.BaseURL,
+		BaseURL:           m.BaseURL,
-		InsecureTLS:      m.InsecureTLS,
+		InsecureTLS:       m.InsecureTLS,
-		Reasoning:        m.Reasoning,
+		Reasoning:         m.Reasoning,
-		FastMode:         fastMode,
+		FastMode:          fastMode,
-		Subagent:         m.Subagent,
+		Subagent:          m.Subagent,
-		WorkspaceMode:    m.WorkspaceMode,
+		WorkspaceMode:     m.WorkspaceMode,
-		WorkspacePath:    m.WorkspacePath,
+		WorkspacePath:     m.WorkspacePath,
-		WorkspaceBase:    m.WorkspaceBase,
+		WorkspaceBase:     m.WorkspaceBase,
-		WorkspaceCapture: m.WorkspaceCapture,
+		WorkspaceCapture:  m.WorkspaceCapture,
-		MaxTurns:         m.MaxTurns,
+		MaxTurns:          m.MaxTurns,
-		Timeout:          m.Timeout,
+		LifetimeTurns:     m.LifetimeTurns,
-		Tools:            append([]string(nil), m.Tools...),
+		CurrentRunTurns:   m.CurrentRunTurns,
-		WebSearchPolicy:  childWebSearchPolicy(m.WebSearchPolicy, m.Subagent, m.Tools),
+		Timeout:           m.Timeout,
-		Attempt:          m.Attempt,
+		Tools:             append([]string(nil), m.Tools...),
-		ProcessPID:       m.ProcessPID,
+		WebSearchPolicy:   childWebSearchPolicy(m.WebSearchPolicy, m.Subagent, m.Tools),
-		InboxPath:        m.InboxPath,
+		Attempt:           m.Attempt,
-		EventLogPath:     m.EventLogPath,
+		ProcessPID:        m.ProcessPID,
-		SessionPath:      m.SessionPath,
+		InboxPath:         m.InboxPath,
-		resumePromptText: m.ResumePrompt,
+		EventLogPath:      m.EventLogPath,
-		resumePromptAt:   m.ResumePromptAt,
+		SessionPath:       m.SessionPath,
-		SessionID:        m.SessionID,
+		resumePromptText:  m.ResumePrompt,
-		inbox:            NewInbox(m.InboxPath),
+		resumePromptAt:    m.ResumePromptAt,
-		status:           status,
+		resumePromptID:    m.ResumePromptID,
-		activity:         activity,
+		resumePromptQueue: append([]queuedResumePrompt(nil), m.ResumeQueue...),
-		finished:         m.Finished,
+		SessionID:         m.SessionID,
-		lastErr:          lastErr,
+		inbox:             NewInbox(m.InboxPath),
-		legacyEventState: legacyEventState,
+		status:            status,
-		processState:     processState,
+		activity:          activity,
-		turnState:        turnState,
+		finished:          m.Finished,
-		currentTurnID:    m.CurrentTurnID,
+		lastErr:           lastErr,
-		updatedAt:        m.UpdatedAt,
+		legacyEventState:  legacyEventState,
-		lastActivity:     lastActivity,
+		processState:      processState,
-		stateDir:         agentStateDir,
+		turnState:         turnState,
-		resultRef:        m.ResultRef,
+		currentTurnID:     m.CurrentTurnID,
-		patchRef:         m.PatchRef,
+		updatedAt:         m.UpdatedAt,
-		changedFiles:     append([]string(nil), m.ChangedFiles...),
+		lastActivity:      lastActivity,
-		maxOutputBytes:   f.cfg.Policy.MaxOutputBytes,
+		stateDir:          agentStateDir,
-		maxOutputLines:   f.cfg.Policy.MaxOutputLines,
+		resultRef:         m.ResultRef,
-		done:             make(chan struct{}),
+		patchRef:          m.PatchRef,
-		turnResults:      make(chan *TurnResult, 16),
+		changedFiles:      append([]string(nil), m.ChangedFiles...),
+		maxOutputBytes:    f.cfg.Policy.MaxOutputBytes,
+		maxOutputLines:    f.cfg.Policy.MaxOutputLines,
+		done:              make(chan struct{}),
+		turnResults:       make(chan *TurnResult, 16),
 	}
 	if a.updatedAt.IsZero() {
 		a.updatedAt = lastActivity
 	if err != nil {
 		return fmt.Errorf("read subagent transcript: %w", err)
 	}
-	if prompt, acceptedAt := a.ResumePromptInfo(); prompt != "" && resumePromptAcknowledged(events, acceptedAt) {
+	if prompt, acceptedAt := a.ResumePromptInfo(); prompt != "" && resumePromptAcknowledged(events, prompt, acceptedAt) {
 		a.clearResumePrompt()
 	}
 	a.mu.Lock()
 // Status precedence: explicit lifecycle events (agent_stopped) win
 // over inferred ones (assistant_message → idle). If the log contains
 // no terminator we keep status=StatusDetached so the user can resume.
-func resumePromptAcknowledged(events []Event, acceptedAt time.Time) bool {
+func resumePromptAcknowledged(events []Event, prompt string, acceptedAt time.Time) bool {
-	if acceptedAt.IsZero() {
+	if prompt == "" || acceptedAt.IsZero() {
 		return false
 	}
+	userDurable := false
 	for _, ev := range events {
-		if (ev.Type == EventTurnStarted || ev.Type == "turn_start") && !ev.Time.Before(acceptedAt) {
+		if ev.Time.Before(acceptedAt) {
+			continue
+		}
+		if ev.Type == "user_message" && userMessageText(ev) == prompt {
+			// The worker emits this event only after the matching session
+			// message has been appended and flushed. A crash here leaves the
+			// prompt pending, which is intentionally safe to replay.
+			userDurable = true
+			continue
+		}
+		if userDurable && isDelegatedTurnStart(ev) {
 			return true
 		}
 	}
 func replayEventsIntoAgent(a *Agent, evs []Event) {
 	terminal := false
 	for _, ev := range evs {
+		replayEventTranscript(a, ev)
 		switch ev.Type {
-		case EventTurnStarted, "turn_start":
+		case EventTurnStarted:
-			turnID := ev.TurnID
+			if !isDelegatedTurnStart(ev) {
-			if turnID == "" {
+				continue
-				if step, ok := ev.Data["step"].(float64); ok {
-					turnID = fmt.Sprintf("turn-%d", int(step))
-				}
 			}
-			a.setTurnState(TurnRunning, turnID)
+			a.setTurnState(TurnRunning, eventTurnID(ev))
 		case EventTurnResult, "turn_result":
 			if result, err := decodeTurnResultEvent(ev, a.ID, a.maxOutputBytes, a.maxOutputLines); err == nil {
 				a.setResult(result)
 			a.status = StatusDone
 			a.activity = "done (offline)"
 			a.mu.Unlock()
-		case "assistant_message", "user_message", "stdout", "stderr", "error":
-			replayEventTranscript(a, ev)
 		case "agent_stopped":
 			terminal = true
 			reason, _ := ev.Data["reason"].(string)
 }
 func replayEventTranscript(a *Agent, ev Event) {
+	if isAssistantStreamBoundary(ev.Type) {
+		a.resetStreamingAssistant()
+	}
 	switch ev.Type {
+	case "message.delta":
+		if delta, _ := ev.Data["delta"].(string); delta != "" {
+			a.appendAssistantDelta(delta)
+		}
 	case "assistant_message", "user_message":
 		var text []string
 		if c, ok := ev.Data["content"].([]any); ok {
 // ResumeWithPrompt continues an agent with a manager follow-up while retaining
 // its existing session. An idle live worker receives the turn through its
-// inbox; a terminal worker is restarted with the follow-up as its initial
+// inbox; an active live worker queues the follow-up for the next idle turn; a
-// prompt, avoiding a race with inbox listener startup.
+// terminal worker is restarted with the follow-up as its initial prompt,
+// avoiding a race with inbox listener startup.
 func (f *Supervisor) ResumeWithPrompt(ctx context.Context, id, prompt string) (*Agent, error) {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
 	if strings.TrimSpace(prompt) == "" {
 		return nil, fmt.Errorf("subagent: follow-up prompt is required")
 	}
 	}
 	status := existing.Status()
 	if status == StatusRunning {
-		if existing.ProcessState() != ProcessAlive || existing.TurnState() != TurnIdle {
+		if existing.ProcessState() != ProcessAlive {
 			f.operationMu.Unlock()
-			return nil, fmt.Errorf("subagent: agent %s is still working; wait for it to become idle before sending a follow-up", existing.ID)
+			return nil, fmt.Errorf("subagent: agent %s is still working; wait for its worker to become available before sending a follow-up", existing.ID)
 		}
 		if existing.inbox == nil {
 			f.operationMu.Unlock()
 			return nil, fmt.Errorf("subagent: agent %s has no inbox", existing.ID)
 		}
+		if err := ctx.Err(); err != nil {
+			f.operationMu.Unlock()
+			return nil, err
+		}
+		if existing.TurnState() != TurnRunning && existing.hasQueuedResumePrompt() {
+			f.operationMu.Unlock()
+			return nil, fmt.Errorf("subagent: agent %s already has a follow-up pending delivery", existing.ID)
+		}
+		if existing.TurnState() == TurnRunning {
+			// Active turns cannot accept a command through the worker inbox yet.
+			// Keep the prompt durable and let the idle transition deliver it in
+			// order after the current message turn finishes.
+			acceptedAt := f.cfg.Now()
+			commandID := existing.queueResumePrompt(prompt, acceptedAt)
+			if err := f.persistAgent(existing); err != nil {
+				existing.removeQueuedResumePrompt(commandID)
+				f.operationMu.Unlock()
+				return nil, fmt.Errorf("subagent: persist queued follow-up for %s: %w", existing.ID, err)
+			}
+			f.operationMu.Unlock()
+			return existing, nil
+		}
+		if existing.TurnState() != TurnIdle {
+			f.operationMu.Unlock()
+			return nil, fmt.Errorf("subagent: agent %s is still working; wait for it to become idle before sending a follow-up", existing.ID)
+		}
 		turnID := existing.CurrentTurnID()
+		previousRunTurns := existing.resetCurrentRunTurns()
 		// Reserve the worker before writing to its inbox. A second manager call
 		// must not enqueue another turn in the small interval before the worker
 		// reports its turn.start event. Persist the prompt first so a host exit
 		// before that event can resume and redeliver it.
-		previousPrompt, previousPromptAt := existing.setResumePrompt(prompt, f.cfg.Now())
+		previousPrompt := existing.setResumePrompt(prompt, f.cfg.Now())
 		existing.setTurnState(TurnQueued, turnID)
 		inbox := existing.inbox
-		command := NewCommand(CommandTurnStart, existing.ID, turnID, TurnStartPayload{Prompt: prompt})
+		command := NewCommand(CommandTurnStart, existing.ID, turnID, TurnStartPayload{Prompt: prompt, NewRun: true})
-		f.persistAgent(existing)
+		command.MessageID = existing.resumePromptCommandID()
+		if err := f.persistAgent(existing); err != nil {
+			existing.setTurnState(TurnIdle, turnID)
+			existing.setCurrentRunTurns(previousRunTurns)
+			existing.restoreResumePrompt(previousPrompt)
+			f.operationMu.Unlock()
+			return nil, fmt.Errorf("subagent: persist follow-up for %s: %w", existing.ID, err)
+		}
 		f.operationMu.Unlock()
 		if err := inbox.SendCommandContext(ctx, command); err != nil {
+			retryUnknown := false
 			f.operationMu.Lock()
 			if existing.Status() == StatusRunning && existing.TurnState() == TurnQueued && existing.CurrentTurnID() == turnID {
 				existing.setTurnState(TurnIdle, turnID)
-				existing.setResumePrompt(previousPrompt, previousPromptAt)
+				existing.setCurrentRunTurns(previousRunTurns)
-				f.persistAgent(existing)
+				if errors.Is(err, ErrDeliveryUnknown) {
+					existing.rejectActiveResumePrompt()
+					retryUnknown = true
+				} else {
+					existing.restoreResumePrompt(previousPrompt)
+				}
+				if persistErr := f.persistAgent(existing); persistErr != nil {
+					err = fmt.Errorf("%w; persist recovery: %v", err, persistErr)
+				}
 			}
 			f.operationMu.Unlock()
+			if retryUnknown {
+				// The command keeps its durable identity. A retry is safe whether
+				// the worker parsed the first write or only received a prefix.
+				f.dispatchQueuedResume(ctx, existing)
+			}
 			return nil, fmt.Errorf("subagent: send follow-up to %s: %w", existing.ID, err)
 		}
 		return existing, nil
 	return f.resume(ctx, id, true, prompt)
 }
+// dispatchQueuedResumeWithTimeout keeps the idle callback bounded. Unlike a
+// manager request, an idle transition has no caller context to propagate.
+func (f *Supervisor) dispatchQueuedResumeWithTimeout(a *Agent) {
+	timeout := f.cfg.Policy.ReconnectTimeout
+	if timeout <= 0 {
+		timeout = 5 * time.Second
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	f.dispatchQueuedResume(ctx, a)
+}
+// dispatchQueuedResume delivers the oldest follow-up accepted during an
+// active turn after the worker reports that its inbox can accept a new turn.
+// The operation lock serializes this transition with manager resume calls and
+// the agent's durable prompt state prevents a host exit from losing it.
+func (f *Supervisor) dispatchQueuedResume(ctx context.Context, a *Agent) {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	if a == nil {
+		return
+	}
+	f.operationMu.Lock()
+	if a.Status() != StatusRunning || a.ProcessState() != ProcessAlive || a.TurnState() != TurnIdle || a.inbox == nil {
+		f.operationMu.Unlock()
+		return
+	}
+	prompt, acceptedAt, commandID, ok := a.startQueuedResumePrompt()
+	if !ok {
+		f.operationMu.Unlock()
+		return
+	}
+	turnID := a.CurrentTurnID()
+	previousRunTurns := a.resetCurrentRunTurns()
+	a.setTurnState(TurnQueued, turnID)
+	inbox := a.inbox
+	command := NewCommand(CommandTurnStart, a.ID, turnID, TurnStartPayload{Prompt: prompt, NewRun: true})
+	command.MessageID = commandID
+	if err := f.persistAgent(a); err != nil {
+		a.restoreResumePromptToQueue(prompt, acceptedAt)
+		a.setCurrentRunTurns(previousRunTurns)
+		a.setTurnState(TurnIdle, turnID)
+		f.operationMu.Unlock()
+		return
+	}
+	f.operationMu.Unlock()
+	if err := inbox.SendCommandContext(ctx, command); err == nil {
+		return
+	}
+	// A failed delivery must put the prompt back at the head of the queue.
+	// Keep the worker idle so a later retry, or an explicit resume, can send
+	// it without skipping any subsequent follow-ups.
+	f.operationMu.Lock()
+	if a.Status() == StatusRunning && a.ProcessState() == ProcessAlive && a.TurnState() == TurnQueued && a.CurrentTurnID() == turnID {
+		if a.restoreResumePromptToQueue(prompt, acceptedAt) {
+			a.setCurrentRunTurns(previousRunTurns)
+			a.setTurnState(TurnIdle, turnID)
+			if persistErr := f.persistAgent(a); persistErr != nil {
+				// persistAgent records the failure on the agent. Keep the explicit
+				// check here because this recovery write is the only durable copy
+				// of the restored queue head.
+				a.recordPersistenceError(persistErr)
+			}
+		}
+	}
+	f.operationMu.Unlock()
+}
 // RestartTask intentionally runs the stored original task again in a fresh
 // worker attempt. Callers should use ResumeSession for normal recovery.
 func (f *Supervisor) RestartTask(ctx context.Context, id string) (*Agent, error) {
 	}
 	now := f.cfg.Now()
 	fastMode := existing.FastMode
-	pendingResumePrompt, pendingResumePromptAt := existing.ResumePromptInfo()
+	lifetimeTurns := existing.LifetimeTurnsValue()
+	currentRunTurns := existing.CurrentRunTurnsValue()
+	pendingResume := existing.resumePromptState()
+	pendingResumePrompt, pendingResumePromptAt, pendingResumePromptID := pendingResume.Prompt, pendingResume.AcceptedAt, pendingResume.CommandID
+	pendingResumeQueue := existing.resumePromptQueueSnapshot()
+	if pendingResumePrompt != "" && pendingResumePromptID == "" {
+		pendingResumePromptID = uuid.NewString()
+	}
 	if resumePrompt != "" {
-		pendingResumePrompt = resumePrompt
+		currentRunTurns = 0
-		pendingResumePromptAt = now
+		if pendingResumePrompt == "" {
+			pendingResumePrompt = resumePrompt
+			pendingResumePromptAt = now
+			pendingResumePromptID = uuid.NewString()
+		} else {
+			pendingResumeQueue = append(pendingResumeQueue, queuedResumePrompt{Prompt: resumePrompt, AcceptedAt: now, CommandID: uuid.NewString()})
+		}
+	}
+	if resuming && resumePrompt == "" && pendingResumePrompt == "" && len(pendingResumeQueue) > 0 {
+		// A host can exit after accepting an active-worker follow-up but before
+		// dispatching it. Make the first durable queued prompt the resumed
+		// worker's initial turn rather than leaving the queue stranded.
+		queued := pendingResumeQueue[0]
+		pendingResumePrompt = queued.Prompt
+		pendingResumePromptAt = queued.AcceptedAt
+		pendingResumePromptID = queued.CommandID
+		if pendingResumePromptID == "" {
+			pendingResumePromptID = uuid.NewString()
+		}
+		pendingResumeQueue = pendingResumeQueue[1:]
+	}
+	if resuming && pendingResumePrompt != "" {
+		// A retained follow-up is an explicit new run, including a queued
+		// follow-up recovered after a host restart. Preserve lifetime turns but
+		// never carry the previous run's allowance into this one.
+		currentRunTurns = 0
+	}
+	if !resuming {
+		currentRunTurns = 0
 	}
 	m := agentMeta{
 		ID: existing.ID, Task: existing.Task,
 		Subagent:      existing.Subagent,
 		WorkspaceMode: existing.WorkspaceMode, WorkspacePath: existing.WorkspacePath,
 		WorkspaceBase: existing.WorkspaceBase, WorkspaceCapture: existing.WorkspaceCapture,
-		MaxTurns: existing.MaxTurns, Timeout: existing.Timeout, Tools: append([]string(nil), existing.Tools...),
+		MaxTurns: existing.MaxTurns, LifetimeTurns: lifetimeTurns, CurrentRunTurns: currentRunTurns, Timeout: existing.Timeout, Tools: append([]string(nil), existing.Tools...),
 		WebSearchPolicy: childWebSearchPolicy(existing.WebSearchPolicy, existing.Subagent, existing.Tools),
 		CurrentTurnID:   existingSnapshot.CurrentTurnID, Attempt: existingSnapshot.Attempt,
 		SessionID: existing.SessionID,
 		SessionPath:    existing.SessionPath,
 		ResumePrompt:   pendingResumePrompt,
 		ResumePromptAt: pendingResumePromptAt,
+		ResumePromptID: pendingResumePromptID,
+		ResumeQueue:    pendingResumeQueue,
 	}
 	if len(m.Tools) == 0 && len(f.cfg.Policy.AllowedTools) > 0 {
 		WorkspaceBase:     m.WorkspaceBase,
 		WorkspaceCapture:  m.WorkspaceCapture,
 		MaxTurns:          maxTurns,
+		LifetimeTurns:     m.LifetimeTurns,
+		CurrentRunTurns:   m.CurrentRunTurns,
 		Timeout:           timeout,
 		Attempt:           m.Attempt,
 		HeartbeatInterval: f.cfg.Policy.HeartbeatInterval,
 		Resuming:          resuming,
 		resumePromptText:  pendingResumePrompt,
 		resumePromptAt:    pendingResumePromptAt,
+		resumePromptID:    m.ResumePromptID,
+		resumePromptQueue: append([]queuedResumePrompt(nil), pendingResumeQueue...),
 		inbox:             NewInbox(m.InboxPath),
 		status:            StatusPending,
 		activity:          "resuming",
 	}
 	a.ctx, a.cancel = runCtx, cancel
 	a.persistFn = f.persistAgent
+	a.setOnTurnIdle(func() { f.dispatchQueuedResumeWithTimeout(a) })
 	a.workspaceCleanup = func() error { return workspace.Cleanup(context.Background()) }
 	a.workspaceCapture = func() (WorkspaceCapture, error) { return workspace.Capture(context.Background()) }
 	a.runner = f.cfg.NewRunner(a)

M packages/agent/subagents/persist_test.go +32 -1


@@ -14,6 +14,34 @@ import (
14		"time"	14		"time"
15		)	15		)
16			16
			17	+	func TestWriteAgentMetaSerializesConcurrentSnapshots(t *testing.T) {
			18	+	stateDir := t.TempDir()
			19	+	a := &Agent{ID: "concurrent-meta", Task: "retain queued prompts", stateDir: stateDir}
			20	+	var wg sync.WaitGroup
			21	+	for i := 0; i < 32; i++ {
			22	+	wg.Add(1)
			23	+	go func(i int) {
			24	+	defer wg.Done()
			25	+	a.setTurnCounts(i, i/2)
			26	+	a.queueResumePrompt("prompt", time.Now())
			27	+	if err := writeAgentMeta(stateDir, a); err != nil {
			28	+	t.Errorf("write metadata: %v", err)
			29	+	}
			30	+	}(i)
			31	+	}
			32	+	wg.Wait()
			33	+	if _, err := readAgentMeta(stateDir); err != nil {
			34	+	t.Fatalf("final metadata is not a complete JSON snapshot: %v", err)
			35	+	}
			36	+	matches, err := filepath.Glob(filepath.Join(stateDir, ".meta.json.tmp-*"))
			37	+	if err != nil {
			38	+	t.Fatal(err)
			39	+	}
			40	+	if len(matches) != 0 {
			41	+	t.Fatalf("temporary metadata files remain: %v", matches)
			42	+	}
			43	+	}
			44	+
17		// TestSpawnWritesMetaJSON asserts the durability contract: every	45		// TestSpawnWritesMetaJSON asserts the durability contract: every
18		// successful Spawn leaves a meta.json on disk with the agent's	46		// successful Spawn leaves a meta.json on disk with the agent's
19		// identity bits. Without this, Reload on the next zut launch can't	47		// identity bits. Without this, Reload on the next zut launch can't

@@ -662,7 +690,7 @@ func TestReloadClearsResumePromptAcknowledgedInEventLog(t *testing.T) {
662		EventLogPath: filepath.Join(stateDir, "events.jsonl"),	690		EventLogPath: filepath.Join(stateDir, "events.jsonl"),
663		SessionPath: filepath.Join(stateDir, "session.json"),	691		SessionPath: filepath.Join(stateDir, "session.json"),
664		ResumePrompt: "I applied your review. What do you think now?",	692		ResumePrompt: "I applied your review. What do you think now?",
665	-	ResumePromptAt: time.Now(),	693	+	ResumePromptAt: time.Now().Add(-time.Second),
666		}	694		}
667		data, err := json.Marshal(m)	695		data, err := json.Marshal(m)
668		if err != nil {	696		if err != nil {

@@ -675,6 +703,9 @@ func TestReloadClearsResumePromptAcknowledgedInEventLog(t *testing.T) {
675		if err != nil {	703		if err != nil {
676		t.Fatal(err)	704		t.Fatal(err)
677		}	705		}
			706	+	if err := log.Append(NewEvent("user_message", map[string]any{"content": []any{map[string]any{"type": "text", "text": m.ResumePrompt}}})); err != nil {
			707	+	t.Fatal(err)
			708	+	}
678		if err := log.Append(NewEvent(EventTurnStarted, map[string]any{"step": float64(1)})); err != nil {	709		if err := log.Append(NewEvent(EventTurnStarted, map[string]any{"step": float64(1)})); err != nil {
679		t.Fatal(err)	710		t.Fatal(err)
680		}	711		}

M packages/agent/subagents/protocol.go +4 -0


@@ -579,6 +579,10 @@ type AgentHeartbeatPayload struct {
579	}	579		}
580	type TurnStartPayload struct {	580		type TurnStartPayload struct {
581	Prompt string `json:"prompt"`	581		Prompt string `json:"prompt"`
		582	+	// NewRun starts a fresh max_turns budget while retaining the worker's
		583	+	// existing session and transcript. It is set only for explicit
		584	+	// subagent_resume follow-ups.
		585	+	NewRun bool `json:"new_run,omitempty"`
582	}	586		}
583	type TurnCancelPayload struct {	587		type TurnCancelPayload struct {
584	Reason string `json:"reason,omitempty"`	588		Reason string `json:"reason,omitempty"`

M packages/agent/subagents/result.go +26 -4

 		return
 	}
 	attempt := a.AttemptValue()
+	a.mu.Lock()
+	partialOutput := a.lastAssistant
+	a.mu.Unlock()
 	result := a.Result()
 	if result != nil {
 		if err := validateTurnResultAgent(result, a.ID); err != nil {
 			result = nil
 		}
 	}
+	if result != nil && result.Output == "" && partialOutput != "" &&
+		(result.Status == ResultFailed || result.Status == ResultCanceled || status == StatusFailed || status == StatusKilled) {
+		// A canceled or failed worker turn may emit its terminal result before
+		// its provider turns accumulated text into a final assistant message.
+		// The event stream has already projected that text onto the Agent, so
+		// retain it in the durable result rather than returning an empty failure.
+		result.Output = partialOutput
+	}
 	if result == nil {
 		turnID := a.CurrentTurnID()
 		if turnID == "" {
 			turnID = fmt.Sprintf("turn-%d", attempt)
 		}
-		a.mu.Lock()
+		output := partialOutput
-		output := a.lastAssistant
-		a.mu.Unlock()
 		resultStatus := ResultSucceeded
 		switch {
 		case status == StatusFailed && errors.Is(runErr, context.Canceled):
 		} else {
 			result.Status = ResultFailed
 		}
-		if result.Error == nil {
+		if errors.Is(runErr, context.DeadlineExceeded) {
+			// The parent deadline is authoritative for terminal categorization, so
+			// it intentionally overrides any child result error, including
+			// context_limit. The worker was first asked to stop cleanly, and any
+			// streamed output remains in this result and HistoryRef(agentID).
+			message := "subagent deadline exceeded; inspect history for received output"
+			if result.Output != "" {
+				message = "subagent deadline exceeded; partial output is preserved in the result and history"
+			}
+			result.Error = &ResultError{
+				Code:    "deadline_exceeded",
+				Message: message,
+			}
+		} else if result.Error == nil {
 			result.Error = &ResultError{Code: "runner_failed", Message: truncate(runErr.Error(), 500)}
 		}
 	}

M packages/agent/subagents/result_test.go +52 -10


@@ -269,23 +269,35 @@ func checkCaptureFailureResult(t testing.T, agent Agent, stateDir string) {
269			269
270		func TestEnsureResultReconcilesChildStatusWithRunnerError(t *testing.T) {	270		func TestEnsureResultReconcilesChildStatusWithRunnerError(t *testing.T) {
271		tests := []struct {	271		tests := []struct {
272	-	name string	272	+	name string
273	-	status Status	273	+	status Status
274	-	runErr error	274	+	runErr error
275	-	wantState TurnStatus	275	+	childCode string
			276	+	wantState TurnStatus
			277	+	wantCode string
			278	+	wantOutput string
276		}{	279		}{
277	-	{name: "runner failure", status: StatusFailed, runErr: errors.New("runner failed"), wantState: ResultFailed},	280	+	{name: "runner failure", status: StatusFailed, runErr: errors.New("runner failed"), wantState: ResultFailed, wantCode: "runner_failed"},
278	-	{name: "runner cancellation", status: StatusFailed, runErr: context.Canceled, wantState: ResultCanceled},	281	+	{name: "runner cancellation", status: StatusFailed, runErr: context.Canceled, wantState: ResultCanceled, wantCode: "runner_failed"},
279	-	{name: "killed", status: StatusKilled, runErr: context.Canceled, wantState: ResultCanceled},	282	+	{name: "deadline preserves recovery guidance", status: StatusFailed, runErr: context.DeadlineExceeded, wantState: ResultFailed, wantCode: "deadline_exceeded", wantOutput: "partial answer"},
			283	+	{name: "deadline overrides child error", status: StatusFailed, runErr: context.DeadlineExceeded, childCode: "context_limit", wantState: ResultFailed, wantCode: "deadline_exceeded", wantOutput: "partial answer"},
			284	+	{name: "killed", status: StatusKilled, runErr: context.Canceled, wantState: ResultCanceled, wantCode: "runner_failed"},
280		}	285		}
281		for _, tt := range tests {	286		for _, tt := range tests {
282		t.Run(tt.name, func(t *testing.T) {	287		t.Run(tt.name, func(t *testing.T) {
283		stateDir := t.TempDir()	288		stateDir := t.TempDir()
			289	+	childStatus := ResultSucceeded
			290	+	var childError *ResultError
			291	+	if tt.childCode != "" {
			292	+	childStatus = ResultFailed
			293	+	childError = &ResultError{Code: tt.childCode, Message: "child error"}
			294	+	}
284		agent := &Agent{	295		agent := &Agent{
285	-	ID: "agent-1",	296	+	ID: "agent-1",
286	-	stateDir: stateDir,	297	+	stateDir: stateDir,
			298	+	lastAssistant: tt.wantOutput,
287		result: &TurnResult{	299		result: &TurnResult{
288	-	AgentID: "agent-1", TurnID: "turn-1", Status: ResultSucceeded,	300	+	AgentID: "agent-1", TurnID: "turn-1", Status: childStatus, Error: childError,
289		},	301		},
290		}	302		}
291		supervisor := &Supervisor{}	303		supervisor := &Supervisor{}

@@ -297,6 +309,12 @@ func TestEnsureResultReconcilesChildStatusWithRunnerError(t *testing.T) {
297		if result.Error == nil {	309		if result.Error == nil {
298		t.Fatal("runner error was not recorded")	310		t.Fatal("runner error was not recorded")
299		}	311		}
			312	+	if result.Error.Code != tt.wantCode {
			313	+	t.Fatalf("result error code = %q, want %q", result.Error.Code, tt.wantCode)
			314	+	}
			315	+	if result.Output != tt.wantOutput {
			316	+	t.Fatalf("result output = %q, want %q", result.Output, tt.wantOutput)
			317	+	}
300		durable, err := readTurnResult(stateDir)	318		durable, err := readTurnResult(stateDir)
301		if err != nil {	319		if err != nil {
302		t.Fatal(err)	320		t.Fatal(err)

@@ -304,6 +322,30 @@ func TestEnsureResultReconcilesChildStatusWithRunnerError(t *testing.T) {
304		if durable.Status != tt.wantState {	322		if durable.Status != tt.wantState {
305		t.Fatalf("durable result status = %q, want %q", durable.Status, tt.wantState)	323		t.Fatalf("durable result status = %q, want %q", durable.Status, tt.wantState)
306		}	324		}
			325	+	if durable.Output != tt.wantOutput {
			326	+	t.Fatalf("durable result output = %q, want %q", durable.Output, tt.wantOutput)
			327	+	}
			328	+	if durable.Error == nil \|\| durable.Error.Code != tt.wantCode {
			329	+	t.Fatalf("durable result error = %#v, want code %q", durable.Error, tt.wantCode)
			330	+	}
307		})	331		})
308		}	332		}
309		}	333		}
			334	+
			335	+	func TestEnsureResultDoesNotBackfillSuccessfulEmptyOutput(t *testing.T) {
			336	+	stateDir := t.TempDir()
			337	+	agent := &Agent{
			338	+	ID: "agent-1",
			339	+	stateDir: stateDir,
			340	+	lastAssistant: "streamed text",
			341	+	result: &TurnResult{
			342	+	AgentID: "agent-1", TurnID: "turn-1", Status: ResultSucceeded,
			343	+	},
			344	+	}
			345	+
			346	+	(&Supervisor{}).ensureResult(agent, StatusDone, nil)
			347	+
			348	+	if result := agent.Result(); result == nil \|\| result.Output != "" {
			349	+	t.Fatalf("successful result = %#v, want intentionally empty output", result)
			350	+	}
			351	+	}

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


@@ -2,12 +2,151 @@ package subagents
2		2
3	import (	3		import (
4	"context"	4		"context"
		5	+	"errors"
5	"path/filepath"	6		"path/filepath"
6	"runtime"	7		"runtime"
7	"testing"	8		"testing"
8	"time"	9		"time"
9	)	10		)
10		11
		12	+	func TestResumeWithPromptQueuesFollowUpsForActiveWorker(t *testing.T) {
		13	+	if runtime.GOOS == "windows" {
		14	+	t.Skip("subagent inbox transport uses Unix-domain sockets")
		15	+	}
		16	+
		17	+	root := shortSocketDir(t)
		18	+	ready := make(chan struct{}, 1)
		19	+	commands := make(chan Envelope, 2)
		20	+	f := New(Config{
		21	+	Root: root, RepoRoot: root,
		22	+	NewRunner: func(a *Agent) Runner {
		23	+	return RunnerFunc(func(ctx context.Context, _ Sink) error {
		24	+	listener, err := Listen(a.InboxPath)
		25	+	if err != nil {
		26	+	return err
		27	+	}
		28	+	defer listener.Close()
		29	+	a.setProcessState(ProcessAlive)
		30	+	a.setTurnState(TurnRunning, "turn-1")
		31	+	ready <- struct{}{}
		32	+	for {
		33	+	select {
		34	+	case <-ctx.Done():
		35	+	return ctx.Err()
		36	+	case line, ok := <-listener.Lines():
		37	+	if !ok {
		38	+	return nil
		39	+	}
		40	+	command, err := ParseCommand(line)
		41	+	if err != nil {
		42	+	return err
		43	+	}
		44	+	if command.Type == CommandAgentShutdown {
		45	+	return nil
		46	+	}
		47	+	commands <- command
		48	+	}
		49	+	}
		50	+	})
		51	+	},
		52	+	})
		53	+	defer f.StopAll()
		54	+
		55	+	a, err := f.Spawn(context.Background(), "review the implementation")
		56	+	if err != nil {
		57	+	t.Fatal(err)
		58	+	}
		59	+	select {
		60	+	case <-ready:
		61	+	case <-time.After(time.Second):
		62	+	t.Fatal("active worker did not open its inbox")
		63	+	}
		64	+	canceled, cancel := context.WithCancel(context.Background())
		65	+	cancel()
		66	+	if _, err := f.ResumeWithPrompt(canceled, a.ID, "must not be accepted"); !errors.Is(err, context.Canceled) {
		67	+	t.Fatalf("canceled active follow-up error = %v, want context canceled", err)
		68	+	}
		69	+
		70	+	const (
		71	+	firstFollowUp = "Check the parser behavior."
		72	+	secondFollowUp = "Then check the error handling."
		73	+	)
		74	+	if _, err := f.ResumeWithPrompt(context.Background(), a.ID, firstFollowUp); err != nil {
		75	+	t.Fatalf("queue first active follow-up: %v", err)
		76	+	}
		77	+	if _, err := f.ResumeWithPrompt(context.Background(), a.ID, secondFollowUp); err != nil {
		78	+	t.Fatalf("queue second active follow-up: %v", err)
		79	+	}
		80	+	select {
		81	+	case command := <-commands:
		82	+	t.Fatalf("active follow-up was delivered before idle: %v", command.Type)
		83	+	default:
		84	+	}
		85	+
		86	+	persisted, err := readAgentMeta(filepath.Join(root, "agents", a.ID))
		87	+	if err != nil {
		88	+	t.Fatal(err)
		89	+	}
		90	+	if persisted.ResumePrompt != "" \|\| len(persisted.ResumeQueue) != 2 {
		91	+	t.Fatalf("active follow-ups persisted as prompt %q queue %d, want empty prompt and queue 2", persisted.ResumePrompt, len(persisted.ResumeQueue))
		92	+	}
		93	+	if firstID, secondID := persisted.ResumeQueue[0].CommandID, persisted.ResumeQueue[1].CommandID; firstID == "" \|\| secondID == "" \|\| firstID == secondID {
		94	+	t.Fatalf("queued follow-up command IDs = %q, %q; want distinct non-empty IDs", firstID, secondID)
		95	+	}
		96	+
		97	+	if err := updateAgentFromEvent(a, NewEvent(EventAgentIdle, map[string]any{"turn_id": "turn-1"})); err != nil {
		98	+	t.Fatalf("apply first idle event: %v", err)
		99	+	}
		100	+	select {
		101	+	case command := <-commands:
		102	+	var payload TurnStartPayload
		103	+	if command.Type != CommandTurnStart \|\| command.DecodePayload(&payload) != nil \|\| payload.Prompt != firstFollowUp {
		104	+	t.Fatalf("first idle delivery = type %q prompt %q, want turn start %q", command.Type, payload.Prompt, firstFollowUp)
		105	+	}
		106	+	if !payload.NewRun {
		107	+	t.Fatal("first queued follow-up did not request a fresh run budget")
		108	+	}
		109	+	case <-time.After(time.Second):
		110	+	t.Fatal("first active follow-up was not delivered at idle")
		111	+	}
		112	+	if got := a.TurnState(); got != TurnQueued {
		113	+	t.Fatalf("turn state after first queued delivery = %s, want %s", got, TurnQueued)
		114	+	}
		115	+
		116	+	if err := updateAgentFromEvent(a, NewEvent(EventTurnStarted, map[string]any{
		117	+	"turn_id": "turn-2", "step": float64(2), "lifetime_turns": 2, "current_run_turns": 1,
		118	+	})); err != nil {
		119	+	t.Fatalf("apply second turn started event: %v", err)
		120	+	}
		121	+	if err := updateAgentFromEvent(a, NewEvent(EventAgentIdle, map[string]any{"turn_id": "turn-2"})); err != nil {
		122	+	t.Fatalf("apply second idle event: %v", err)
		123	+	}
		124	+	select {
		125	+	case command := <-commands:
		126	+	var payload TurnStartPayload
		127	+	if command.Type != CommandTurnStart \|\| command.DecodePayload(&payload) != nil \|\| payload.Prompt != secondFollowUp {
		128	+	t.Fatalf("second idle delivery = type %q prompt %q, want turn start %q", command.Type, payload.Prompt, secondFollowUp)
		129	+	}
		130	+	case <-time.After(time.Second):
		131	+	t.Fatal("second active follow-up was not delivered at the next idle turn")
		132	+	}
		133	+
		134	+	persisted, err = readAgentMeta(filepath.Join(root, "agents", a.ID))
		135	+	if err != nil {
		136	+	t.Fatal(err)
		137	+	}
		138	+	if persisted.ResumePrompt != secondFollowUp \|\| len(persisted.ResumeQueue) != 0 {
		139	+	t.Fatalf("second follow-up persistence = prompt %q queue %d, want prompt %q and empty queue", persisted.ResumePrompt, len(persisted.ResumeQueue), secondFollowUp)
		140	+	}
		141	+	if persisted.ResumePromptID == "" {
		142	+	t.Fatal("promoted follow-up lost its command ID")
		143	+	}
		144	+	if err := f.Stop(a.ID); err != nil {
		145	+	t.Fatal(err)
		146	+	}
		147	+	a.Wait()
		148	+	}
		149	+
11	func TestResumeWithPromptDeliversFollowUpToIdleWorker(t *testing.T) {	150		func TestResumeWithPromptDeliversFollowUpToIdleWorker(t *testing.T) {
12	if runtime.GOOS == "windows" {	151		if runtime.GOOS == "windows" {
13	t.Skip("subagent inbox transport uses Unix-domain sockets")	152		t.Skip("subagent inbox transport uses Unix-domain sockets")

@@ -60,6 +199,7 @@ func TestResumeWithPromptDeliversFollowUpToIdleWorker(t *testing.T) {
60	case <-time.After(time.Second):	199		case <-time.After(time.Second):
61	t.Fatal("idle worker did not open its inbox")	200		t.Fatal("idle worker did not open its inbox")
62	}	201		}
		202	+	a.setTurnCounts(4, 2)
63		203
64	const followUp = "I applied your review. What do you think now?"	204		const followUp = "I applied your review. What do you think now?"
65	continued, err := f.ResumeWithPrompt(context.Background(), a.ID, followUp)	205		continued, err := f.ResumeWithPrompt(context.Background(), a.ID, followUp)

@@ -72,6 +212,12 @@ func TestResumeWithPromptDeliversFollowUpToIdleWorker(t *testing.T) {
72	if got := a.TurnState(); got != TurnQueued {	212		if got := a.TurnState(); got != TurnQueued {
73	t.Fatalf("turn state after sending follow-up = %s, want %s", got, TurnQueued)	213		t.Fatalf("turn state after sending follow-up = %s, want %s", got, TurnQueued)
74	}	214		}
		215	+	if got := a.CurrentRunTurnsValue(); got != 0 {
		216	+	t.Fatalf("current-run turns after explicit resume = %d, want 0 before turn starts", got)
		217	+	}
		218	+	if got := a.LifetimeTurnsValue(); got != 4 {
		219	+	t.Fatalf("lifetime turns after explicit resume = %d, want 4", got)
		220	+	}
75	if _, err := f.ResumeWithPrompt(context.Background(), a.ID, "duplicate follow-up"); err == nil {	221		if _, err := f.ResumeWithPrompt(context.Background(), a.ID, "duplicate follow-up"); err == nil {
76	t.Fatal("second follow-up succeeded while the first was queued")	222		t.Fatal("second follow-up succeeded while the first was queued")
77	}	223		}

@@ -87,6 +233,9 @@ func TestResumeWithPromptDeliversFollowUpToIdleWorker(t *testing.T) {
87	if payload.Prompt != followUp {	233		if payload.Prompt != followUp {
88	t.Fatalf("follow-up prompt = %q, want %q", payload.Prompt, followUp)	234		t.Fatalf("follow-up prompt = %q, want %q", payload.Prompt, followUp)
89	}	235		}
		236	+	if !payload.NewRun {
		237	+	t.Fatal("idle follow-up did not request a fresh run budget")
		238	+	}
90	case <-time.After(time.Second):	239		case <-time.After(time.Second):
91	t.Fatal("idle worker did not receive the follow-up")	240		t.Fatal("idle worker did not receive the follow-up")
92	}	241		}

M packages/agent/subagents/runner.go +246 -18


@@ -5,7 +5,9 @@ import (
5		"bytes"	5		"bytes"
6		"context"	6		"context"
7		"encoding/json"	7		"encoding/json"
			8	+	"errors"
8		"fmt"	9		"fmt"
			10	+	"math"
9		"os"	11		"os"
10		"os/exec"	12		"os/exec"
11		"path/filepath"	13		"path/filepath"

@@ -52,6 +54,11 @@ type execRunner struct {
52		// would litter the user's repo — every agent's Dir points	54		// would litter the user's repo — every agent's Dir points
53		// at it directly.	55		// at it directly.
54		SessionPath string	56		SessionPath string
			57	+
			58	+	// GracePeriod is the time a deadline-expired worker gets to handle an
			59	+	// inbox shutdown and write its session/result before the process group is
			60	+	// force-killed. Zero uses the standard ten-second cancellation grace.
			61	+	GracePeriod time.Duration
55		}	62		}
56			63
57		// subagentWorkerArgsOpts captures every dynamic input to subagentWorkerArgs.	64		// subagentWorkerArgsOpts captures every dynamic input to subagentWorkerArgs.

@@ -73,6 +80,9 @@ type subagentWorkerArgsOpts struct {
73		FastModeSet bool	80		FastModeSet bool
74		Subagent string	81		Subagent string
75		MaxTurns int	82		MaxTurns int
			83	+	LifetimeTurns int
			84	+	RunTurns int
			85	+	CountersSet bool
76		Tools []string	86		Tools []string
77		WebSearchPolicy WebSearchPolicy	87		WebSearchPolicy WebSearchPolicy
78		}	88		}

@@ -108,6 +118,9 @@ func defaultChildArgs(exe string, a *Agent, sessionPath, inboxPath string) []str
108		FastModeSet: true,	118		FastModeSet: true,
109		Subagent: a.Subagent,	119		Subagent: a.Subagent,
110		MaxTurns: a.MaxTurns,	120		MaxTurns: a.MaxTurns,
			121	+	LifetimeTurns: a.LifetimeTurnsValue(),
			122	+	RunTurns: a.CurrentRunTurnsValue(),
			123	+	CountersSet: true,
111		Tools: a.Tools,	124		Tools: a.Tools,
112		WebSearchPolicy: a.WebSearchPolicy,	125		WebSearchPolicy: a.WebSearchPolicy,
113		})	126		})

@@ -151,6 +164,12 @@ func subagentWorkerArgs(opts subagentWorkerArgsOpts) []string {
151		if opts.MaxTurns > 0 {	164		if opts.MaxTurns > 0 {
152		args = append(args, "--max-turns", fmt.Sprint(opts.MaxTurns))	165		args = append(args, "--max-turns", fmt.Sprint(opts.MaxTurns))
153		}	166		}
			167	+	if opts.CountersSet {
			168	+	args = append(args,
			169	+	"--subagent-lifetime-turns", fmt.Sprint(opts.LifetimeTurns),
			170	+	"--subagent-run-turns", fmt.Sprint(opts.RunTurns),
			171	+	)
			172	+	}
154		webSearchPolicy := childWebSearchPolicy(opts.WebSearchPolicy, opts.Subagent, opts.Tools)	173		webSearchPolicy := childWebSearchPolicy(opts.WebSearchPolicy, opts.Subagent, opts.Tools)
155		// Always propagate the final capability decision, including deny, so a	174		// Always propagate the final capability decision, including deny, so a
156		// child with no ordinary --tools list cannot re-enable web search from its	175		// child with no ordinary --tools list cannot re-enable web search from its

@@ -302,7 +321,14 @@ func (r *execRunner) Run(ctx context.Context, sink Sink) error {
302		args = defaultChildArgs(exe, r.agent, sessionPath, inboxPath)	321		args = defaultChildArgs(exe, r.agent, sessionPath, inboxPath)
303		}	322		}
304			323
305	-	cmd := exec.CommandContext(ctx, args[0], args[1:]...)	324	+	// Do not bind the process directly to ctx: CommandContext sends an
			325	+	// immediate SIGKILL at the deadline, which prevents the worker from
			326	+	// handling cancellation and persisting the session it has built so far.
			327	+	// A deadline watcher below requests the worker's graceful inbox shutdown
			328	+	// first, then force-stops it only after the bounded grace period. Use a
			329	+	// non-canceling CommandContext so configureWorkerProcess can retain its
			330	+	// Cmd.Cancel fallback without tying it to the worker lifetime context.
			331	+	cmd := exec.CommandContext(context.Background(), args[0], args[1:]...)
306		cmd.Dir = r.agent.Dir	332		cmd.Dir = r.agent.Dir
307		cmd.Env = append(workerEnvironment(r.agent.Provider),	333		cmd.Env = append(workerEnvironment(r.agent.Provider),
308		"ZUT_SUBAGENT_AGENT_ID="+r.agent.ID,	334		"ZUT_SUBAGENT_AGENT_ID="+r.agent.ID,

@@ -353,6 +379,10 @@ func (r *execRunner) Run(ctx context.Context, sink Sink) error {
353		r.agent.persistFn(r.agent)	379		r.agent.persistFn(r.agent)
354		}	380		}
355			381
			382	+	runnerDone := make(chan struct{})
			383	+	defer close(runnerDone)
			384	+	go r.stopOnContextDone(ctx, cmd, runnerDone)
			385	+
356		var logErrMu sync.Mutex	386		var logErrMu sync.Mutex
357		var logErr error	387		var logErr error
358		var stopOnLogErr sync.Once	388		var stopOnLogErr sync.Once

@@ -397,7 +427,9 @@ func (r *execRunner) Run(ctx context.Context, sink Sink) error {
397		if trimmed != "" && !truncated {	427		if trimmed != "" && !truncated {
398		if ev, ok := parseEventLine(trimmed); ok {	428		if ev, ok := parseEventLine(trimmed); ok {
399		appendLog(ev)	429		appendLog(ev)
400	-	updateAgentFromEvent(r.agent, ev)	430	+	if persistErr := updateAgentFromEvent(r.agent, ev); persistErr != nil {
			431	+	sink.Transcript("error: metadata persistence failed: " + persistErr.Error())
			432	+	}
401		applyEventToSink(ev, sink)	433		applyEventToSink(ev, sink)
402		// Fan prompt-level task completions up to any	434		// Fan prompt-level task completions up to any
403		// subscriber on the supervised Agent. The child	435		// subscriber on the supervised Agent. The child

@@ -460,12 +492,16 @@ func (r *execRunner) Run(ctx context.Context, sink Sink) error {
460		if ee, ok := err.(*exec.ExitError); ok {	492		if ee, ok := err.(*exec.ExitError); ok {
461		exit = ee.ExitCode()	493		exit = ee.ExitCode()
462		}	494		}
463	-	if err != nil && ctx.Err() != nil {	495	+	if ctxErr := ctx.Err(); ctxErr != nil {
464	-	appendLog(NewEvent("agent_stopped", map[string]any{"reason": "cancelled"}))	496	+	reason := "cancelled"
			497	+	if errors.Is(ctxErr, context.DeadlineExceeded) {
			498	+	reason = "deadline"
			499	+	}
			500	+	appendLog(NewEvent("agent_stopped", map[string]any{"reason": reason}))
465		if logErr := firstLogErr(); logErr != nil {	501		if logErr := firstLogErr(); logErr != nil {
466		return fmt.Errorf("subagent event log: %w", logErr)	502		return fmt.Errorf("subagent event log: %w", logErr)
467		}	503		}
468	-	return ctx.Err()	504	+	return ctxErr
469		}	505		}
470		if err != nil {	506		if err != nil {
471		appendLog(NewEvent("agent_stopped", map[string]any{"reason": "exit", "code": exit, "error": err.Error()}))	507		appendLog(NewEvent("agent_stopped", map[string]any{"reason": "exit", "code": exit, "error": err.Error()}))

@@ -482,6 +518,48 @@ func (r *execRunner) Run(ctx context.Context, sink Sink) error {
482		return nil	518		return nil
483		}	519		}
484			520
			521	+	// stopOnContextDone stops a worker when its run context ends. A deadline gets
			522	+	// one bounded chance to process an inbox shutdown and persist its session;
			523	+	// explicit cancellation force-stops immediately so Run cannot remain blocked.
			524	+	func (r execRunner) stopOnContextDone(ctx context.Context, cmd exec.Cmd, runnerDone <-chan struct{}) {
			525	+	select {
			526	+	case <-runnerDone:
			527	+	return
			528	+	case <-ctx.Done():
			529	+	}
			530	+	if !errors.Is(ctx.Err(), context.DeadlineExceeded) {
			531	+	if cmd.Cancel != nil {
			532	+	_ = cmd.Cancel()
			533	+	return
			534	+	}
			535	+	_ = killProcessGroup(cmd)
			536	+	return
			537	+	}
			538	+
			539	+	grace := r.GracePeriod
			540	+	if grace <= 0 {
			541	+	grace = 10 * time.Second
			542	+	}
			543	+	shutdownCtx, cancel := context.WithTimeout(context.Background(), grace)
			544	+	defer cancel()
			545	+	if r.agent != nil && r.agent.inbox != nil {
			546	+	_ = r.agent.inbox.SendCommandContext(shutdownCtx, NewCommand(
			547	+	CommandAgentShutdown, r.agent.ID, r.agent.CurrentTurnID(), AgentShutdownPayload{},
			548	+	))
			549	+	}
			550	+
			551	+	select {
			552	+	case <-runnerDone:
			553	+	return
			554	+	case <-shutdownCtx.Done():
			555	+	}
			556	+	if cmd.Cancel != nil {
			557	+	_ = cmd.Cancel()
			558	+	return
			559	+	}
			560	+	_ = killProcessGroup(cmd)
			561	+	}
			562	+
485		func workerEnvironment(provider string) []string {	563		func workerEnvironment(provider string) []string {
486		// Provider credentials are resolved by the supervisor and transferred	564		// Provider credentials are resolved by the supervisor and transferred
487		// over the child's stdin. Do not inherit API-key/token variables into the	565		// over the child's stdin. Do not inherit API-key/token variables into the

@@ -594,9 +672,71 @@ func parseEventLine(line string) (Event, bool) {
594		}, true	672		}, true
595		}	673		}
596			674
597	-	func updateAgentFromEvent(a *Agent, ev Event) {	675	+	func eventMatchesPendingResume(a *Agent, ev Event) bool {
598		if a == nil {	676		if a == nil {
599	-	return	677	+	return false
			678	+	}
			679	+	commandID, _ := ev.Data["command_id"].(string)
			680	+	if commandID == "" {
			681	+	// Protocol-v1 turn.started events predate command identities, but a
			682	+	// commandless rejection cannot be safely associated with the current
			683	+	// pending prompt and must not consume it.
			684	+	code, _ := ev.Data["code"].(string)
			685	+	return code != "turn_rejected"
			686	+	}
			687	+	expected := a.resumePromptCommandID()
			688	+	return expected == "" \|\| expected == commandID
			689	+	}
			690	+
			691	+	func eventCounter(data map[string]any, key string) (int, bool) {
			692	+	value, ok := data[key]
			693	+	if !ok {
			694	+	return 0, false
			695	+	}
			696	+	maxInt := int(^uint(0) >> 1)
			697	+	valid := func(value int64) (int, bool) {
			698	+	if value < 0 \|\| value > int64(maxInt) {
			699	+	return 0, false
			700	+	}
			701	+	return int(value), true
			702	+	}
			703	+	switch value := value.(type) {
			704	+	case int:
			705	+	if value < 0 {
			706	+	return 0, false
			707	+	}
			708	+	return value, true
			709	+	case int64:
			710	+	return valid(value)
			711	+	case uint:
			712	+	if uint64(value) > uint64(maxInt) {
			713	+	return 0, false
			714	+	}
			715	+	return int(value), true
			716	+	case uint64:
			717	+	if value > uint64(maxInt) {
			718	+	return 0, false
			719	+	}
			720	+	return int(value), true
			721	+	case float64:
			722	+	if value < 0 \|\| math.Trunc(value) != value \|\| value >= float64(maxInt)+1 {
			723	+	return 0, false
			724	+	}
			725	+	return int(value), true
			726	+	case json.Number:
			727	+	parsed, err := value.Int64()
			728	+	if err != nil {
			729	+	return 0, false
			730	+	}
			731	+	return valid(parsed)
			732	+	default:
			733	+	return 0, false
			734	+	}
			735	+	}
			736	+
			737	+	func updateAgentFromEvent(a *Agent, ev Event) error {
			738	+	if a == nil {
			739	+	return nil
600		}	740		}
601		now := ev.Time	741		now := ev.Time
602		if now.IsZero() {	742		if now.IsZero() {

@@ -604,25 +744,56 @@ func updateAgentFromEvent(a *Agent, ev Event) {
604		}	744		}
605		a.markActivity(now)	745		a.markActivity(now)
606		persist := false	746		persist := false
			747	+	notifyIdle := false
607		switch ev.Type {	748		switch ev.Type {
608		case EventAgentReady, "agent_ready":	749		case EventAgentReady, "agent_ready":
609		a.setProcessState(ProcessAlive)	750		a.setProcessState(ProcessAlive)
610	-	a.setTurnState(TurnIdle, ev.TurnID)	751	+	if lifetime, ok := eventCounter(ev.Data, "lifetime_turns"); ok {
			752	+	if currentRun, currentOK := eventCounter(ev.Data, "current_run_turns"); currentOK {
			753	+	a.setTurnCounts(lifetime, currentRun)
			754	+	}
			755	+	}
			756	+	// A resumed worker may have a durable initial follow-up in its argv.
			757	+	// Keep it queued until the worker emits its own turn.started event;
			758	+	// treating readiness as idle here could dispatch another queued prompt
			759	+	// concurrently with that initial turn.
			760	+	if prompt, _ := a.ResumePromptInfo(); prompt == "" && a.TurnState() != TurnQueued {
			761	+	a.setTurnState(TurnIdle, ev.TurnID)
			762	+	notifyIdle = true
			763	+	}
611		persist = true	764		persist = true
612		case EventAgentHeartbeat, "agent_heartbeat":	765		case EventAgentHeartbeat, "agent_heartbeat":
613		a.setProcessState(ProcessAlive)	766		a.setProcessState(ProcessAlive)
614		persist = true	767		persist = true
615	-	case EventTurnStarted, "turn_start":	768	+	case EventTurnStarted:
616	-	turnID := ev.TurnID	769	+	if !isDelegatedTurnStart(ev) {
617	-	if turnID == "" {	770	+	// Provider/model-loop turn starts are nested inside one worker
618	-	if step, ok := ev.Data["step"].(float64); ok {	771	+	// message turn and are activity only.
619	-	turnID = fmt.Sprintf("turn-%d", int(step))	772	+	a.setProcessState(ProcessAlive)
620	-	}	773	+	break
621		}	774		}
			775	+	if !eventMatchesPendingResume(a, ev) {
			776	+	break
			777	+	}
			778	+	turnID := eventTurnID(ev)
622		a.setProcessState(ProcessAlive)	779		a.setProcessState(ProcessAlive)
			780	+	if lifetime, ok := eventCounter(ev.Data, "lifetime_turns"); ok {
			781	+	if currentRun, currentOK := eventCounter(ev.Data, "current_run_turns"); currentOK {
			782	+	a.setTurnCounts(lifetime, currentRun)
			783	+	} else {
			784	+	a.incrementTurnCounts()
			785	+	}
			786	+	} else {
			787	+	a.incrementTurnCounts()
			788	+	}
623		a.setTurnState(TurnRunning, turnID)	789		a.setTurnState(TurnRunning, turnID)
624		a.clearResumePrompt()	790		a.clearResumePrompt()
625		persist = true	791		persist = true
			792	+	case "turn_start":
			793	+	// Provider/model-loop turn starts are nested inside one worker message
			794	+	// turn. They are activity only and must not consume or reset the
			795	+	// worker's lifetime or current-run budget.
			796	+	a.setProcessState(ProcessAlive)
626		case EventTurnResult, "turn_result":	797		case EventTurnResult, "turn_result":
627		if result, err := decodeTurnResultEvent(ev, a.ID, a.maxOutputBytes, a.maxOutputLines); err == nil {	798		if result, err := decodeTurnResultEvent(ev, a.ID, a.maxOutputBytes, a.maxOutputLines); err == nil {
628		a.setResult(result)	799		a.setResult(result)

@@ -653,17 +824,36 @@ func updateAgentFromEvent(a *Agent, ev Event) {
653		a.setTurnState(TurnFailed, ev.TurnID)	824		a.setTurnState(TurnFailed, ev.TurnID)
654		persist = true	825		persist = true
655		case EventAgentIdle, "agent_idle":	826		case EventAgentIdle, "agent_idle":
			827	+	if lifetime, ok := eventCounter(ev.Data, "lifetime_turns"); ok {
			828	+	if currentRun, currentOK := eventCounter(ev.Data, "current_run_turns"); currentOK {
			829	+	a.setTurnCounts(lifetime, currentRun)
			830	+	}
			831	+	}
656		a.setTurnState(TurnIdle, ev.TurnID)	832		a.setTurnState(TurnIdle, ev.TurnID)
			833	+	notifyIdle = true
657		persist = true	834		persist = true
658		case EventAgentExited, "agent_exited", "agent_stopped":	835		case EventAgentExited, "agent_exited", "agent_stopped":
659		a.setProcessState(ProcessExited)	836		a.setProcessState(ProcessExited)
660		persist = true	837		persist = true
			838	+	case "error":
			839	+	if code, _ := ev.Data["code"].(string); code == "turn_rejected" && eventMatchesPendingResume(a, ev) {
			840	+	if a.rejectActiveResumePrompt() {
			841	+	reason, _ := ev.Data["reason"].(string)
			842	+	if reason == "max_turns" {
			843	+	a.setTurnState(TurnFailed, ev.TurnID)
			844	+	} else {
			845	+	a.setTurnState(TurnIdle, ev.TurnID)
			846	+	notifyIdle = true
			847	+	}
			848	+	persist = true
			849	+	}
			850	+	}
661		case "turn_end":	851		case "turn_end":
662		// Provider/tool-loop turn_end events (for example stop=tool_use)	852		// Provider/tool-loop turn_end events (for example stop=tool_use)
663		// do not carry the daemon's prompt step and are not terminal for	853		// do not carry the daemon's prompt step and are not terminal for
664		// the delegated task. They remain in the event log, but must not	854		// the delegated task. They remain in the event log, but must not
665		// overwrite the delegated turn state or trigger persistence.	855		// overwrite the delegated turn state or trigger persistence.
666	-	if _, ok := ev.Data["step"].(float64); !ok {	856	+	if !isDelegatedTurnEnd(ev) {
667		break	857		break
668		}	858		}
669		if message, _ := ev.Data["error"].(string); message != "" {	859		if message, _ := ev.Data["error"].(string); message != "" {

@@ -674,8 +864,15 @@ func updateAgentFromEvent(a *Agent, ev Event) {
674		persist = true	864		persist = true
675		}	865		}
676		if persist && a.persistFn != nil {	866		if persist && a.persistFn != nil {
677	-	a.persistFn(a)	867	+	if err := a.persistFn(a); err != nil {
			868	+	a.recordPersistenceError(err)
			869	+	return err
			870	+	}
			871	+	}
			872	+	if notifyIdle {
			873	+	a.notifyTurnIdle()
678		}	874		}
			875	+	return nil
679		}	876		}
680			877
681		// notifyPromptTurnEnd calls Agent.OnTurnEnd only for the subagent	878		// notifyPromptTurnEnd calls Agent.OnTurnEnd only for the subagent

@@ -686,7 +883,10 @@ func notifyPromptTurnEnd(a *Agent, ev Event) {
686		if a == nil \|\| ev.Type != "turn_end" {	883		if a == nil \|\| ev.Type != "turn_end" {
687		return	884		return
688		}	885		}
689	-	step, ok := ev.Data["step"].(float64)	886	+	if !isDelegatedTurnEnd(ev) {
			887	+	return
			888	+	}
			889	+	step, ok := eventCounter(ev.Data, "step")
690		if !ok {	890		if !ok {
691		return	891		return
692		}	892		}

@@ -700,7 +900,16 @@ func notifyPromptTurnEnd(a *Agent, ev Event) {
700		return	900		return
701		}	901		}
702		a.mu.Unlock()	902		a.mu.Unlock()
703	-	go fn(int(step), errMsg)	903	+	go fn(step, errMsg)
			904	+	}
			905	+
			906	+	func isAssistantStreamBoundary(eventType string) bool {
			907	+	switch eventType {
			908	+	case EventTurnStarted, "turn_start", EventTurnResult, "turn_result", EventTurnFailed, "turn_failed", "turn_end":
			909	+	return true
			910	+	default:
			911	+	return false
			912	+	}
704		}	913		}
705			914
706		// applyEventToSink translates an Event into Sink updates. Only a	915		// applyEventToSink translates an Event into Sink updates. Only a

@@ -711,6 +920,17 @@ func applyEventToSink(ev Event, sink Sink) {
711		userMessage(string)	920		userMessage(string)
712		assistantMessage(string)	921		assistantMessage(string)
713		}	922		}
			923	+	type streamingSink interface {
			924	+	assistantDelta(string)
			925	+	}
			926	+	type streamResetSink interface {
			927	+	resetStreamingAssistant()
			928	+	}
			929	+	if isAssistantStreamBoundary(ev.Type) {
			930	+	if streaming, ok := sink.(streamResetSink); ok {
			931	+	streaming.resetStreamingAssistant()
			932	+	}
			933	+	}
714		appendMessage := func(text string, assistant bool) {	934		appendMessage := func(text string, assistant bool) {
715		if text == "" {	935		if text == "" {
716		return	936		return

@@ -731,6 +951,14 @@ func applyEventToSink(ev Event, sink Sink) {
731		}	951		}
732			952
733		switch ev.Type {	953		switch ev.Type {
			954	+	case "message.delta":
			955	+	if delta, _ := ev.Data["delta"].(string); delta != "" {
			956	+	if streaming, ok := sink.(streamingSink); ok {
			957	+	streaming.assistantDelta(delta)
			958	+	} else {
			959	+	sink.Transcript(delta)
			960	+	}
			961	+	}
734		case "assistant_message", "user_message":	962		case "assistant_message", "user_message":
735		var text []string	963		var text []string
736		if c, ok := ev.Data["content"].([]any); ok {	964		if c, ok := ev.Data["content"].([]any); ok {

M packages/agent/subagents/runner_e2e_test.go +181 -19


@@ -12,25 +12,187 @@ import (
12		"time"	12		"time"
13		)	13		)
14			14
15	-	// TestRunnerEndToEndWithStubChild is the integration test for the	15	+	type notifyingAgentSink struct {
16	-	// new daemon-mode runner. It compiles the stubchild binary in	16	+	agentSink
17	-	// testdata/cmd/stubchild, points an execRunner at it, and drives	17	+	deltas chan<- struct{}
18	-	// a Supervisor through one Spawn + one SendUserTurn + Stop cycle.	18	+	}
19	-	//	19	+
20	-	// What this proves:	20	+	func (s notifyingAgentSink) assistantDelta(text string) {
21	-	//	21	+	s.agentSink.assistantDelta(text)
22	-	// - The default argv shape (subagentWorkerArgs) is one the child can	22	+	select {
23	-	// actually parse — locks the shape against silent breakage.	23	+	case s.deltas <- struct{}{}:
24	-	// - The stdout JSONL parser ingests events and writes them to the	24	+	default:
25	-	// durable log.	25	+	}
26	-	// - applyEventToSink turns events into Activity / Transcript	26	+	}
27	-	// updates the dashboard reads.	27	+
28	-	// - The supervisor inbox dials the child's socket and a follow-up	28	+	const runnerProcessTimeout = 10 * time.Second
29	-	// line round-trips back as a user_message event.	29	+
30	-	// - Stop closes the inbox AND cancels the child's context so the	30	+	type controlledDeadlineContext struct{ done chan struct{} }
31	-	// stub exits cleanly.	31	+
32	-	//	32	+	func (c *controlledDeadlineContext) Deadline() (time.Time, bool) {
33	-	// The test is skipped on platforms without unix sockets (Windows).	33	+	return time.Now().Add(time.Hour), true
			34	+	}
			35	+	func (c *controlledDeadlineContext) Done() <-chan struct{} { return c.done }
			36	+	func (c *controlledDeadlineContext) Err() error {
			37	+	select {
			38	+	case <-c.done:
			39	+	return context.DeadlineExceeded
			40	+	default:
			41	+	return nil
			42	+	}
			43	+	}
			44	+	func (c *controlledDeadlineContext) Value(any) any { return nil }
			45	+	func (c *controlledDeadlineContext) expire() {
			46	+	select {
			47	+	case <-c.done:
			48	+	default:
			49	+	close(c.done)
			50	+	}
			51	+	}
			52	+
			53	+	// TestExecRunnerDeadlineGracefullyStopsWorkerAndPreservesStreamedOutput
			54	+	// verifies that deadline expiry shuts a worker down through its inbox rather
			55	+	// than killing it before its terminal events can be recorded.
			56	+	func TestExecRunnerDeadlineGracefullyStopsWorkerAndPreservesStreamedOutput(t *testing.T) {
			57	+	if runtime.GOOS == "windows" {
			58	+	t.Skip("unix sockets not supported")
			59	+	}
			60	+	if testing.Short() {
			61	+	t.Skip("skip end-to-end runner test in -short mode")
			62	+	}
			63	+
			64	+	exe := buildStubChild(t)
			65	+	t.Setenv("ZUT_STUB_PROTOCOL", "1")
			66	+	t.Setenv("ZUT_STUB_BLOCK_INITIAL", "1")
			67	+
			68	+	root := t.TempDir()
			69	+	inboxPath, err := inboxSocketPath(root, "deadline-test")
			70	+	if err != nil {
			71	+	t.Fatalf("inboxSocketPath: %v", err)
			72	+	}
			73	+	a := &Agent{
			74	+	ID: "deadline-test",
			75	+	Task: "long-running task",
			76	+	Dir: root,
			77	+	SessionPath: filepath.Join(root, "session.jsonl"),
			78	+	InboxPath: inboxPath,
			79	+	EventLogPath: filepath.Join(root, "events.jsonl"),
			80	+	}
			81	+	a.inbox = NewInbox(a.InboxPath)
			82	+	t.Cleanup(func() { _ = a.inbox.Close() })
			83	+
			84	+	r := &execRunner{
			85	+	agent: a,
			86	+	Command: subagentWorkerArgs(subagentWorkerArgsOpts{Exe: exe, Dir: a.Dir, SessionPath: a.SessionPath, InboxPath: a.InboxPath, Task: a.Task}),
			87	+	GracePeriod: time.Second,
			88	+	}
			89	+	ctx := &controlledDeadlineContext{done: make(chan struct{})}
			90	+	defer ctx.expire()
			91	+	deltas := make(chan struct{}, 1)
			92	+	runDone := make(chan error, 1)
			93	+	go func() { runDone <- r.Run(ctx, notifyingAgentSink{agentSink: agentSink{a: a}, deltas: deltas}) }()
			94	+	select {
			95	+	case <-deltas:
			96	+	case <-time.After(runnerProcessTimeout):
			97	+	t.Fatal("worker did not emit its initial delta")
			98	+	}
			99	+	ctx.expire()
			100	+	select {
			101	+	case err := <-runDone:
			102	+	if !errors.Is(err, context.DeadlineExceeded) {
			103	+	t.Fatalf("Run error = %v, want context deadline exceeded", err)
			104	+	}
			105	+	case <-time.After(runnerProcessTimeout):
			106	+	t.Fatal("Run did not return after deadline expiry")
			107	+	}
			108	+
			109	+	events, err := ReadEventLog(a.EventLogPath)
			110	+	if err != nil {
			111	+	t.Fatalf("ReadEventLog: %v", err)
			112	+	}
			113	+	var sawDelta, sawGracefulTurnEnd bool
			114	+	for _, event := range events {
			115	+	if event.Type == "message.delta" && event.Data["delta"] == "partial answer" {
			116	+	sawDelta = true
			117	+	}
			118	+	if event.Type == "turn_end" && event.Data["stop"] == "cancelled" {
			119	+	sawGracefulTurnEnd = true
			120	+	}
			121	+	}
			122	+	if !sawDelta \|\| !sawGracefulTurnEnd {
			123	+	t.Fatalf("deadline did not preserve a graceful partial turn: %s", formatEvents(events))
			124	+	}
			125	+
			126	+	snapshot := a.Snapshot()
			127	+	if snapshot.LastAssistant != "partial answer" {
			128	+	t.Fatalf("live partial output = %q, want %q", snapshot.LastAssistant, "partial answer")
			129	+	}
			130	+	replayed := &Agent{}
			131	+	for _, event := range events {
			132	+	replayEventTranscript(replayed, event)
			133	+	}
			134	+	if snapshot := replayed.Snapshot(); snapshot.LastAssistant != "partial answer" {
			135	+	t.Fatalf("replayed partial output = %q, want %q", snapshot.LastAssistant, "partial answer")
			136	+	}
			137	+	}
			138	+
			139	+	func TestExecRunnerCancelsBlockedWorker(t *testing.T) {
			140	+	if runtime.GOOS == "windows" {
			141	+	t.Skip("unix sockets not supported")
			142	+	}
			143	+	if testing.Short() {
			144	+	t.Skip("skip end-to-end runner test in -short mode")
			145	+	}
			146	+
			147	+	exe := buildStubChild(t)
			148	+	t.Setenv("ZUT_STUB_PROTOCOL", "1")
			149	+	t.Setenv("ZUT_STUB_BLOCK_INITIAL", "1")
			150	+
			151	+	root := t.TempDir()
			152	+	inboxPath, err := inboxSocketPath(root, "cancel-test")
			153	+	if err != nil {
			154	+	t.Fatalf("inboxSocketPath: %v", err)
			155	+	}
			156	+	a := &Agent{
			157	+	ID: "cancel-test",
			158	+	Task: "blocked task",
			159	+	Dir: root,
			160	+	SessionPath: filepath.Join(root, "session.jsonl"),
			161	+	InboxPath: inboxPath,
			162	+	EventLogPath: filepath.Join(root, "events.jsonl"),
			163	+	}
			164	+	a.inbox = NewInbox(a.InboxPath)
			165	+	t.Cleanup(func() { _ = a.inbox.Close() })
			166	+
			167	+	r := &execRunner{
			168	+	agent: a,
			169	+	Command: subagentWorkerArgs(subagentWorkerArgsOpts{Exe: exe, Dir: a.Dir, SessionPath: a.SessionPath, InboxPath: a.InboxPath, Task: a.Task}),
			170	+	}
			171	+	ctx, cancel := context.WithCancel(context.Background())
			172	+	defer cancel()
			173	+	deltas := make(chan struct{}, 1)
			174	+	runDone := make(chan error, 1)
			175	+	go func() { runDone <- r.Run(ctx, notifyingAgentSink{agentSink: agentSink{a: a}, deltas: deltas}) }()
			176	+
			177	+	select {
			178	+	case <-deltas:
			179	+	case <-time.After(runnerProcessTimeout):
			180	+	t.Fatal("worker did not emit its initial delta")
			181	+	}
			182	+	cancel()
			183	+	select {
			184	+	case err := <-runDone:
			185	+	if !errors.Is(err, context.Canceled) {
			186	+	t.Fatalf("Run error = %v, want context canceled", err)
			187	+	}
			188	+	case <-time.After(runnerProcessTimeout):
			189	+	t.Fatal("Run did not return after context cancellation")
			190	+	}
			191	+	}
			192	+
			193	+	// TestRunnerEndToEndWithStubChild drives the daemon-mode runner through an
			194	+	// initial turn, a follow-up, and a graceful stop using the stub child. It is
			195	+	// skipped on platforms without Unix sockets.
34		func TestRunnerEndToEndWithStubChild(t *testing.T) {	196		func TestRunnerEndToEndWithStubChild(t *testing.T) {
35		if runtime.GOOS == "windows" {	197		if runtime.GOOS == "windows" {
36		t.Skip("unix sockets not supported")	198		t.Skip("unix sockets not supported")

M packages/agent/subagents/runner_test.go +268 -2


@@ -58,6 +58,106 @@ func TestCredentialStdinHelperProcess(t *testing.T) {
58		os.Exit(0)	58		os.Exit(0)
59		}	59		}
60			60
			61	+	// TestMessageDeltaStreamsAndReplaysWithoutDuplicatingFinalMessage verifies
			62	+	// that the durable event stream has the same visible result while live and
			63	+	// after history replay.
			64	+	func TestMessageDeltaStreamsAndReplaysWithoutDuplicatingFinalMessage(t *testing.T) {
			65	+	events := []Event{
			66	+	NewEvent("message.delta", map[string]any{"delta": "partial "}),
			67	+	NewEvent("message.delta", map[string]any{"delta": "answer"}),
			68	+	NewEvent("assistant_message", map[string]any{"content": []any{
			69	+	map[string]any{"type": "text", "text": "partial answer"},
			70	+	}}),
			71	+	}
			72	+
			73	+	live := &Agent{transcriptLoaded: true}
			74	+	for _, event := range events {
			75	+	applyEventToSink(event, agentSink{a: live})
			76	+	}
			77	+	if got := strings.Join(live.Transcript(), "\n"); got != "partial answer" {
			78	+	t.Fatalf("live transcript = %q, want final assistant message once", got)
			79	+	}
			80	+	if got := live.Snapshot().LastAssistant; got != "partial answer" {
			81	+	t.Fatalf("live assistant output = %q, want %q", got, "partial answer")
			82	+	}
			83	+
			84	+	replayed := &Agent{transcriptLoaded: true}
			85	+	for _, event := range events {
			86	+	replayEventTranscript(replayed, event)
			87	+	}
			88	+	if got := strings.Join(replayed.Transcript(), "\n"); got != "partial answer" {
			89	+	t.Fatalf("replayed transcript = %q, want final assistant message once", got)
			90	+	}
			91	+	}
			92	+
			93	+	func TestMessageDeltaBoundsLiveProjection(t *testing.T) {
			94	+	a := &Agent{maxOutputBytes: 32, maxOutputLines: 100, transcriptLoaded: true}
			95	+	applyEventToSink(NewEvent("message.delta", map[string]any{"delta": strings.Repeat("x", 64)}), agentSink{a: a})
			96	+	applyEventToSink(NewEvent("message.delta", map[string]any{"delta": "discarded"}), agentSink{a: a})
			97	+
			98	+	a.mu.Lock()
			99	+	streamed := a.streamingAssistantText
			100	+	truncated := a.streamingAssistantTruncated
			101	+	a.mu.Unlock()
			102	+	if !truncated {
			103	+	t.Fatal("streamed output was not marked truncated")
			104	+	}
			105	+	if got := len([]byte(streamed)); got > 32 {
			106	+	t.Fatalf("streamed output length = %d, want at most 32", got)
			107	+	}
			108	+	snapshot := a.Snapshot()
			109	+	if got := snapshot.LastAssistant; got != streamed {
			110	+	t.Fatalf("live assistant output = %q, want bounded stream %q", got, streamed)
			111	+	}
			112	+	if !snapshot.OutputTruncated {
			113	+	t.Fatal("snapshot did not expose truncated streamed output")
			114	+	}
			115	+
			116	+	events := []Event{
			117	+	NewEvent(EventMessageDelta, map[string]any{"delta": "first partial"}),
			118	+	NewEvent("turn_end", map[string]any{"stop": "cancelled"}),
			119	+	NewEvent(EventMessageDelta, map[string]any{"delta": "second partial"}),
			120	+	}
			121	+	want := "first partial\nsecond partial"
			122	+	assertProjection := func(t testing.T, agent Agent) {
			123	+	t.Helper()
			124	+	if got := strings.Join(agent.Transcript(), "\n"); got != want {
			125	+	t.Fatalf("transcript = %q, want %q", got, want)
			126	+	}
			127	+	agent.mu.Lock()
			128	+	truncated := agent.streamingAssistantTruncated
			129	+	agent.mu.Unlock()
			130	+	if truncated {
			131	+	t.Fatal("fresh second-turn stream was incorrectly truncated")
			132	+	}
			133	+	}
			134	+
			135	+	live := &Agent{maxOutputBytes: 100, maxOutputLines: 100, transcriptLoaded: true}
			136	+	for _, event := range events {
			137	+	applyEventToSink(event, agentSink{a: live})
			138	+	}
			139	+	assertProjection(t, live)
			140	+
			141	+	replayed := &Agent{maxOutputBytes: 100, maxOutputLines: 100, transcriptLoaded: true}
			142	+	replayTranscriptIntoAgent(replayed, events)
			143	+	assertProjection(t, replayed)
			144	+
			145	+	legacy := &Agent{maxOutputBytes: 100, maxOutputLines: 100, transcriptLoaded: true}
			146	+	replayEventsIntoAgent(legacy, events)
			147	+	assertProjection(t, legacy)
			148	+
			149	+	truncatedTurn := &Agent{maxOutputBytes: 16, maxOutputLines: 100, transcriptLoaded: true}
			150	+	applyEventToSink(NewEvent(EventMessageDelta, map[string]any{"delta": strings.Repeat("x", 64)}), agentSink{a: truncatedTurn})
			151	+	applyEventToSink(NewEvent("turn_end", map[string]any{"stop": "cancelled"}), agentSink{a: truncatedTurn})
			152	+	truncatedTurn.mu.Lock()
			153	+	streamText := truncatedTurn.streamingAssistantText
			154	+	streamTruncated := truncatedTurn.streamingAssistantTruncated
			155	+	truncatedTurn.mu.Unlock()
			156	+	if streamText != "" \|\| streamTruncated {
			157	+	t.Fatalf("stream state after turn boundary = (%q, %v), want empty and not truncated", streamText, streamTruncated)
			158	+	}
			159	+	}
			160	+
61		func TestWorkerEnvironmentRedactsProviderSecrets(t *testing.T) {	161		func TestWorkerEnvironmentRedactsProviderSecrets(t *testing.T) {
62		t.Setenv("OPENAI_API_KEY", "openai-secret")	162		t.Setenv("OPENAI_API_KEY", "openai-secret")
63		t.Setenv("CUSTOM_PROVIDER_API_KEY", "custom-secret")	163		t.Setenv("CUSTOM_PROVIDER_API_KEY", "custom-secret")

@@ -383,11 +483,69 @@ func TestDefaultChildArgsResumeUsesFollowUpPrompt(t *testing.T) {
383		}	483		}
384		}	484		}
385			485
			486	+	func TestReadyDoesNotMarkInitialDelegatedTurnIdle(t *testing.T) {
			487	+	a := &Agent{Task: "initial delegated task"}
			488	+	a.setTurnState(TurnQueued, "")
			489	+
			490	+	if err := updateAgentFromEvent(a, NewEvent(EventAgentReady, map[string]any{"lifetime_turns": 0, "current_run_turns": 0})); err != nil {
			491	+	t.Fatal(err)
			492	+	}
			493	+	if got := a.TurnState(); got != TurnQueued {
			494	+	t.Fatalf("ready changed turn state to %s, want %s", got, TurnQueued)
			495	+	}
			496	+	if err := updateAgentFromEvent(a, NewEvent(EventTurnStarted, map[string]any{
			497	+	"turn_id": "turn-1",
			498	+	"lifetime_turns": 1,
			499	+	"current_run_turns": 1,
			500	+	})); err != nil {
			501	+	t.Fatal(err)
			502	+	}
			503	+	if got := a.TurnState(); got != TurnRunning {
			504	+	t.Fatalf("turn.started changed turn state to %s, want %s", got, TurnRunning)
			505	+	}
			506	+	}
			507	+
			508	+	func TestUpdateAgentFromEventIgnoresStaleRejectedFollowUp(t *testing.T) {
			509	+	a := &Agent{}
			510	+	a.setResumePrompt("current prompt", time.Now())
			511	+	if err := updateAgentFromEvent(a, NewEvent("error", map[string]any{
			512	+	"code": "turn_rejected", "reason": "busy", "command_id": "stale-command",
			513	+	})); err != nil {
			514	+	t.Fatal(err)
			515	+	}
			516	+	if prompt, _ := a.ResumePromptInfo(); prompt != "current prompt" {
			517	+	t.Fatalf("stale rejection changed active prompt to %q", prompt)
			518	+	}
			519	+	}
			520	+
			521	+	func TestUpdateAgentFromEventRecoversRejectedFollowUp(t *testing.T) {
			522	+	a := &Agent{}
			523	+	a.setResumePrompt("retry me", time.Now())
			524	+	a.setTurnState(TurnQueued, "turn-1")
			525	+	if err := updateAgentFromEvent(a, NewEvent("error", map[string]any{
			526	+	"code": "turn_rejected",
			527	+	"reason": "busy",
			528	+	"command_id": a.resumePromptCommandID(),
			529	+	})); err != nil {
			530	+	t.Fatal(err)
			531	+	}
			532	+	if got := a.TurnState(); got != TurnIdle {
			533	+	t.Fatalf("rejected turn state = %s, want %s", got, TurnIdle)
			534	+	}
			535	+	if prompt, _ := a.ResumePromptInfo(); prompt != "" {
			536	+	t.Fatalf("rejected prompt remained active: %q", prompt)
			537	+	}
			538	+	queued := a.resumePromptQueueSnapshot()
			539	+	if len(queued) != 1 \|\| queued[0].Prompt != "retry me" {
			540	+	t.Fatalf("rejected prompt queue = %+v, want retry me", queued)
			541	+	}
			542	+	}
			543	+
386		func TestUpdateAgentFromEventIgnoresProviderToolLoopTurnEnd(t *testing.T) {	544		func TestUpdateAgentFromEventIgnoresProviderToolLoopTurnEnd(t *testing.T) {
387		a := &Agent{}	545		a := &Agent{}
388		a.setTurnState(TurnRunning, "turn-1")	546		a.setTurnState(TurnRunning, "turn-1")
389		persisted := 0	547		persisted := 0
390	-	a.persistFn = func(*Agent) { persisted++ }	548	+	a.persistFn = func(*Agent) error { persisted++; return nil }
391			549
392		updateAgentFromEvent(a, NewEvent("turn_end", map[string]any{"stop": "tool_use"}))	550		updateAgentFromEvent(a, NewEvent("turn_end", map[string]any{"stop": "tool_use"}))
393			551

@@ -405,7 +563,7 @@ func TestUpdateAgentFromEventIgnoresProviderToolLoopTurnEnd(t *testing.T) {
405		func TestUpdateAgentFromEventPersistsTerminalTurnEndWithStep(t *testing.T) {	563		func TestUpdateAgentFromEventPersistsTerminalTurnEndWithStep(t *testing.T) {
406		a := &Agent{}	564		a := &Agent{}
407		persisted := 0	565		persisted := 0
408	-	a.persistFn = func(*Agent) { persisted++ }	566	+	a.persistFn = func(*Agent) error { persisted++; return nil }
409			567
410		updateAgentFromEvent(a, NewEvent("turn_end", map[string]any{"step": float64(2), "error": "boom"}))	568		updateAgentFromEvent(a, NewEvent("turn_end", map[string]any{"step": float64(2), "error": "boom"}))
411			569

@@ -481,6 +639,114 @@ func TestSetOnTurnEndReplaysPendingNoticesInArrivalOrder(t *testing.T) {
481		}	639		}
482		}	640		}
483			641
			642	+	func TestUpdateAgentFromEventDoesNotCountProviderTurnStarts(t *testing.T) {
			643	+	a := &Agent{}
			644	+	a.setTurnCounts(4, 2)
			645	+	a.setTurnState(TurnRunning, "turn-1")
			646	+	persisted := 0
			647	+	a.persistFn = func(*Agent) error { persisted++; return nil }
			648	+
			649	+	updateAgentFromEvent(a, NewEvent(EventTurnStarted, map[string]any{"step": float64(7), "nested_turn": true}))
			650	+
			651	+	if got := a.LifetimeTurnsValue(); got != 4 {
			652	+	t.Fatalf("lifetime turns = %d, want 4", got)
			653	+	}
			654	+	if got := a.CurrentRunTurnsValue(); got != 2 {
			655	+	t.Fatalf("current-run turns = %d, want 2", got)
			656	+	}
			657	+	if got := a.TurnState(); got != TurnRunning {
			658	+	t.Fatalf("turn state = %s, want %s", got, TurnRunning)
			659	+	}
			660	+	if persisted != 0 {
			661	+	t.Fatalf("provider turn start persisted %d times, want 0", persisted)
			662	+	}
			663	+	}
			664	+
			665	+	func TestUpdateAgentFromEventPersistsCanonicalTurnCounters(t *testing.T) {
			666	+	stateDir := t.TempDir()
			667	+	a := &Agent{ID: "counter-agent", stateDir: stateDir}
			668	+	a.persistFn = func(agent *Agent) error {
			669	+	if err := writeAgentMeta(stateDir, agent); err != nil {
			670	+	t.Errorf("write agent metadata: %v", err)
			671	+	return err
			672	+	}
			673	+	return nil
			674	+	}
			675	+
			676	+	updateAgentFromEvent(a, NewEvent(EventTurnStarted, map[string]any{
			677	+	"turn_id": "turn-3",
			678	+	"lifetime_turns": 3,
			679	+	"current_run_turns": 1,
			680	+	}))
			681	+
			682	+	meta, err := readAgentMeta(stateDir)
			683	+	if err != nil {
			684	+	t.Fatal(err)
			685	+	}
			686	+	if meta.LifetimeTurns != 3 \|\| meta.CurrentRunTurns != 1 {
			687	+	t.Fatalf("persisted counters = (%d, %d), want (3, 1)", meta.LifetimeTurns, meta.CurrentRunTurns)
			688	+	}
			689	+	if got := a.Snapshot(); got.LifetimeTurns != 3 \|\| got.CurrentRunTurns != 1 {
			690	+	t.Fatalf("snapshot counters = (%d, %d), want (3, 1)", got.LifetimeTurns, got.CurrentRunTurns)
			691	+	}
			692	+	}
			693	+
			694	+	func TestRecordPersistenceErrorPreservesFirstFailure(t *testing.T) {
			695	+	a := &Agent{}
			696	+	a.recordPersistenceError(fmt.Errorf("first failure"))
			697	+	a.recordPersistenceError(fmt.Errorf("later failure"))
			698	+	if got := a.Snapshot().Err; !strings.Contains(got, "first failure") \|\| strings.Contains(got, "later failure") {
			699	+	t.Fatalf("recorded persistence error = %q, want only first failure", got)
			700	+	}
			701	+	}
			702	+
			703	+	func TestRestoreResumePromptPreservesCommandIdentity(t *testing.T) {
			704	+	a := &Agent{}
			705	+	a.setResumePrompt("old prompt", time.Now())
			706	+	oldID := a.resumePromptCommandID()
			707	+	previous := a.setResumePrompt("new prompt", time.Now())
			708	+	a.restoreResumePrompt(previous)
			709	+	if got := a.resumePromptCommandID(); got != oldID {
			710	+	t.Fatalf("restored command ID = %q, want %q", got, oldID)
			711	+	}
			712	+	}
			713	+
			714	+	func TestEventMatchesPendingResumeRejectsIdentityLessRejection(t *testing.T) {
			715	+	a := &Agent{resumePromptID: "command-1"}
			716	+	if eventMatchesPendingResume(a, Event{Type: "error", Data: map[string]any{"code": "turn_rejected"}}) {
			717	+	t.Fatal("identity-less turn rejection matched a pending prompt")
			718	+	}
			719	+	if !eventMatchesPendingResume(a, Event{Type: EventTurnStarted, Data: map[string]any{}}) {
			720	+	t.Fatal("identity-less legacy turn.started did not match a pending prompt")
			721	+	}
			722	+	if !eventMatchesPendingResume(a, Event{Type: "error", Data: map[string]any{"code": "turn_rejected", "command_id": "command-1"}}) {
			723	+	t.Fatal("matching turn rejection did not match a pending prompt")
			724	+	}
			725	+	}
			726	+
			727	+	func TestEventCounterRejectsNegativeFractionalAndOverflowValues(t *testing.T) {
			728	+	cases := []struct {
			729	+	name string
			730	+	value any
			731	+	ok bool
			732	+	}{
			733	+	{name: "valid integer", value: float64(3), ok: true},
			734	+	{name: "negative integer", value: int64(-1)},
			735	+	{name: "fractional float", value: 1.5},
			736	+	{name: "negative float", value: -1.0},
			737	+	{name: "fractional json number", value: json.Number("1.5")},
			738	+	{name: "overflow float", value: float64(^uint(0) >> 1)},
			739	+	}
			740	+	for _, tc := range cases {
			741	+	t.Run(tc.name, func(t *testing.T) {
			742	+	got, ok := eventCounter(map[string]any{"counter": tc.value}, "counter")
			743	+	if ok != tc.ok {
			744	+	t.Fatalf("eventCounter ok = %t, want %t (value %v, got %d)", ok, tc.ok, tc.value, got)
			745	+	}
			746	+	})
			747	+	}
			748	+	}
			749	+
484		func indexOf(xs []string, want string) int {	750		func indexOf(xs []string, want string) int {
485		for i, x := range xs {	751		for i, x := range xs {
486		if x == want {	752		if x == want {

M packages/agent/subagents/scheduler.go +17 -6

 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 		a.activity = "starting"
 		a.mu.Unlock()
 		a.setProcessState(ProcessStarting)
-		a.setTurnState(TurnIdle, "")
+		prompt, _ := a.ResumePromptInfo()
+		initialTurn := (!a.Resuming && strings.TrimSpace(a.Task) != "") || prompt != ""
+		if initialTurn {
+			a.setTurnState(TurnQueued, "")
+		} else {
+			a.setTurnState(TurnIdle, "")
+		}
 		a.incrementAttempt()
 		f.active++
 	f.schedule()
 }
-func (f *Supervisor) persistAgent(a *Agent) {
+func (f *Supervisor) persistAgent(a *Agent) error {
 	if a == nil {
-		return
+		return errors.New("subagents: nil agent")
 	}
 	stateDir := a.stateDirectory(f.cfg.Root)
-	if _, err := os.Stat(stateDir); err != nil {
+	if err := writeAgentMeta(stateDir, a); err != nil {
-		return
+		// Lifecycle callbacks cannot all return an error to their caller. Keep
+		// the failure visible in the agent snapshot instead of silently
+		// allowing a queued prompt or counter to disappear on restart.
+		a.recordPersistenceError(err)
+		return err
 	}
-	_ = writeAgentMeta(stateDir, a)
+	return nil
 }

M packages/agent/subagents/supervisor.go +14 -3

 	}
 	if cfg.NewRunner == nil {
 		cfg.NewRunner = func(a *Agent) Runner {
-			return &execRunner{agent: a, resolveCredential: cfg.ResolveCredential}
+			return &execRunner{
+				agent:             a,
+				resolveCredential: cfg.ResolveCredential,
+				GracePeriod:       cfg.Policy.CancelGracePeriod,
+			}
 		}
 	}
 	cfg.Policy.normalize()
 	}
 	a.ctx, a.cancel = runCtx, cancel
 	a.persistFn = f.persistAgent
+	a.setOnTurnIdle(func() { f.dispatchQueuedResumeWithTimeout(a) })
 	a.workspaceCleanup = func() error { return workspace.Cleanup(context.Background()) }
 	a.workspaceCapture = func() (WorkspaceCapture, error) { return workspace.Capture(context.Background()) }
 	a.runner = f.cfg.NewRunner(a)
 	ProcessState    ProcessState
 	TurnState       TurnState
 	CurrentTurnID   string
+	LifetimeTurns   int
+	CurrentRunTurns int
 	Attempt         int
 	Activity        string
 	Started         time.Time
 	status := a.status
 	activity := a.activity
 	lastAssistant := a.lastAssistant
+	outputTruncated := a.outputTruncated || a.streamingAssistantTruncated
 	finished := a.finished
 	a.mu.Unlock()
 	processState := a.processState
 	turnState := a.turnState
 	currentTurnID := a.currentTurnID
+	lifetimeTurns := a.LifetimeTurns
+	currentRunTurns := a.CurrentRunTurns
 	attempt := a.Attempt
 	lastActivity := a.lastActivity
 	updatedAt := a.updatedAt
 	resultRef := a.resultRef
 	patchRef := a.patchRef
 	changedFiles := append([]string(nil), a.changedFiles...)
-	outputTruncated := a.outputTruncated
 	a.lifecycleMu.Unlock()
 	return AgentSnapshot{
 		ID: a.ID, Task: a.Task, Dir: a.Dir,
 		Status: status, ProcessState: processState, TurnState: turnState,
-		CurrentTurnID: currentTurnID, Attempt: attempt, Activity: activity,
+		CurrentTurnID: currentTurnID, LifetimeTurns: lifetimeTurns, CurrentRunTurns: currentRunTurns, Attempt: attempt, Activity: activity,
 		Started: a.Started, Finished: finished, CreatedAt: a.Started, UpdatedAt: updatedAt, LastActivity: lastActivity,
 		Err: errStr, Tail: tail, Lines: lines,
 		LastAssistant: lastAssistant, Result: result, ResultRef: resultRef,
 }
 func (s agentSink) userMessage(text string)      { s.a.appendUserMessage(text) }
 func (s agentSink) assistantMessage(text string) { s.a.appendAssistantMessage(text) }
+func (s agentSink) assistantDelta(text string)   { s.a.appendAssistantDelta(text) }
+func (s agentSink) resetStreamingAssistant()     { s.a.resetStreamingAssistant() }
 func truncate(s string, n int) string {
 	runes := []rune(s)

M packages/agent/subagents/testdata/cmd/stubchild/main.go +20 -1


@@ -72,8 +72,20 @@ func main() {
72			72
73		// Initial task lives in the positional. Process it as the first	73		// Initial task lives in the positional. Process it as the first
74		// user turn so the supervisor's "initial task" path is exercised.	74		// user turn so the supervisor's "initial task" path is exercised.
			75	+	initialTurnOpen := false
75		if task := flag.Arg(0); task != "" {	76		if task := flag.Arg(0); task != "" {
76	-	runTurn(emit, task, 0)	77	+	if os.Getenv("ZUT_STUB_BLOCK_INITIAL") == "1" {
			78	+	initialTurnOpen = true
			79	+	emit("turn_start", map[string]any{"step": 0})
			80	+	emit("user_message", map[string]any{
			81	+	"content": []any{
			82	+	map[string]any{"type": "text", "text": task},
			83	+	},
			84	+	})
			85	+	emit("message.delta", map[string]any{"delta": "partial answer"})
			86	+	} else {
			87	+	runTurn(emit, task, 0)
			88	+	}
77		}	89		}
78			90
79		turn := 1	91		turn := 1

@@ -91,10 +103,17 @@ func main() {
91		if parseErr == nil {	103		if parseErr == nil {
92		switch command.Type {	104		switch command.Type {
93		case subagents.CommandAgentShutdown:	105		case subagents.CommandAgentShutdown:
			106	+	if initialTurnOpen {
			107	+	emit("turn_end", map[string]any{"stop": "cancelled"})
			108	+	initialTurnOpen = false
			109	+	}
94		emit("agent_stopped", map[string]any{"reason": "shutdown"})	110		emit("agent_stopped", map[string]any{"reason": "shutdown"})
95		_ = c.Close()	111		_ = c.Close()
96		return	112		return
97		case subagents.CommandTurnCancel:	113		case subagents.CommandTurnCancel:
			114	+	if initialTurnOpen {
			115	+	initialTurnOpen = false
			116	+	}
98		emit("turn_end", map[string]any{"stop": "cancelled"})	117		emit("turn_end", map[string]any{"stop": "cancelled"})
99		case subagents.CommandTurnStart:	118		case subagents.CommandTurnStart:
100		var payload subagents.TurnStartPayload	119		var payload subagents.TurnStartPayload

A packages/agent/subagents/turn_classification.go +93 -0

@@ -0,0 +1,93 @@
	1	+	package subagents
	2	+
	3	+	import "fmt"
	4	+
	5	+	// turnEventClass identifies the boundary that owns a turn event. The worker
	6	+	// daemon's turn.started event is the delegated message boundary; provider
	7	+	// turn_start events are nested model-loop activity. New workers carry stable
	8	+	// lifetime/current counters on the delegated boundary and nested_turn on the
	9	+	// provider boundary. The fallbacks preserve protocol-v1 logs, which used
	10	+	// turn.started without counters for delegated turns and turn_start for nested
	11	+	// turns.
	12	+	type turnEventClass uint8
	13	+
	14	+	const (
	15	+	turnEventUnknown turnEventClass = iota
	16	+	turnEventDelegated
	17	+	turnEventNested
	18	+	)
	19	+
	20	+	func classifyTurnEvent(ev Event) turnEventClass {
	21	+	if nested, ok := ev.Data["nested_turn"].(bool); ok && nested {
	22	+	return turnEventNested
	23	+	}
	24	+	switch ev.Type {
	25	+	case "turn_start":
	26	+	return turnEventNested
	27	+	case EventTurnStarted:
	28	+	// v1 turn.started without counters is the delegated boundary. A
	29	+	// current worker marks nested canonical events explicitly above.
	30	+	return turnEventDelegated
	31	+	case "turn_end":
	32	+	if _, ok := eventCounter(ev.Data, "step"); ok {
	33	+	return turnEventDelegated
	34	+	}
	35	+	return turnEventNested
	36	+	}
	37	+	return turnEventUnknown
	38	+	}
	39	+
	40	+	func isDelegatedTurnStart(ev Event) bool {
	41	+	return ev.Type == EventTurnStarted && classifyTurnEvent(ev) == turnEventDelegated
	42	+	}
	43	+
	44	+	// IsDelegatedTurnStart is shared with the worker's replay bootstrap so live,
	45	+	// replayed, and protocol-v1 event handling use the same boundary rules.
	46	+	func IsDelegatedTurnStart(ev Event) bool {
	47	+	return isDelegatedTurnStart(ev)
	48	+	}
	49	+
	50	+	func isDelegatedTurnEnd(ev Event) bool {
	51	+	return ev.Type == "turn_end" && classifyTurnEvent(ev) == turnEventDelegated
	52	+	}
	53	+
	54	+	func eventTurnID(ev Event) string {
	55	+	if ev.TurnID != "" {
	56	+	return ev.TurnID
	57	+	}
	58	+	if step, ok := eventCounter(ev.Data, "step"); ok {
	59	+	return fmt.Sprintf("turn-%d", step)
	60	+	}
	61	+	return ""
	62	+	}
	63	+
	64	+	func userMessageText(ev Event) string {
	65	+	if ev.Type != "user_message" {
	66	+	return ""
	67	+	}
	68	+	content := ev.Data["content"]
	69	+	var text string
	70	+	appendBlock := func(fields map[string]any) {
	71	+	if typ, _ := fields["type"].(string); typ == "text" {
	72	+	if value, _ := fields["text"].(string); value != "" {
	73	+	if text != "" {
	74	+	text += "\n"
	75	+	}
	76	+	text += value
	77	+	}
	78	+	}
	79	+	}
	80	+	switch blocks := content.(type) {
	81	+	case []any:
	82	+	for _, block := range blocks {
	83	+	if fields, ok := block.(map[string]any); ok {
	84	+	appendBlock(fields)
	85	+	}
	86	+	}
	87	+	case []map[string]any:
	88	+	for _, fields := range blocks {
	89	+	appendBlock(fields)
	90	+	}
	91	+	}
	92	+	return text
	93	+	}

A packages/agent/subagents/turn_classification_test.go +63 -0

@@ -0,0 +1,63 @@
	1	+	package subagents
	2	+
	3	+	import (
	4	+	"testing"
	5	+	"time"
	6	+	)
	7	+
	8	+	func TestTurnClassificationUsesStableBoundaryFieldsAcrossProtocolVersions(t *testing.T) {
	9	+	cases := []struct {
	10	+	name string
	11	+	event Event
	12	+	class turnEventClass
	13	+	delegated bool
	14	+	}{
	15	+	{
	16	+	name: "current delegated",
	17	+	event: NewEvent(EventTurnStarted, map[string]any{
	18	+	"lifetime_turns": 4,
	19	+	"current_run_turns": 2,
	20	+	}),
	21	+	class: turnEventDelegated,
	22	+	delegated: true,
	23	+	},
	24	+	{
	25	+	name: "current nested",
	26	+	event: NewEvent(EventTurnStarted, map[string]any{
	27	+	"nested_turn": true,
	28	+	"step": 3,
	29	+	}),
	30	+	class: turnEventNested,
	31	+	},
	32	+	{
	33	+	name: "protocol v1 delegated fallback",
	34	+	event: Event{Type: EventTurnStarted, Version: 1, Time: time.Now()},
	35	+	class: turnEventDelegated,
	36	+	delegated: true,
	37	+	},
	38	+	{
	39	+	name: "protocol v1 nested turn_start",
	40	+	event: Event{Type: "turn_start", Version: 1, Time: time.Now()},
	41	+	class: turnEventNested,
	42	+	},
	43	+	}
	44	+	for _, tc := range cases {
	45	+	t.Run(tc.name, func(t *testing.T) {
	46	+	if got := classifyTurnEvent(tc.event); got != tc.class {
	47	+	t.Fatalf("classifyTurnEvent = %d, want %d", got, tc.class)
	48	+	}
	49	+	if got := isDelegatedTurnStart(tc.event); got != tc.delegated {
	50	+	t.Fatalf("isDelegatedTurnStart = %v, want %v", got, tc.delegated)
	51	+	}
	52	+	})
	53	+	}
	54	+	}
	55	+
	56	+	func TestTurnClassificationKeepsNestedAndDelegatedEndsSeparate(t *testing.T) {
	57	+	if isDelegatedTurnEnd(NewEvent("turn_end", map[string]any{"stop": "tool_use"})) {
	58	+	t.Fatal("provider turn_end was classified as delegated")
	59	+	}
	60	+	if !isDelegatedTurnEnd(NewEvent("turn_end", map[string]any{"step": 2})) {
	61	+	t.Fatal("worker turn_end was not classified as delegated")
	62	+	}
	63	+	}

M packages/agent/tools/create_worktree.go +9 -7

 )
 const (
-	worktreesIgnoreEntry         = "/.worktrees/"
+	worktreesIgnoreEntry           = "/.worktrees/"
-	defaultWorktreeRoot          = ".worktrees"
+	worktreesUnanchoredIgnoreEntry = ".worktrees/"
-	worktreeConfigKey            = "zut.worktrees.path"
+	defaultWorktreeRoot            = ".worktrees"
-	maxCreateWorktreeGitOutput   = 64 * 1024
+	worktreeConfigKey              = "zut.worktrees.path"
-	maxCreateWorktreeIgnoreBytes = 1 << 20
+	maxCreateWorktreeGitOutput     = 64 * 1024
+	maxCreateWorktreeIgnoreBytes   = 1 << 20
 )
 var createWorktreeOperationMu sync.Mutex
 		if err != nil {
 			return createWorktreePlan{}, fmt.Errorf("create_worktree: read .gitignore: %w", err)
 		}
-		ignoreAction = "already contains " + worktreesIgnoreEntry
+		ignoreAction = "already ignores " + defaultWorktreeRoot + "/"
 		if ignore.changed {
 			ignoreAction = "add " + worktreesIgnoreEntry
 		}
 		return worktreesIgnoreUpdate{}, err
 	}
 	for _, line := range strings.Split(string(contents), "\n") {
-		if strings.TrimSuffix(line, "\r") == worktreesIgnoreEntry {
+		switch strings.TrimSuffix(line, "\r") {
+		case worktreesIgnoreEntry, worktreesUnanchoredIgnoreEntry:
 			return worktreesIgnoreUpdate{path: path, before: contents, existed: existed, mode: mode}, nil
 		}
 	}

M packages/agent/tools/create_worktree_test.go +70 -0


@@ -431,6 +431,76 @@ func TestExecuteCreateWorktreePlanRollsBackBootstrapConfigOnIgnoreFailure(t *tes
431	}	431		}
432	}	432		}
433		433
		434	+	func TestCreateWorktreeAcceptsViableGitignoreEntries(t *testing.T) {
		435	+	if _, err := exec.LookPath("git"); err != nil {
		436	+	t.Skip("git is required")
		437	+	}
		438	+	for _, test := range []struct {
		439	+	name string
		440	+	entry string
		441	+	}{
		442	+	{name: "root-anchored", entry: worktreesIgnoreEntry},
		443	+	{name: "unanchored", entry: worktreesUnanchoredIgnoreEntry},
		444	+	} {
		445	+	t.Run(test.name, func(t *testing.T) {
		446	+	repo := initWorktreeTestRepo(t)
		447	+	ignorePath := filepath.Join(repo, ".gitignore")
		448	+	before := []byte(test.entry + "\n")
		449	+	if err := os.WriteFile(ignorePath, before, 0o644); err != nil {
		450	+	t.Fatal(err)
		451	+	}
		452	+	tool := newCreateWorktreeTestTool(repo)
		453	+	args := mustJSON(t, map[string]string{
		454	+	"branch": "feature/" + test.name + "-ignore",
		455	+	"bootstrap_root": defaultWorktreeRoot,
		456	+	})
		457	+
		458	+	result, err := tool.Execute(context.Background(), args, nil)
		459	+	if err != nil {
		460	+	t.Fatal(err)
		461	+	}
		462	+	text := result.Content[0].(provider.TextBlock).Text
		463	+	if !strings.Contains(text, ".gitignore: already ignores .worktrees/") {
		464	+	t.Fatalf("result did not recognize existing ignore entry:\n%s", text)
		465	+	}
		466	+	ignore, err := os.ReadFile(ignorePath)
		467	+	if err != nil {
		468	+	t.Fatal(err)
		469	+	}
		470	+	if string(ignore) != string(before) {
		471	+	t.Fatalf(".gitignore changed from %q to %q", before, ignore)
		472	+	}
		473	+	})
		474	+	}
		475	+	}
		476	+
		477	+	func TestNewWorktreesIgnoreUpdateRejectsLookalikeEntries(t *testing.T) {
		478	+	for _, entry := range []string{
		479	+	"!.worktrees/\n",
		480	+	"nested/.worktrees/\n",
		481	+	"#.worktrees/\n",
		482	+	".worktrees-other/\n",
		483	+	} {
		484	+	t.Run(strings.TrimSpace(entry), func(t *testing.T) {
		485	+	ignorePath := filepath.Join(t.TempDir(), ".gitignore")
		486	+	if err := os.WriteFile(ignorePath, []byte(entry), 0o644); err != nil {
		487	+	t.Fatal(err)
		488	+	}
		489	+
		490	+	update, err := newWorktreesIgnoreUpdate(ignorePath)
		491	+	if err != nil {
		492	+	t.Fatal(err)
		493	+	}
		494	+	if !update.changed {
		495	+	t.Fatalf("entry %q was treated as ignoring the root .worktrees directory", strings.TrimSpace(entry))
		496	+	}
		497	+	if got, want := string(update.after), entry+worktreesIgnoreEntry+"\n"; got != want {
		498	+	t.Fatalf("updated .gitignore = %q, want %q", got, want)
		499	+	}
		500	+	})
		501	+	}
		502	+	}
		503	+
434	func TestCreateWorktreePreservesGitignoreLineEndings(t *testing.T) {	504		func TestCreateWorktreePreservesGitignoreLineEndings(t *testing.T) {
435	if _, err := exec.LookPath("git"); err != nil {	505		if _, err := exec.LookPath("git"); err != nil {
436	t.Skip("git is required")	506		t.Skip("git is required")

M packages/agent/tools/subagent_resume.go +8 -6

 	"github.com/bnema/zut/packages/core"
 )
-// SubagentResumeTool gives a completed or stopped sub-agent a follow-up turn
+// SubagentResumeTool gives a sub-agent a follow-up turn while preserving its
-// while preserving its existing session context. For an idle live worker, the
+// existing session context. Every explicit follow-up starts a fresh max_turns
-// follow-up is delivered directly. For a terminal worker, the supervisor
+// budget. For an idle live worker, the follow-up is delivered directly; for an
-// restarts the retained session with the follow-up as its initial turn.
+// active live worker, it is queued for the next available message turn; for a
+// terminal worker, the supervisor restarts the retained session with the
+// follow-up as its initial turn.
 type SubagentResumeTool struct {
 	Supervisor *subagents.Supervisor
 	Enabled    func() bool
 func (t *SubagentResumeTool) Name() string { return "subagent_resume" }
 func (t *SubagentResumeTool) Description() string {
-	return "Send a follow-up to an idle sub-agent, or restart a stopped one with its prior session context preserved."
+	return "Continue a sub-agent with a fresh turn budget and its retained session; deliver immediately when idle, queue while active, or restart a stopped worker."
 }
 func (t *SubagentResumeTool) Schema() json.RawMessage {
 		return protocolToolError(prefix + ": subagent supervisor not available in this mode")
 	}
 	if t.Enabled == nil || !t.Enabled() {
-		return protocolToolError(prefix + ": auto-subagents is disabled. Ask the user to enable it from /settings before managing workers.")
+		return protocolToolError(prefix + ": subagent management is unavailable in this mode")
 	}
 	var args subagentResumeArgs

M packages/agent/tools/subagent_spawn.go +8 -10

 // turn continues uninterrupted. The user can monitor / chat with the
 // spawned agent via /subagents.
 //
-// Gated by the auto_subagents_enabled config flag at call time so a user
+// Available when the host's launch-time tool policy permits delegation. The
-// can flip it off mid-session and the next call refuses cleanly
+// primary-agent prompt decides whether delegation is proactive or only on an
-// without re-registering the tool.
+// explicit user request.
 type SubagentSpawnTool struct {
-	// Supervisor is the supervisor used to spawn agents. Nil means
+	// Supervisor is the supervisor used to spawn agents. Nil means subagents
-	// "auto-subagents not available in this mode" and the tool always
+	// are unavailable in this mode and the tool always errors.
-	// errors.
 	Supervisor *subagents.Supervisor
-	// Enabled reads the live config flag. Lets users toggle from
+	// Enabled reports whether the host currently exposes this tool. When nil,
-	// /settings without rebuilding the agent. When nil, the tool
+	// the tool is treated as disabled.
-	// is treated as disabled.
 	Enabled func() bool
 	// DefaultModel and DefaultProvider return the host agent's resolved
 		return protocolToolError(prefix + ": subagent supervisor not available in this mode")
 	}
 	if t.Enabled == nil || !t.Enabled() {
-		return protocolToolError(prefix + ": auto-subagents is disabled. Ask the user to enable it from /settings before delegating sub-tasks.")
+		return protocolToolError(prefix + ": subagent delegation is unavailable in this mode")
 	}
 	var a subagentSpawnArgs
 	if err := json.Unmarshal(raw, &a); err != nil {

M packages/agent/tools/subagent_status.go +21 -17


@@ -34,15 +34,17 @@ type subagentStatusResponse struct {
34		}	34		}
35			35
36		type subagentStatusEntry struct {	36		type subagentStatusEntry struct {
37	-	ID string `json:"agent_id"`	37	+	ID string `json:"agent_id"`
38	-	State string `json:"state"`	38	+	State string `json:"state"`
39	-	ProcessState string `json:"process_state"`	39	+	ProcessState string `json:"process_state"`
40	-	TurnState string `json:"turn_state"`	40	+	TurnState string `json:"turn_state"`
41	-	StartedAt time.Time `json:"started_at"`	41	+	LifetimeTurns int `json:"lifetime_turns"`
42	-	UpdatedAt time.Time `json:"updated_at"`	42	+	CurrentRunTurns int `json:"current_run_turns"`
43	-	FinishedAt *time.Time `json:"finished_at,omitempty"`	43	+	StartedAt time.Time `json:"started_at"`
44	-	TaskSummary string `json:"task_summary,omitempty"`	44	+	UpdatedAt time.Time `json:"updated_at"`
45	-	Result *subagentStatusResult `json:"result,omitempty"`	45	+	FinishedAt *time.Time `json:"finished_at,omitempty"`
			46	+	TaskSummary string `json:"task_summary,omitempty"`
			47	+	Result *subagentStatusResult `json:"result,omitempty"`
46		}	48		}
47			49
48		type subagentStatusResult struct {	50		type subagentStatusResult struct {

@@ -84,7 +86,7 @@ func (t *SubagentStatusTool) Execute(ctx context.Context, raw json.RawMessage, _
84		return protocolToolError(prefix + ": subagent supervisor not available in this mode")	86		return protocolToolError(prefix + ": subagent supervisor not available in this mode")
85		}	87		}
86		if t.Enabled == nil \|\| !t.Enabled() {	88		if t.Enabled == nil \|\| !t.Enabled() {
87	-	return protocolToolError(prefix + ": auto-subagents is disabled. Ask the user to enable it from /settings before querying workers.")	89	+	return protocolToolError(prefix + ": subagent status is unavailable in this mode")
88		}	90		}
89			91
90		var args subagentStatusArgs	92		var args subagentStatusArgs

@@ -132,13 +134,15 @@ func findSubagentStatusSnapshot(snapshots []subagents.AgentSnapshot, id string)
132			134
133		func publicSubagentStatus(snapshot subagents.AgentSnapshot) subagentStatusEntry {	135		func publicSubagentStatus(snapshot subagents.AgentSnapshot) subagentStatusEntry {
134		entry := subagentStatusEntry{	136		entry := subagentStatusEntry{
135	-	ID: snapshot.ID,	137	+	ID: snapshot.ID,
136	-	State: publicSubagentState(snapshot),	138	+	State: publicSubagentState(snapshot),
137	-	ProcessState: string(snapshot.ProcessState),	139	+	ProcessState: string(snapshot.ProcessState),
138	-	TurnState: string(snapshot.TurnState),	140	+	TurnState: string(snapshot.TurnState),
139	-	StartedAt: snapshot.Started,	141	+	LifetimeTurns: snapshot.LifetimeTurns,
140	-	UpdatedAt: snapshot.UpdatedAt,	142	+	CurrentRunTurns: snapshot.CurrentRunTurns,
141	-	TaskSummary: summarizeSubagentTask(snapshot.Task),	143	+	StartedAt: snapshot.Started,
			144	+	UpdatedAt: snapshot.UpdatedAt,
			145	+	TaskSummary: summarizeSubagentTask(snapshot.Task),
142		}	146		}
143		if !snapshot.Finished.IsZero() {	147		if !snapshot.Finished.IsZero() {
144		finished := snapshot.Finished	148		finished := snapshot.Finished

M packages/agent/tools/subagent_status_test.go +22 -0


@@ -39,6 +39,28 @@ func (r statusTestRunner) Run(ctx context.Context, sink subagents.Sink) error {
39	}	39		}
40	}	40		}
41		41
		42	+	func TestSubagentStatusIncludesTurnCounters(t *testing.T) {
		43	+	entry := publicSubagentStatus(subagents.AgentSnapshot{
		44	+	ID: "counter-agent",
		45	+	LifetimeTurns: 7,
		46	+	CurrentRunTurns: 2,
		47	+	})
		48	+	if entry.LifetimeTurns != 7 \|\| entry.CurrentRunTurns != 2 {
		49	+	t.Fatalf("status counters = (%d, %d), want (7, 2)", entry.LifetimeTurns, entry.CurrentRunTurns)
		50	+	}
		51	+	encoded, err := json.Marshal(entry)
		52	+	if err != nil {
		53	+	t.Fatal(err)
		54	+	}
		55	+	var fields map[string]any
		56	+	if err := json.Unmarshal(encoded, &fields); err != nil {
		57	+	t.Fatal(err)
		58	+	}
		59	+	if fields["lifetime_turns"] != float64(7) \|\| fields["current_run_turns"] != float64(2) {
		60	+	t.Fatalf("encoded status counters = %#v", fields)
		61	+	}
		62	+	}
		63	+
42	func TestSubagentStatusSchemaHasOptionalAgentID(t *testing.T) {	64		func TestSubagentStatusSchemaHasOptionalAgentID(t *testing.T) {
43	var schema struct {	65		var schema struct {
44	Type string `json:"type"`	66		Type string `json:"type"`

M packages/agent/tools/subagent_stop.go +1 -1


@@ -67,7 +67,7 @@ func (t *SubagentStopTool) Execute(ctx context.Context, raw json.RawMessage, _ f
67		return protocolToolError(prefix + ": subagent supervisor not available in this mode")	67		return protocolToolError(prefix + ": subagent supervisor not available in this mode")
68		}	68		}
69		if t.Enabled == nil \|\| !t.Enabled() {	69		if t.Enabled == nil \|\| !t.Enabled() {
70	-	return protocolToolError(prefix + ": auto-subagents is disabled. Ask the user to enable it from /settings before managing workers.")	70	+	return protocolToolError(prefix + ": subagent management is unavailable in this mode")
71		}	71		}
72			72
73		var args subagentStopArgs	73		var args subagentStopArgs

M packages/core/session.go +13 -0


@@ -1187,6 +1187,19 @@ func (s *Session) AppendMessage(m provider.Message) error {
1187	return nil	1187		return nil
1188	}	1188		}
1189		1189
		1190	+	// Sync flushes the session file's bytes through the filesystem. Interactive
		1191	+	// hosts use this at acknowledgement boundaries where a crash must not make a
		1192	+	// prompt look accepted before its user message is recoverable.
		1193	+	func (s *Session) Sync() error {
		1194	+	if s == nil \|\| s.writer == nil {
		1195	+	return nil
		1196	+	}
		1197	+	if err := s.buf.Flush(); err != nil {
		1198	+	return err
		1199	+	}
		1200	+	return s.writer.Sync()
		1201	+	}
		1202	+
1190	// AppendCompaction writes a checkpoint that replaces all earlier	1203		// AppendCompaction writes a checkpoint that replaces all earlier
1191	// transcript rows when the session is resumed. The old rows remain in	1204		// transcript rows when the session is resumed. The old rows remain in
1192	// the JSONL file for audit/export, while loaders use the latest	1205		// the JSONL file for audit/export, while loaders use the latest

M packages/tui/editor.go +15 -0


@@ -912,6 +912,21 @@ func stripANSI(s string) string {
912	}	912		}
913	continue	913		continue
914	}	914		}
		915	+	if runes[i] == 0x1b && i+1 < len(runes) && runes[i+1] == ']' {
		916	+	i += 2
		917	+	for i < len(runes) {
		918	+	if runes[i] == 0x07 {
		919	+	i++
		920	+	break
		921	+	}
		922	+	if runes[i] == 0x1b && i+1 < len(runes) && runes[i+1] == '\\' {
		923	+	i += 2
		924	+	break
		925	+	}
		926	+	i++
		927	+	}
		928	+	continue
		929	+	}
915	out = append(out, runes[i])	930		out = append(out, runes[i])
916	i++	931		i++
917	}	932		}

M packages/tui/render.go +131 -30

 	logLines  []string
 	// Raw logical rows let DrawLog reject an unchanged frame before
 	// truncating and repainting every transcript row.
-	logRawChat          []string
+	logRawChat        []string
-	logRawBottom        []string
+	logRawBottom      []string
-	logRawCols          int
+	logRawCols        int
-	logRawRows          int
+	logRawRows        int
-	logRawBackground    string
+	logRawContentCols int
-	logRawHasThemeBG    bool
+	logRawBackground  string
-	logViewportTop      int
+	logRawHasThemeBG  bool
-	logHardwareRow      int
+	logViewportTop    int
-	logInit             bool
+	logHardwareRow    int
-	logNeedsFullRepaint bool
+	logInit           bool
+	// The right bar is a viewport overlay on top of the main-screen flow
+	// renderer. Keeping its cache separate prevents persistent chrome from
+	// replacing the transcript's logical buffer and native scrollback.
+	rightBarActive   bool
+	rightBarLines    []string
+	rightBarMainCols int
+	rightBarDimmed   bool
 	// keepScrollback is true when we must NOT emit \x1b[3J
 	// (erase-in-display 3, "clear scrollback").
 		r.logViewportTop = 0
 		r.logHardwareRow = 0
 		r.logInit = false
+		r.rightBarActive = false
+		r.rightBarLines = nil
+		r.rightBarMainCols = 0
 		if r.out != nil {
 			if r.keepScrollback {
 				// A resize is a discrete user action, like Ctrl+L: the
 	r.logViewportTop = 0
 	r.logHardwareRow = 0
 	r.logInit = false
+	r.rightBarActive = false
+	r.rightBarLines = nil
+	r.rightBarMainCols = 0
 	if r.keepScrollback {
 		// On VS Code's xterm.js the transcript is taller than the
 		// viewport, so an in-place clear (home + erase-to-end) only
 	var out strings.Builder
 	out.Grow(len(s))
 	seen := 0
+	osc8Active := false
 	runes := []rune(s)
 	for i := 0; i < len(runes); {
 		r := runes[i]
 			}
 			continue
 		}
+		// OSC string escape (BEL or ST terminated): zero-width and atomic.
+		if r == 0x1b && i+1 < len(runes) && runes[i+1] == ']' {
+			start := i
+			i += 2
+			for i < len(runes) {
+				c := runes[i]
+				i++
+				if c == 0x07 {
+					break
+				}
+				if c == 0x1b && i < len(runes) && runes[i] == '\\' {
+					i++
+					break
+				}
+			}
+			osc8Closer := start+5 < i && runes[start+2] == '8' && runes[start+3] == ';' && runes[start+4] == ';' &&
+				((runes[start+5] == 0x07 && i == start+6) ||
+					(start+6 < i && runes[start+5] == 0x1b && runes[start+6] == '\\' && i == start+7))
+			if seen < cols || osc8Closer {
+				for _, c := range runes[start:i] {
+					out.WriteRune(c)
+				}
+				if runes[start+2] == '8' {
+					osc8Active = !osc8Closer
+				}
+			}
+			continue
+		}
 		rw := runewidthRune(r)
 		if seen+rw > cols {
+			if osc8Active {
+				// The remaining text is omitted, so close a hyperlink
+				// whose opener was already emitted before the boundary.
+				out.WriteString("\x1b]8;;\x07")
+			}
 			// Flush any trailing ANSI escapes (resets, erase-to-EOL)
 			// so background colors and cleanup sequences survive.
 			for i < len(runes) {
 							break
 						}
 					}
+				} else if runes[i] == 0x1b && i+1 < len(runes) && runes[i+1] == ']' {
+					// Do not append a new OSC sequence after the visible
+					// boundary: an OSC 8 opener would leak hyperlink state
+					// into the next terminal row. A matching OSC 8 closer is
+					// retained so a link opened before the boundary is closed.
+					keep := i+5 < len(runes) && runes[i+2] == '8' && runes[i+3] == ';' && runes[i+4] == ';' &&
+						(runes[i+5] == 0x07 || (i+6 < len(runes) && runes[i+5] == 0x1b && runes[i+6] == '\\'))
+					start := i
+					i += 2
+					for i < len(runes) {
+						c := runes[i]
+						i++
+						if c == 0x07 {
+							break
+						}
+						if c == 0x1b && i < len(runes) && runes[i] == '\\' {
+							i++
+							break
+						}
+					}
+					if keep {
+						for _, c := range runes[start:i] {
+							out.WriteRune(c)
+						}
+					}
 				} else {
 					break
 				}
 //
 // cursorBottomRow/cursorCol are offsets into bottom, not the full frame.
 func (r *Renderer) DrawLog(chat, bottom []string, cursorBottomRow, cursorCol int) {
+	if r.rightBarActive {
+		r.clearRightBarOverlay()
+	}
+	r.drawLog(chat, bottom, cursorBottomRow, cursorCol, r.cols)
+}
+// drawLog is DrawLog's owning flow implementation. contentCols may reserve
+// terminal columns for a separately composited viewport overlay.
+func (r *Renderer) drawLog(chat, bottom []string, cursorBottomRow, cursorCol, contentCols int) bool {
 	if r.cols == 0 || r.rows == 0 {
-		return
+		return false
+	}
+	if contentCols <= 0 || contentCols > r.cols {
+		contentCols = r.cols
 	}
 	if len(bottom) == 0 {
 		bottom = []string{""}
 	}
-	if r.logInit && len(r.logLines) > 0 &&
+	if r.logRawFrameUnchanged(chat, bottom, cursorBottomRow, cursorCol, contentCols) {
-		cursorBottomRow == r.cursorRow && cursorCol == r.cursorCol &&
+		return false
-		r.logRawCols == r.cols && r.logRawRows == r.rows && r.logRawBackground == r.backgroundStyle &&
-		r.logRawHasThemeBG == (r.theme.Background != nil) &&
-		sameLines(chat, r.logRawChat) && sameLines(bottom, r.logRawBottom) {
-		return
 	}
 	chatFrame := make([]string, len(chat))
 	for i, line := range chat {
-		chatFrame[i] = paintBackgroundRow(truncateToWidth(line, r.cols), r.cols, r.backgroundStyle)
+		chatFrame[i] = paintBackgroundRow(truncateToWidth(line, contentCols), contentCols, r.backgroundStyle)
 	}
 	bottomFrame := make([]string, len(bottom))
 	for i, line := range bottom {
-		bottomFrame[i] = paintBackgroundRow(truncateToWidth(line, r.cols), r.cols, r.backgroundStyle)
+		bottomFrame[i] = paintBackgroundRow(truncateToWidth(line, contentCols), contentCols, r.backgroundStyle)
 	}
 	// Always reserve one real row below the editor/status band. This is
 	lines = append(lines, chatFrame...)
 	lines = append(lines, bottomFrame...)
 	for range bottomMarginRows {
-		lines = append(lines, paintBackgroundRow("", r.cols, r.backgroundStyle))
+		lines = append(lines, paintBackgroundRow("", contentCols, r.backgroundStyle))
 	}
 	// In main-screen flow mode zut normally emits only its logical
 	// content rows and leaves the rest of the terminal viewport alone.
 	// default transparent case.
 	if r.theme.Background != nil {
 		for len(lines) < r.rows {
-			lines = append(lines, paintBackgroundRow("", r.cols, r.backgroundStyle))
+			lines = append(lines, paintBackgroundRow("", contentCols, r.backgroundStyle))
 		}
 	}
 	if len(lines) == 0 {
 	// that never blinks, because we keep "showing" it before the
 	// terminal can blink it off. Bailing out here lets the OS run
 	// its blink cycle.
-	if r.logInit && cursorBottomRow == r.cursorRow && cursorCol == r.cursorCol && sameLines(lines, r.logLines) {
+	if r.logInit && r.logRawContentCols == contentCols &&
-		return
+		cursorBottomRow == r.cursorRow && cursorCol == r.cursorCol && sameLines(lines, r.logLines) {
+		return false
 	}
 	var w strings.Builder
 		}
 		moveToLogicalRow(cursorTargetRow)
 		w.WriteString("\r")
-		if cursorCol > 0 {
+		physicalCursorCol := cursorCol
-			w.WriteString("\x1b[" + itoa(cursorCol) + "C")
+		if physicalCursorCol < 0 {
+			physicalCursorCol = 0
+		}
+		if physicalCursorCol >= contentCols {
+			physicalCursorCol = contentCols - 1
+		}
+		if physicalCursorCol > 0 {
+			w.WriteString("\x1b[" + itoa(physicalCursorCol) + "C")
 		}
 		w.WriteString(SeqShowCursor)
 	}
 	wasInitialized := r.logInit
 	full := !wasInitialized || len(r.logLines) == 0
 	if full {
-		// Returning from the fixed right-bar frame needs a full viewport
+		// A cache invalidation may require a full viewport repaint after flow
-		// repaint, but it must not discard terminal scrollback merely because
+		// has started, but only the initial paint may discard old scrollback.
-		// the renderer's flow cache is intentionally empty.
+		writeFull(true, !wasInitialized)
-		writeFull(true, !wasInitialized && !r.logNeedsFullRepaint)
 		r.logInit = true
-		r.logNeedsFullRepaint = false
 	} else {
 		firstChanged := -1
 		lastChanged := -1
 	r.logRawBottom = append(r.logRawBottom[:0], bottom...)
 	r.logRawCols = r.cols
 	r.logRawRows = r.rows
+	r.logRawContentCols = contentCols
 	r.logRawBackground = r.backgroundStyle
 	r.logRawHasThemeBG = r.theme.Background != nil
 	r.cursorRow = cursorBottomRow
 	r.cursorCol = cursorCol
+	return true
+}
+func (r *Renderer) logRawFrameUnchanged(chat, bottom []string, cursorBottomRow, cursorCol, contentCols int) bool {
+	return cursorBottomRow == r.cursorRow && cursorCol == r.cursorCol &&
+		r.logRawContentUnchanged(chat, bottom, contentCols)
+}
+func (r *Renderer) logRawContentUnchanged(chat, bottom []string, contentCols int) bool {
+	return r.logInit && len(r.logLines) > 0 &&
+		r.logRawCols == r.cols && r.logRawRows == r.rows && r.logRawContentCols == contentCols &&
+		r.logRawBackground == r.backgroundStyle && r.logRawHasThemeBG == (r.theme.Background != nil) &&
+		sameLines(chat, r.logRawChat) && sameLines(bottom, r.logRawBottom)
 }
 // sameLines reports whether two []string have the exact same

M packages/tui/rightbar.go +92 -42

@@ -1,6 +1,7 @@
1		package tui	1		package tui
2			2
3		import (	3		import (
			4	+	"io"
4		"sort"	5		"sort"
5		"strings"	6		"strings"
6		)	7		)

@@ -372,12 +373,9 @@ func joinRightBar(th Theme, main, rightBar string, mainWidth, rightBarWidth int,
372		return main + separator + rightBar	373		return main + separator + rightBar
373		}	374		}
374			375
375	-	// DrawRightBar renders an already-laid-out visible chat slice and sticky	376	+	// DrawRightBar renders the complete transcript through DrawLog, then
376	-	// bottom block in a fixed frame with a persistent right bar. The normal	377	+	// composites the persistent rail over the visible viewport. The flow cache
377	-	// DrawLog path deliberately uses terminal scrollback; a persistent side rail	378	+	// remains authoritative so appended chat still enters native scrollback.
378	-	// needs a fixed viewport so updates can repaint its columns without leaving
379	-	// stale rows behind. Interactive mode still owns chat scrolling and passes
380	-	// the selected visible slice here.
381		func (r *Renderer) DrawRightBar(chat, bottom, rightBar []string, cursorBottomRow, cursorCol int) {	379		func (r *Renderer) DrawRightBar(chat, bottom, rightBar []string, cursorBottomRow, cursorCol int) {
382		r.drawRightBar(chat, bottom, rightBar, cursorBottomRow, cursorCol, false)	380		r.drawRightBar(chat, bottom, rightBar, cursorBottomRow, cursorCol, false)
383		}	381		}

@@ -394,50 +392,102 @@ func (r *Renderer) drawRightBar(chat, bottom, rightBar []string, cursorBottomRow
394		}	392		}
395		mainWidth, rightBarWidth, ok := RightBarColumns(r.cols)	393		mainWidth, rightBarWidth, ok := RightBarColumns(r.cols)
396		if !ok {	394		if !ok {
			395	+	r.DrawLog(chat, bottom, cursorBottomRow, cursorCol)
397		return	396		return
398		}	397		}
			398	+
399		if len(bottom) == 0 {	399		if len(bottom) == 0 {
400		bottom = []string{""}	400		bottom = []string{""}
401		}	401		}
402	-	if len(rightBar) < r.rows {
403	-	padded := make([]string, r.rows)
404	-	copy(padded, rightBar)
405	-	rightBar = padded
406	-	} else if len(rightBar) > r.rows {
407	-	rightBar = rightBar[:r.rows]
408	-	}
409			402
410	-	main := make([]string, 0, len(chat)+len(bottom)+1)	403	+	// Keep DrawLog's final blank margin unobstructed, matching the normal flow
411	-	main = append(main, chat...)	404	+	// renderer and the previous right-bar layout.
412	-	main = append(main, bottom...)	405	+	frameRows := max(0, r.rows-1)
413	-	main = append(main, "") // mirror DrawLog's renderer-owned bottom margin	406	+	barLines := make([]string, frameRows)
414	-	cursorRow := len(chat) + cursorBottomRow	407	+	copy(barLines, rightBar)
415	-	if len(main) > r.rows {	408	+
416	-	trim := len(main) - r.rows	409	+	barChanged := !r.rightBarActive \|\| r.rightBarMainCols != mainWidth \|\|
417	-	main = main[trim:]	410	+	r.rightBarDimmed != dimSeparator \|\| !sameLines(barLines, r.rightBarLines)
418	-	cursorRow -= trim	411	+	contentUnchanged := r.logRawContentUnchanged(chat, bottom, mainWidth)
419	-	}	412	+	flowUnchanged := contentUnchanged && cursorBottomRow == r.cursorRow && cursorCol == r.cursorCol
420	-	if len(main) < r.rows {	413	+	if flowUnchanged && !barChanged {
421	-	padding := make([]string, r.rows-len(main))	414	+	return
422	-	main = append(padding, main...)	415	+	}
423	-	cursorRow += len(padding)	416	+	if !contentUnchanged && r.rightBarActive {
			417	+	// Remove viewport chrome before DrawLog can naturally scroll a row into
			418	+	// history. Otherwise every appended transcript row captures a stale
			419	+	// copy of the rail in native terminal scrollback.
			420	+	r.clearRightBarOverlay()
424		}	421		}
			422	+	r.drawLog(chat, bottom, cursorBottomRow, cursorCol, mainWidth)
			423	+	if contentUnchanged && !barChanged {
			424	+	// Cursor-only updates do not disturb the composited rail.
			425	+	return
			426	+	}
			427	+	r.writeRightBarOverlay(barLines, mainWidth, rightBarWidth, dimSeparator)
			428	+	r.rightBarActive = true
			429	+	r.rightBarLines = append(r.rightBarLines[:0], barLines...)
			430	+	r.rightBarMainCols = mainWidth
			431	+	r.rightBarDimmed = dimSeparator
			432	+	}
425			433
426	-	frame := make([]string, r.rows)	434	+	// clearRightBarOverlay removes viewport chrome before DrawLog expands back to
427	-	for row := range frame {	435	+	// the terminal width. Restoring the tracked flow cursor keeps DrawLog's
428	-	frame[row] = joinRightBar(r.theme, main[row], rightBar[row], mainWidth, rightBarWidth, dimSeparator)	436	+	// hardware-row model valid across the intermediate absolute writes.
			437	+	func (r *Renderer) clearRightBarOverlay() {
			438	+	if !r.rightBarActive {
			439	+	return
429		}	440		}
			441	+	remaining := r.cols - r.rightBarMainCols
			442	+	if remaining > 0 {
			443	+	blank := strings.Repeat(" ", remaining)
			444	+	var w strings.Builder
			445	+	w.WriteString(SeqSynchronizedOn)
			446	+	w.WriteString(SeqHideCursor)
			447	+	for row := 0; row < max(0, r.rows-1); row++ {
			448	+	w.WriteString(MoveTo(row+1, r.rightBarMainCols+1))
			449	+	w.WriteString("\x1b[0m")
			450	+	w.WriteString(blank)
			451	+	}
			452	+	r.appendTrackedLogCursor(&w, r.rightBarMainCols)
			453	+	w.WriteString(SeqSynchronizedOff)
			454	+	_, _ = io.WriteString(r.out, w.String())
			455	+	}
			456	+	r.rightBarActive = false
			457	+	r.rightBarLines = nil
			458	+	r.rightBarMainCols = 0
			459	+	r.rightBarDimmed = false
			460	+	}
			461	+
			462	+	func (r *Renderer) writeRightBarOverlay(rightBar []string, mainWidth, rightBarWidth int, dimSeparator bool) {
			463	+	var w strings.Builder
			464	+	w.WriteString(SeqSynchronizedOn)
			465	+	w.WriteString(SeqHideCursor)
			466	+	for row, line := range rightBar {
			467	+	w.WriteString(MoveTo(row+1, mainWidth+1))
			468	+	w.WriteString("\x1b[0m")
			469	+	w.WriteString(joinRightBar(r.theme, "", line, 0, rightBarWidth, dimSeparator))
			470	+	}
			471	+	r.appendTrackedLogCursor(&w, mainWidth)
			472	+	w.WriteString(SeqSynchronizedOff)
			473	+	_, _ = io.WriteString(r.out, w.String())
			474	+	}
430			475
431	-	// Draw() owns the fixed-frame cache. Reset the flow-mode cache so a	476	+	func (r Renderer) appendTrackedLogCursor(w strings.Builder, contentCols int) {
432	-	// later fallback to DrawLog starts with a full repaint instead of trying	477	+	if !r.logInit \|\| r.cursorRow < 0 {
433	-	// to diff against logical rows from before the rail was enabled. Mark the	478	+	return
434	-	// transition separately so that repaint does not clear scrollback.	479	+	}
435	-	r.logChat = nil	480	+	row := len(r.logChat) + r.cursorRow - r.logViewportTop
436	-	r.logBottom = nil	481	+	if row < 0 \|\| row >= r.rows {
437	-	r.logLines = nil	482	+	return
438	-	r.logViewportTop = 0	483	+	}
439	-	r.logHardwareRow = 0	484	+	cursorCol := r.cursorCol
440	-	r.logInit = false	485	+	if cursorCol < 0 {
441	-	r.logNeedsFullRepaint = true	486	+	cursorCol = 0
442	-	r.Draw(frame, cursorRow, cursorCol)	487	+	}
			488	+	if cursorCol >= contentCols {
			489	+	cursorCol = contentCols - 1
			490	+	}
			491	+	w.WriteString(MoveTo(row+1, cursorCol+1))
			492	+	w.WriteString(SeqShowCursor)
443		}	493		}

M packages/tui/rightbar_test.go +152 -6


@@ -209,6 +209,141 @@ func TestJoinRightBarPreservesCellBudgetForUnicode(t *testing.T) {
209		}	209		}
210		}	210		}
211			211
			212	+	func TestRightBarTruncationPreservesOSCSequences(t *testing.T) {
			213	+	for _, tc := range []struct {
			214	+	opener string
			215	+	closer string
			216	+	}{
			217	+	{"\x1b]8;;https://example.test\x07", "\x1b]8;;\x07"},
			218	+	{"\x1b]8;;https://example.test\x1b\\", "\x1b]8;;\x1b\\"},
			219	+	} {
			220	+	got := JoinRightBar(Dark, tc.opener+"label-more", "", 5, 1)
			221	+	if !strings.HasPrefix(got, tc.opener+"label") {
			222	+	t.Fatalf("truncated right-bar row split OSC escape %q: %q", tc.opener, got)
			223	+	}
			224	+	got = truncateToWidth("12345"+tc.opener+"tail", 5)
			225	+	if got != "12345" {
			226	+	t.Fatalf("truncated right-bar row leaked trailing OSC escape %q: %q", tc.opener, got)
			227	+	}
			228	+	got = truncateToWidth(tc.opener+"12345x"+tc.closer, 5)
			229	+	if !strings.HasSuffix(got, "\x1b]8;;\x07") && !strings.HasSuffix(got, tc.closer) {
			230	+	t.Fatalf("truncated right-bar row left OSC 8 hyperlink open: %q", got)
			231	+	}
			232	+	}
			233	+	}
			234	+
			235	+	func TestRendererDrawRightBarKeepsFlowScrollback(t *testing.T) {
			236	+	t.Setenv("TERM_PROGRAM", "")
			237	+
			238	+	var out bytes.Buffer
			239	+	r := NewRenderer(&out)
			240	+	r.SetTheme(Dark)
			241	+	r.Resize(80, 5)
			242	+	chat := []string{"one", "two", "three", "four", "five", "six"}
			243	+	r.DrawRightBar(
			244	+	chat,
			245	+	[]string{"input"},
			246	+	RenderRightBar(Dark, []RightBarWidget{{Extension: "plan", Title: "Plan", Lines: []string{"task"}}}, 26, 5),
			247	+	0,
			248	+	0,
			249	+	)
			250	+	if !r.logInit {
			251	+	t.Fatal("right-bar draw abandoned the flow renderer")
			252	+	}
			253	+	if got := len(r.logChat); got != len(chat) {
			254	+	t.Fatalf("cached chat rows = %d, want complete transcript length %d", got, len(chat))
			255	+	}
			256	+
			257	+	out.Reset()
			258	+	chat = append(chat, "seven")
			259	+	r.DrawRightBar(
			260	+	chat,
			261	+	[]string{"input"},
			262	+	RenderRightBar(Dark, []RightBarWidget{{Extension: "plan", Title: "Plan", Lines: []string{"task"}}}, 26, 5),
			263	+	0,
			264	+	0,
			265	+	)
			266	+	got := out.String()
			267	+	if strings.Contains(got, SeqClearScreenNoHome) \|\| strings.Contains(got, SeqClearScrollback) {
			268	+	t.Fatalf("right-bar append cleared retained scrollback: %q", got)
			269	+	}
			270	+	if !strings.Contains(stripANSI(got), "seven") {
			271	+	t.Fatalf("right-bar append omitted new transcript row: %q", got)
			272	+	}
			273	+	mainWidth, _, _ := RightBarColumns(80)
			274	+	clearedRail := MoveTo(1, mainWidth+1) + "\x1b[0m" + strings.Repeat(" ", 80-mainWidth)
			275	+	if clearAt, appendAt := strings.Index(got, clearedRail), strings.Index(got, "seven"); clearAt < 0 \|\| clearAt > appendAt {
			276	+	t.Fatalf("right bar was not removed before transcript append entered scrollback: %q", got)
			277	+	}
			278	+	if r.logViewportTop == 0 {
			279	+	t.Fatal("test did not exercise transcript rows above the viewport")
			280	+	}
			281	+	}
			282	+
			283	+	func TestRendererDrawRightBarIdleNoOpEmitsNothing(t *testing.T) {
			284	+	t.Setenv("TERM_PROGRAM", "")
			285	+	var out bytes.Buffer
			286	+	r := NewRenderer(&out)
			287	+	r.SetTheme(Dark)
			288	+	r.Resize(80, 5)
			289	+	chat := []string{"chat"}
			290	+	bottom := []string{"input"}
			291	+	rail := RenderRightBar(Dark, []RightBarWidget{{Extension: "plan", Lines: []string{"task"}}}, 26, 5)
			292	+	r.DrawRightBar(chat, bottom, rail, 0, 0)
			293	+	out.Reset()
			294	+
			295	+	r.DrawRightBar(chat, bottom, rail, 0, 0)
			296	+	if out.Len() != 0 {
			297	+	t.Fatalf("idle right-bar redraw emitted %d bytes: %q", out.Len(), out.String())
			298	+	}
			299	+	}
			300	+
			301	+	func TestRendererDrawRightBarCursorMoveDoesNotRepaintRail(t *testing.T) {
			302	+	t.Setenv("TERM_PROGRAM", "")
			303	+	var out bytes.Buffer
			304	+	r := NewRenderer(&out)
			305	+	r.SetTheme(Dark)
			306	+	r.Resize(80, 5)
			307	+	chat := []string{"chat"}
			308	+	bottom := []string{"input"}
			309	+	rail := RenderRightBar(Dark, []RightBarWidget{{Extension: "plan", Lines: []string{"task"}}}, 26, 5)
			310	+	r.DrawRightBar(chat, bottom, rail, 0, 0)
			311	+	out.Reset()
			312	+
			313	+	r.DrawRightBar(chat, bottom, rail, 0, 1)
			314	+	if out.Len() == 0 {
			315	+	t.Fatal("cursor-only right-bar update emitted nothing")
			316	+	}
			317	+	if !strings.Contains(out.String(), "\r\x1b[1C") {
			318	+	t.Fatalf("cursor-only update did not move the cursor to column 1: %q", out.String())
			319	+	}
			320	+	if strings.Contains(stripANSI(out.String()), "task") {
			321	+	t.Fatalf("cursor-only update repainted the entire rail: %q", out.String())
			322	+	}
			323	+	}
			324	+
			325	+	func TestRendererDrawRightBarClampsCursorToMainContent(t *testing.T) {
			326	+	t.Setenv("TERM_PROGRAM", "")
			327	+	var out bytes.Buffer
			328	+	r := NewRenderer(&out)
			329	+	r.SetTheme(Dark)
			330	+	r.Resize(80, 5)
			331	+	rail := RenderRightBar(Dark, []RightBarWidget{{Extension: "plan", Lines: []string{"task"}}}, 26, 5)
			332	+	r.DrawRightBar([]string{"chat"}, []string{"input"}, rail, 0, 100)
			333	+
			334	+	mainWidth, _, ok := RightBarColumns(80)
			335	+	if !ok {
			336	+	t.Fatal("right bar should fit")
			337	+	}
			338	+	got := out.String()
			339	+	if strings.Contains(got, MoveTo(2, 101)) {
			340	+	t.Fatalf("cursor escaped the main content area: %q", got)
			341	+	}
			342	+	if !strings.Contains(got, MoveTo(2, mainWidth)) {
			343	+	t.Fatalf("cursor was not clamped to the main content edge: %q", got)
			344	+	}
			345	+	}
			346	+
212		func TestRendererDrawRightBarToDrawLogKeepsScrollback(t *testing.T) {	347		func TestRendererDrawRightBarToDrawLogKeepsScrollback(t *testing.T) {
213		t.Setenv("TERM_PROGRAM", "")	348		t.Setenv("TERM_PROGRAM", "")
214			349

@@ -226,10 +361,21 @@ func TestRendererDrawRightBarToDrawLogKeepsScrollback(t *testing.T) {
226			361
227		out.Reset()	362		out.Reset()
228		r.DrawLog([]string{"chat"}, []string{"input"}, 0, 0)	363		r.DrawLog([]string{"chat"}, []string{"input"}, 0, 0)
229	-	if !strings.Contains(stripANSI(out.String()), "input") {	364	+	if r.rightBarActive {
230	-	t.Fatalf("right-bar fallback did not repaint flow content: %q", out.String())	365	+	t.Fatal("right-bar fallback left the viewport overlay active")
			366	+	}
			367	+	if r.logRawContentCols != 80 {
			368	+	t.Fatalf("flow content width = %d, want full terminal width 80", r.logRawContentCols)
231		}	369		}
232	-	if strings.Contains(out.String(), SeqClearScrollback) {	370	+	mainWidth, _, ok := RightBarColumns(80)
			371	+	if !ok {
			372	+	t.Fatal("right bar should fit before falling back to DrawLog")
			373	+	}
			374	+	clearedRail := MoveTo(1, mainWidth+1) + "\x1b[0m" + strings.Repeat(" ", 80-mainWidth)
			375	+	if !strings.Contains(out.String(), clearedRail) {
			376	+	t.Fatalf("right-bar fallback did not clear the old rail: %q", out.String())
			377	+	}
			378	+	if strings.Contains(out.String(), SeqClearScreenNoHome) \|\| strings.Contains(out.String(), SeqClearScrollback) {
233		t.Fatalf("right-bar fallback cleared terminal scrollback: %q", out.String())	379		t.Fatalf("right-bar fallback cleared terminal scrollback: %q", out.String())
234		}	380		}
235		}	381		}

@@ -261,14 +407,14 @@ func TestRendererDrawRightBarUpdatesClearsAndResizes(t *testing.T) {
261		if !strings.Contains(stripANSI(out.String()), "Updated") {	407		if !strings.Contains(stripANSI(out.String()), "Updated") {
262		t.Fatalf("right-bar update did not repaint changed content: %q", out.String())	408		t.Fatalf("right-bar update did not repaint changed content: %q", out.String())
263		}	409		}
264	-	if r.logInit {	410	+	if !r.logInit {
265	-	t.Fatal("right-bar mode left flow renderer initialized")	411	+	t.Fatal("right-bar update abandoned the flow renderer")
266		}	412		}
267			413
268		out.Reset()	414		out.Reset()
269		r.DrawLog([]string{"chat"}, []string{"input"}, 0, 0)	415		r.DrawLog([]string{"chat"}, []string{"input"}, 0, 0)
270		if !r.logInit {	416		if !r.logInit {
271	-	t.Fatal("flow renderer was not reinitialized after right-bar clearing")	417	+	t.Fatal("flow renderer was not retained after right-bar clearing")
272		}	418		}
273			419
274		out.Reset()	420		out.Reset()