Merge branch 'main' into codex/session-title-fix (21ed173)

Adopt upstream's own fix for the adaptive-evidence footer assertion
(normalized separator comparison, supersedes our MAIN_SEPARATOR variant).
Budget re-based to measured 676495: +9 from the session-title regression
tests, the rest absorbs the pre-release repair batch 21ed173 which
landed without a budget update. Session-title tests still pass.

Author: SparkofSpike

CHANGELOG.md

@@ -140,6 +140,39 @@ File edits, terminal width, and Windows installation.
 - Acceptance-level Gherkin coverage locking the existing user-command
   precedence, alias shadowing, fallback, and invalid-command error contract
   (PR #4992).
+- Agent Plugins v1.0.0: consume, publish, and slugify packaged sub-agent
+  briefs, with an install/update/uninstall on-ramp in the TUI (PR #5182). A
+  plugin bundles a prompt, posture, and routing as one shareable artifact;
+  on-disk migration of the older `plugin.toml` scaffold is deliberately out
+  of scope for this train.
+- `send_later`: a model-callable one-shot delayed continuation tool, so the
+  model can schedule a single future nudge without an operator-approved
+  durable automation (PR #5138).
+- `/advisor`: an opt-in background advisor watcher for live turns (PR #5139).
+- Notification quiet mode with per-category switches and action-first copy
+  (PR #5066).
+- Automation scheduling forms — one-shot `ONCE`, five-field cron, and honest
+  watcher modes — created through the approval-gated `automation` tool
+  (PR #5183).
+- Sub-agent `resume_from` continuation chains (PR #5142), child-result
+  diff-tainting when a claimed diff is not visible to git, per-turn usage
+  receipts on the exec stream-json stream, and spawn receipts that report
+  the model each sub-agent actually ran on.
+- Transport resilience: sub-agent exec transport retries with a 600 s
+  default (PR #5210), SSE header stalls retryable instead of fatal, and
+  headless turn resume after mid-stream network drops with an `EX_TEMPFAIL`
+  exit.
+- Session durability and control: a deterministic compaction continuation
+  contract (PR #5064), persisting interrupted output (PR #5206), stop-word
+  cancellation (PR #5207), token-counter refresh (PR #5204), deny-by-default
+  approval cards (PR #5090), and the Operate completion gate (PR #5067).
+- zh-Hant promoted to a full shipped locale with complete `en.json` parity
+  (PR #5143).
+- A persistent update-available chip in the header, with the startup update
+  check throttled and naming the right command.
+- RLM static intent extraction for code blocks (`rlm_block_intent.rs`)
+  landed as groundwork for a future code-mode approval flow; it is not yet
+  wired into the turn pipeline and ships dormant by design.
 
 ### Changed
 
@@ -186,6 +219,20 @@ File edits, terminal width, and Windows installation.
   futures-util to 0.3.33, libc to 0.2.189, actions/stale to 11.0.0, and
   docker/login-action to 4.5.2. The locked graph also includes the
   event-listener 5.4.2 fix for RUSTSEC-2026-0221.
+- The progress surface now speaks plainly everywhere: the last user-visible
+  "Work update is pending" notices say "To-do list", the tool constructor and
+  the docs name `todo_write` as the single canonical progress tool, and
+  `work_update`, `TodoWrite`, and `todo` stay registered as hidden
+  compatibility aliases so saved transcripts keep replaying.
+- Sub-agent and `agents/wait` waits stay short by default and by cap:
+  blocking waits default to 30 s and refuse to block past 120 s, because a
+  blocked wait deafens the session to typed input and settled children
+  already report back as `<codewhale:subagent.done>` sentinels.
+- `Bash` `action=wait` honors `timeout_secs` (seconds) and bare `timeout`
+  (milliseconds) alongside canonical `timeout_ms`, and `block` as an alias
+  for `wait`, so a habit formed on other wait tools gets the duration it
+  asked for instead of silently falling back to the 30 s default; the result
+  metadata reports the real `wait_timeout_ms` applied.
 
 ### Fixed
 
@@ -362,6 +409,21 @@ File edits, terminal width, and Windows installation.
 - Transcript wheel scrolling under iTerm2: xterm alternate-scroll (DECSET
   1007) now stays off while mouse capture is active, so wheel events arrive as
   mouse events instead of being converted into arrow keys (#5223, PR #5234).
+- A stalled model stream no longer ends the turn as `Completed` over a
+  frozen reasoning block: a mid-stream chunk-timeout now counts toward the
+  stream-error budget, so a stall with nothing streamed retries the request
+  transparently, and a stall that exhausts the retry budget fails the turn
+  with the real reason instead of reporting success.
+- A finished background shell task now wakes the engine even when no goal is
+  active: the idle loop starts an ordinary runtime turn so the completion
+  reaches the model immediately instead of sitting unclaimed until the user
+  types (a dead provider route claims the completion once and reports where
+  the output lives instead of re-arming the same error every tick).
+- Sub-agent final reports that exceed the summary budget are now spilled to
+  a session artifact, and the truncation footer names the
+  `retrieve_tool_result` ref for the elided middle instead of telling the
+  model the bytes are unrecoverable; write failures degrade to the honest
+  no-ref footer.
 
 ### Removed
 

crates/tui/CHANGELOG.md

@@ -140,6 +140,39 @@ File edits, terminal width, and Windows installation.
 - Acceptance-level Gherkin coverage locking the existing user-command
   precedence, alias shadowing, fallback, and invalid-command error contract
   (PR #4992).
+- Agent Plugins v1.0.0: consume, publish, and slugify packaged sub-agent
+  briefs, with an install/update/uninstall on-ramp in the TUI (PR #5182). A
+  plugin bundles a prompt, posture, and routing as one shareable artifact;
+  on-disk migration of the older `plugin.toml` scaffold is deliberately out
+  of scope for this train.
+- `send_later`: a model-callable one-shot delayed continuation tool, so the
+  model can schedule a single future nudge without an operator-approved
+  durable automation (PR #5138).
+- `/advisor`: an opt-in background advisor watcher for live turns (PR #5139).
+- Notification quiet mode with per-category switches and action-first copy
+  (PR #5066).
+- Automation scheduling forms — one-shot `ONCE`, five-field cron, and honest
+  watcher modes — created through the approval-gated `automation` tool
+  (PR #5183).
+- Sub-agent `resume_from` continuation chains (PR #5142), child-result
+  diff-tainting when a claimed diff is not visible to git, per-turn usage
+  receipts on the exec stream-json stream, and spawn receipts that report
+  the model each sub-agent actually ran on.
+- Transport resilience: sub-agent exec transport retries with a 600 s
+  default (PR #5210), SSE header stalls retryable instead of fatal, and
+  headless turn resume after mid-stream network drops with an `EX_TEMPFAIL`
+  exit.
+- Session durability and control: a deterministic compaction continuation
+  contract (PR #5064), persisting interrupted output (PR #5206), stop-word
+  cancellation (PR #5207), token-counter refresh (PR #5204), deny-by-default
+  approval cards (PR #5090), and the Operate completion gate (PR #5067).
+- zh-Hant promoted to a full shipped locale with complete `en.json` parity
+  (PR #5143).
+- A persistent update-available chip in the header, with the startup update
+  check throttled and naming the right command.
+- RLM static intent extraction for code blocks (`rlm_block_intent.rs`)
+  landed as groundwork for a future code-mode approval flow; it is not yet
+  wired into the turn pipeline and ships dormant by design.
 
 ### Changed
 
@@ -186,6 +219,20 @@ File edits, terminal width, and Windows installation.
   futures-util to 0.3.33, libc to 0.2.189, actions/stale to 11.0.0, and
   docker/login-action to 4.5.2. The locked graph also includes the
   event-listener 5.4.2 fix for RUSTSEC-2026-0221.
+- The progress surface now speaks plainly everywhere: the last user-visible
+  "Work update is pending" notices say "To-do list", the tool constructor and
+  the docs name `todo_write` as the single canonical progress tool, and
+  `work_update`, `TodoWrite`, and `todo` stay registered as hidden
+  compatibility aliases so saved transcripts keep replaying.
+- Sub-agent and `agents/wait` waits stay short by default and by cap:
+  blocking waits default to 30 s and refuse to block past 120 s, because a
+  blocked wait deafens the session to typed input and settled children
+  already report back as `<codewhale:subagent.done>` sentinels.
+- `Bash` `action=wait` honors `timeout_secs` (seconds) and bare `timeout`
+  (milliseconds) alongside canonical `timeout_ms`, and `block` as an alias
+  for `wait`, so a habit formed on other wait tools gets the duration it
+  asked for instead of silently falling back to the 30 s default; the result
+  metadata reports the real `wait_timeout_ms` applied.
 
 ### Fixed
 
@@ -362,6 +409,21 @@ File edits, terminal width, and Windows installation.
 - Transcript wheel scrolling under iTerm2: xterm alternate-scroll (DECSET
   1007) now stays off while mouse capture is active, so wheel events arrive as
   mouse events instead of being converted into arrow keys (#5223, PR #5234).
+- A stalled model stream no longer ends the turn as `Completed` over a
+  frozen reasoning block: a mid-stream chunk-timeout now counts toward the
+  stream-error budget, so a stall with nothing streamed retries the request
+  transparently, and a stall that exhausts the retry budget fails the turn
+  with the real reason instead of reporting success.
+- A finished background shell task now wakes the engine even when no goal is
+  active: the idle loop starts an ordinary runtime turn so the completion
+  reaches the model immediately instead of sitting unclaimed until the user
+  types (a dead provider route claims the completion once and reports where
+  the output lives instead of re-arming the same error every tick).
+- Sub-agent final reports that exceed the summary budget are now spilled to
+  a session artifact, and the truncation footer names the
+  `retrieve_tool_result` ref for the elided middle instead of telling the
+  model the bytes are unrecoverable; write failures degrade to the honest
+  no-ref footer.
 
 ### Removed
 

crates/tui/src/commands/groups/core/voice.rs

@@ -480,21 +480,21 @@ async fn transcribe_local_whisper(audio_samples: &[i16]) -> Result<String, Strin
             .arg("auto")
             .arg("--output-txt")
             .output();
-        if let Ok(out) = output {
-            if out.status.success() {
-                let txt = String::from_utf8_lossy(&out.stdout).trim().to_string();
+        if let Ok(out) = output
+            && out.status.success()
+        {
+            let txt = String::from_utf8_lossy(&out.stdout).trim().to_string();
+            let _ = std::fs::remove_file(&tmp);
+            if !txt.is_empty() {
+                return Ok(txt);
+            }
+            // Some builds write to .txt sidecar
+            let sidecar = tmp.with_extension("txt");
+            if let Ok(s) = std::fs::read_to_string(&sidecar) {
+                let _ = std::fs::remove_file(&sidecar);
                 let _ = std::fs::remove_file(&tmp);
-                if !txt.is_empty() {
-                    return Ok(txt);
-                }
-                // Some builds write to .txt sidecar
-                let sidecar = tmp.with_extension("txt");
-                if let Ok(s) = std::fs::read_to_string(&sidecar) {
-                    let _ = std::fs::remove_file(&sidecar);
-                    let _ = std::fs::remove_file(&tmp);
-                    if !s.trim().is_empty() {
-                        return Ok(s.trim().to_string());
-                    }
+                if !s.trim().is_empty() {
+                    return Ok(s.trim().to_string());
                 }
             }
         }

crates/tui/src/commands/mod.rs

@@ -703,15 +703,15 @@ mod tests {
 
         let mut context = crate::tools::spec::ToolContext::new(app.workspace.clone());
         context.runtime.work = Some(work);
-        crate::tools::todo::TodoWriteTool::work_update(app.todos.clone())
+        crate::tools::todo::TodoWriteTool::new(app.todos.clone())
             .execute(
                 serde_json::json!({
                     "todos": [{"content": "relay the staged graph", "status": "in_progress"}]
                 }),
                 &context,
             )
             .await
-            .expect("graph-backed work_update");
+            .expect("graph-backed todo_write");
 
         assert!(
             app.todos.lock().await.snapshot().is_empty(),

crates/tui/src/core/engine.rs

@@ -1891,19 +1891,12 @@ impl Engine {
         }
     }
 
-    /// Whether the idle loop should poll for background shell completion:
-    /// only while a goal is active and a background job is running or has
-    /// finished without being claimed yet.
+    /// Whether the idle loop should poll for background shell completion: a
+    /// background job is running or has finished without being claimed yet.
+    /// Plain interactive sessions arm exactly like goal sessions — a finished
+    /// background task must reach the model without waiting for the user to
+    /// type, the same wake an idle sub-agent completion already gets.
     fn idle_shell_wake_armed(&self) -> bool {
-        let goal_active = self
-            .config
-            .goal_state
-            .lock()
-            .map(|state| state.snapshot().is_active())
-            .unwrap_or(false);
-        if !goal_active {
-            return false;
-        }
         self.shell_manager
             .lock()
             .map(|manager| manager.may_have_undelivered_completion())
@@ -1918,18 +1911,82 @@ impl Engine {
             .unwrap_or(false)
     }
 
-    /// An idle-engine wake for finished background shell work: queue a goal
-    /// continuation. The evidence itself is claimed by the boundary drain in
-    /// `handle_send_message`, so the continuation turn reads the completion
-    /// payload the same way a user-initiated turn would.
+    /// An idle-engine wake for finished background shell work. With an active
+    /// goal this queues a goal continuation; without one it starts an ordinary
+    /// runtime turn so the completion reaches the model immediately instead of
+    /// sitting unclaimed until the user types. Either way the evidence itself
+    /// is claimed by the boundary drain in `handle_send_message`, so the
+    /// follow-up turn reads the completion payload the same way a
+    /// user-initiated turn would.
     async fn handle_idle_shell_completion_wake(&mut self) {
+        let goal_active = self
+            .config
+            .goal_state
+            .lock()
+            .map(|state| state.snapshot().is_active())
+            .unwrap_or(false);
+        if goal_active {
+            let _ = self
+                .tx_event
+                .send(Event::status(
+                    "Background shell work finished; continuing the active goal".to_string(),
+                ))
+                .await;
+            self.schedule_goal_continuation(Vec::new());
+            return;
+        }
+        let route = match self.current_runtime_route() {
+            Ok(route) => route,
+            Err(err) => {
+                // No route, no turn. Claim the once-only completion now so a
+                // dead route cannot re-arm the wake into the same error every
+                // poll tick; the user sees what finished and where the output
+                // lives, and the next healthy turn proceeds normally.
+                let finished = self
+                    .shell_manager
+                    .lock()
+                    .map(|mut manager| manager.drain_finished_jobs_with_evidence().len())
+                    .unwrap_or(0);
+                let _ = self
+                    .tx_event
+                    .send(Event::error(ErrorEnvelope::fatal_auth(format!(
+                        "{finished} background shell task(s) finished, but the turn cannot resume because the provider route is no longer valid: {err}. Their output stays available via /jobs."
+                    ))))
+                    .await;
+                return;
+            }
+        };
         let _ = self
             .tx_event
             .send(Event::status(
-                "Background shell work finished; continuing the active goal".to_string(),
+                "Background shell work finished; resuming the turn".to_string(),
             ))
             .await;
-        self.schedule_goal_continuation(Vec::new());
+        let _ = self
+            .handle_send_message(
+                "[runtime] A background shell task finished; its completion evidence follows."
+                    .to_string(),
+                self.current_mode,
+                route,
+                self.config.compaction.clone(),
+                self.config.goal_objective.clone(),
+                self.config.goal_token_budget,
+                self.config.goal_status,
+                self.session.reasoning_effort.clone(),
+                self.session.reasoning_effort_auto,
+                self.session.auto_model,
+                self.session.allow_shell,
+                self.session.trust_mode,
+                self.session.auto_approve,
+                self.session.approval_mode,
+                self.config.translation_enabled,
+                self.config.allowed_tools.clone(),
+                Vec::new(),
+                self.config.hook_executor.clone(),
+                self.config.verbosity.clone(),
+                UserInputProvenance::Runtime,
+            )
+            .await;
     }
 
     /// Run the engine event loop
@@ -3544,7 +3601,7 @@ impl Engine {
             Some(SubAgentForkContext {
                 messages: self.messages_with_turn_metadata(),
                 structured_state_block: state.to_system_block(),
-                // Resolve at spawn time so a work update earlier in this turn
+                // Resolve at spawn time so a todo_write earlier in this turn
                 // reaches the child rather than freezing turn-start state.
                 work_source: Some(self.work_state_source()),
             })

crates/tui/src/core/engine/tests.rs

@@ -10900,10 +10900,10 @@ async fn run_graph_backed_work_update(
     use crate::tools::spec::ToolSpec as _;
     let mut context = crate::tools::spec::ToolContext::new(std::env::temp_dir());
     context.runtime.work = Some(work.clone());
-    crate::tools::todo::TodoWriteTool::work_update(todos.clone())
+    crate::tools::todo::TodoWriteTool::new(todos.clone())
         .execute(json!({ "todos": items }), &context)
         .await
-        .expect("graph-backed work_update");
+        .expect("graph-backed todo_write");
 }
 
 /// #3983 runtime regression: a real graph-backed `work_update` stages the new
@@ -15737,13 +15737,16 @@ async fn idle_engine_wakes_for_finished_background_shell_only_while_goal_active(
         tokio::time::sleep(Duration::from_millis(25)).await;
     }
 
-    // No active goal: the wake stays disarmed and the idle receive keeps
-    // waiting — completions belong to the next user-initiated turn.
-    let disarmed =
-        tokio::time::timeout(Duration::from_millis(300), engine.next_run_input(false)).await;
+    // No active goal: the wake still arms — a finished background task must
+    // reach the model without waiting for the user to type, the same wake an
+    // idle sub-agent completion already gets.
+    let input = tokio::time::timeout(Duration::from_secs(10), engine.next_run_input(false))
+        .await
+        .expect("idle engine must wake for finished background shell work even without a goal")
+        .expect("engine input");
     assert!(
-        disarmed.is_err(),
-        "without an active goal the engine must not start turns for shell completions"
+        matches!(input, EngineRunInput::ShellCompletionWake),
+        "wake input expected without an active goal"
     );
 
     engine