diff --git a/Cargo.lock b/Cargo.lock
index a5519168..b06c0a74 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6852,7 +6852,7 @@ dependencies = [
 [[package]]
 name = "octos-agent"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "async-trait",
  "base64 0.22.1",
@@ -6982,7 +6982,7 @@ dependencies = [
 [[package]]
 name = "octos-bus"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "aes 0.8.4",
  "async-trait",
@@ -7011,7 +7011,7 @@ dependencies = [
 [[package]]
 name = "octos-cli"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "agent-client-protocol",
  "argon2",
@@ -7092,7 +7092,7 @@ dependencies = [
 [[package]]
 name = "octos-core"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "chrono",
  "eyre",
@@ -7106,7 +7106,7 @@ dependencies = [
 [[package]]
 name = "octos-diagnostics"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "eyre",
  "octos-core",
@@ -7118,7 +7118,7 @@ dependencies = [
 [[package]]
 name = "octos-fleet"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "eyre",
  "octos-core",
@@ -7134,7 +7134,7 @@ dependencies = [
 [[package]]
 name = "octos-fleet-worker"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "async-trait",
  "eyre",
@@ -7151,7 +7151,7 @@ dependencies = [
 [[package]]
 name = "octos-llm"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "async-trait",
  "base64 0.22.1",
@@ -7175,7 +7175,7 @@ dependencies = [
 [[package]]
 name = "octos-memory"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "bincode",
  "chrono",
@@ -7194,7 +7194,7 @@ dependencies = [
 [[package]]
 name = "octos-pipeline"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "async-trait",
  "chrono",
@@ -7216,7 +7216,7 @@ dependencies = [
 [[package]]
 name = "octos-plugin"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "eyre",
  "metrics",
@@ -7230,7 +7230,7 @@ dependencies = [
 [[package]]
 name = "octos-research"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "base64 0.22.1",
  "chromiumoxide",
@@ -7254,7 +7254,7 @@ dependencies = [
 [[package]]
 name = "octos-sandbox"
 version = "0.1.0"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "clap",
  "eyre",
@@ -7269,7 +7269,7 @@ dependencies = [
 [[package]]
 name = "octos-services"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "chrono",
  "dirs",
@@ -7291,7 +7291,7 @@ dependencies = [
 [[package]]
 name = "octos-store"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "base64 0.22.1",
  "chrono",
@@ -7311,7 +7311,7 @@ dependencies = [
 [[package]]
 name = "octos-swarm"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "async-trait",
  "chrono",
@@ -7330,7 +7330,7 @@ dependencies = [
 [[package]]
 name = "octos-workflows"
 version = "2.0.3-rc.13"
-source = "git+https://github.com/octos-org/octos.git?rev=ae230ce04d57f3c29cf6c2518e5956a86c07d788#ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+source = "git+https://github.com/octos-org/octos.git?rev=056173e85b150e387805fc307fe231064ac1ed35#056173e85b150e387805fc307fe231064ac1ed35"
 dependencies = [
  "chrono",
  "eyre",
diff --git a/Cargo.toml b/Cargo.toml
index 8653183d..5108d045 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -110,7 +110,12 @@ octosense-app-hub = { git = "https://github.com/OctoSense-org/OctoSense-App-Hub"
 # and App Hub and Rinx no longer need the same App Hub commit.
 octosense-app-contract = "1"
 # --- octos: ONE source for every octos crate (octos-org/octos main at the
-# merge of octos#2656, low fixes for host-owned app peers; after #2655, the
+# merge of octos#2675, hydrate rows that name a tool row's call and tool;
+# after #2672, the accepted client_commands echoed on session/open, #2671
+# and #2669, docs, #2665, undeclared secrets kept from strict skills, #2664,
+# octos's own dev profile, and #2261, a credential store that keeps
+# credentials on a failed save; before that #2656, low fixes for host-owned
+# app peers; #2655, the
 # unknown-outcome interlock kept across a kernel restart, #2653, a bound
 # workspace swapped for a symlink no longer re-roots the session, #2648, a
 # host session's exact tool list; #2649,
@@ -120,12 +125,12 @@ octosense-app-contract = "1"
 # keeps its peer/input, and #2645, Bing News's Chinese results).
 # Move octos-core, octos-cli and octos-research together; the Android kernel
 # artifact (liboctos.so) is built from this same revision.
-octos-core = { git = "https://github.com/octos-org/octos.git", rev = "ae230ce04d57f3c29cf6c2518e5956a86c07d788" }
-octos-cli = { git = "https://github.com/octos-org/octos.git", rev = "ae230ce04d57f3c29cf6c2518e5956a86c07d788", default-features = false }
+octos-core = { git = "https://github.com/octos-org/octos.git", rev = "056173e85b150e387805fc307fe231064ac1ed35" }
+octos-cli = { git = "https://github.com/octos-org/octos.git", rev = "056173e85b150e387805fc307fe231064ac1ed35", default-features = false }
 # The research engine (the metasearch, the SSRF-safe polite reader and the
 # toolbox scope) for the toolbox's `octos-engine` feature. Same source and
 # revision as above.
-octos-research = { git = "https://github.com/octos-org/octos.git", rev = "ae230ce04d57f3c29cf6c2518e5956a86c07d788", default-features = false }
+octos-research = { git = "https://github.com/octos-org/octos.git", rev = "056173e85b150e387805fc307fe231064ac1ed35", default-features = false }
 # --- AppCard's inline renderers.
 streaming-markdown-kit = { git = "https://github.com/Project-Robius-China/streaming-markdown-kit.git", branch = "main" }
 makepad-diagram-kit = { git = "https://github.com/Project-Robius-China/makepad-diagram-kit.git", branch = "main" }
diff --git a/crates/kernel/src/kernel.rs b/crates/kernel/src/kernel.rs
index 360847b4..78482254 100644
--- a/crates/kernel/src/kernel.rs
+++ b/crates/kernel/src/kernel.rs
@@ -60,6 +60,9 @@ struct Io {
     /// host-managed server stops when it reaches EOF, which also happens
     /// when this process dies, so a crashed shell leaves no kernel behind.
     lifeline: Option<tokio::process::ChildStdin>,
+    /// The task copying the child's stderr into the [`Tail`]; it ends at
+    /// the end of the pipe, after the kernel's last line.
+    stderr: Option<tokio::task::JoinHandle<()>>,
 }
 
 /// Keeps the last lines the kernel wrote to stderr, to say why it exited.
@@ -116,7 +119,7 @@ fn start(launch: &Launch, network: &Network, log: &LogSink, tail: &Tail) -> Resu
                 return Err("the kernel's stdin/stdout are not piped".into());
             };
             // The kernel logs to stderr; it never carries protocol frames.
-            if let Some(stderr) = child.stderr.take() {
+            let stderr = child.stderr.take().map(|stderr| {
                 let log = log.clone();
                 let tail = tail.clone();
                 tokio::spawn(async move {
@@ -126,14 +129,14 @@ fn start(launch: &Launch, network: &Network, log: &LogSink, tail: &Tail) -> Resu
                         (log)(&format!("octos: {line}"));
                         tail.push(line);
                     }
-                });
-            }
+                })
+            });
             let lines = BufReader::new(Box::pin(stdout) as Pin<Box<dyn AsyncRead + Send>>).lines();
             Ok(if shared {
                 // Frames go over the WebSocket once it is up (`prepare_network`).
-                Io { writer: Box::pin(tokio::io::sink()), lines, running: Running::Child(child), lifeline: Some(stdin) }
+                Io { writer: Box::pin(tokio::io::sink()), lines, running: Running::Child(child), lifeline: Some(stdin), stderr }
             } else {
-                Io { writer: Box::pin(stdin), lines, running: Running::Child(child), lifeline: None }
+                Io { writer: Box::pin(stdin), lines, running: Running::Child(child), lifeline: None, stderr }
             })
         }
         #[cfg(target_env = "ohos")]
@@ -153,6 +156,7 @@ fn start(launch: &Launch, network: &Network, log: &LogSink, tail: &Tail) -> Resu
                 lines: BufReader::new(Box::pin(reader) as Pin<Box<dyn AsyncRead + Send>>).lines(),
                 running: Running::Embedded(task),
                 lifeline: None,
+                stderr: None,
             })
         }
         #[cfg(not(target_env = "ohos"))]
@@ -266,7 +270,7 @@ async fn exited(running: &mut Running) -> String {
 async fn stop(io: Io) {
     // Closing stdin stops either kind of child: the stdio pipe drains owned
     // turns on EOF; a host-managed server drains its connections and exits.
-    let Io { writer, lines, mut running, lifeline } = io;
+    let Io { writer, lines, mut running, lifeline, .. } = io;
     let grace = if lifeline.is_some() { SHARED_GRACE } else { STDIO_GRACE };
     drop(writer);
     drop(lines);
@@ -401,16 +405,18 @@ pub(crate) async fn supervise(
                                 }
                             }
                         }
-                        Ok(None) => break CloseReason::Exited(with_tail("the kernel closed its output", &tail)),
+                        Ok(None) => break CloseReason::Exited("the kernel closed its output".into()),
                         Err(e) => break CloseReason::Exited(format!("reading from the kernel failed: {e}")),
                     },
-                    why = exited(&mut io.running) => break CloseReason::Exited(with_tail(&why, &tail)),
+                    why = exited(&mut io.running) => break CloseReason::Exited(why),
                 }
             }};
             (log)(&format!("octos-core: stopping kernel {generation}: {reason}"));
+            let stderr = io.stderr.take();
             stop(io).await;
             match reason {
-                CloseReason::Failed(why) => CloseReason::Failed(with_tail(&why, &tail)),
+                CloseReason::Failed(why) => CloseReason::Failed(last_words(&why, stderr, &tail).await),
+                CloseReason::Exited(why) => CloseReason::Exited(last_words(&why, stderr, &tail).await),
                 other => other,
             }
         }
@@ -464,6 +470,24 @@ fn tool_list_reply(text: &str) -> Option<String> {
     })
 }
 
+/// How long a stopped kernel's stderr may take to reach its end. The pipe
+/// closes with the kernel; only a process it started that inherited the
+/// pipe can hold it open longer.
+const LAST_WORDS_GRACE: Duration = Duration::from_secs(2);
+
+/// `why` with the kernel's last words (the [`Tail`]), once `stderr`, the
+/// task reading them, has reached the end of the pipe. That task runs
+/// beside the supervisor, so lines the kernel wrote just before its stdout
+/// closed or it exited can still be on their way to the tail: read at once,
+/// the reason said "the kernel closed its output: fake kernel up" without
+/// the "asked to exit" the kernel wrote last.
+async fn last_words(why: &str, stderr: Option<tokio::task::JoinHandle<()>>, tail: &Tail) -> String {
+    if let Some(reader) = stderr {
+        let _ = tokio::time::timeout(LAST_WORDS_GRACE, reader).await;
+    }
+    with_tail(why, tail)
+}
+
 fn with_tail(why: &str, tail: &Tail) -> String {
     let tail = tail.text();
     if tail.is_empty() {
diff --git a/crates/kernel/tests/core.rs b/crates/kernel/tests/core.rs
index 2a74ba25..43d9d545 100644
--- a/crates/kernel/tests/core.rs
+++ b/crates/kernel/tests/core.rs
@@ -238,7 +238,9 @@ async fn a_kernel_that_dies_closes_its_connections_with_its_last_words() {
     call(&mut a, "1", "session/list", json!({})).await;
     a.send(json!({"jsonrpc": "2.0", "method": "test/exit", "params": {}}).to_string()).unwrap();
     match next(&mut a).await {
-        Err(CloseReason::Exited(why)) => assert!(why.contains("asked to exit") || why.contains("exit"), "{why}"),
+        // The line it wrote to stderr last, whichever end the core saw
+        // first: its output closing or its exit status.
+        Err(CloseReason::Exited(why)) => assert!(why.contains("asked to exit"), "{why}"),
         other => panic!("expected Exited, got {other:?}"),
     }
     for _ in 0..100 {
diff --git a/crates/shell/src/approvals/mod.rs b/crates/shell/src/approvals/mod.rs
index 33168e40..0d1a0fd2 100644
--- a/crates/shell/src/approvals/mod.rs
+++ b/crates/shell/src/approvals/mod.rs
@@ -130,6 +130,31 @@ impl Approvals {
     pub fn consent_granted(&self, app: &str) -> bool {
         self.consent.granted(app, self.router.hooks().grants_all(app))
     }
+    /// The relay's entry point (octos#2567) on these approvals: a call
+    /// needs an approval.
+    pub fn approval_requested(&mut self, app: &str, tool: ToolSpec, args: serde_json::Value, caller: Caller, context: RequestContext) -> Route {
+        self.router.approval_requested(app, tool, args, caller, context)
+    }
+    /// The relay installs itself; decisions made before are handed over
+    /// first.
+    pub fn set_relay(&mut self, mut relay: Box<dyn ApprovalRelay>) {
+        for (id, decision, reason) in self.queue.take() {
+            relay.approval_decided(&id, decision, &reason);
+        }
+        *self.external.lock().unwrap_or_else(|e| e.into_inner()) = Some(relay);
+    }
+    /// The AI bus's held `confirm: host` call as a request like any other.
+    pub fn bus_requested(&mut self, held: &crate::ai_bus::HeldCall) -> Route {
+        let mut tool = ToolSpec::host(&held.tool);
+        tool.auto_approvable = held.auto_approvable;
+        if held.command {
+            tool = tool.command();
+        }
+        let args = serde_json::from_str(&held.args).unwrap_or_else(|_| serde_json::Value::String(held.args.clone()));
+        // The pane is the person's own conversation with the system agent.
+        let context = RequestContext { call_id: held.key.clone(), trigger: Trigger::Person, ..RequestContext::default() };
+        self.approval_requested(&held.app, tool, args, Caller::SystemAgent, context)
+    }
 }
 
 static STATE: Mutex<Option<Approvals>> = Mutex::new(None);
@@ -160,34 +185,23 @@ pub fn now() -> u64 {
 
 // ------------------------------------------------------------ the relay
 
-/// The relay's entry point (octos#2567): a call needs an approval.
+/// The relay's entry point (octos#2567): a call needs an approval
+/// ([`Approvals::approval_requested`] on the shell's approvals).
 pub fn approval_requested(app: &str, tool: ToolSpec, args: serde_json::Value, caller: Caller, context: RequestContext) -> Route {
-    with(|a| a.router.approval_requested(app, tool, args, caller, context)).unwrap_or_else(|| Route::Refused("approvals are not set up".into()))
+    with(|a| a.approval_requested(app, tool, args, caller, context)).unwrap_or_else(|| Route::Refused("approvals are not set up".into()))
 }
 
-/// The relay installs itself; decisions made before are handed over first.
-pub fn set_relay(mut relay: Box<dyn ApprovalRelay>) {
-    with(|a| {
-        for (id, decision, reason) in a.queue.take() {
-            relay.approval_decided(&id, decision, &reason);
-        }
-        *a.external.lock().unwrap_or_else(|e| e.into_inner()) = Some(relay);
-    });
+/// The relay installs itself; decisions made before are handed over first
+/// ([`Approvals::set_relay`] on the shell's approvals).
+pub fn set_relay(relay: Box<dyn ApprovalRelay>) {
+    with(|a| a.set_relay(relay));
 }
 
 /// The AI bus's `confirm: host` calls (`ai_bus::Route::Approval`): each is
 /// a request like any other; the shell drains the answers here and
 /// releases the held call (`AiBus::release`).
 pub fn bus_requested(held: &crate::ai_bus::HeldCall) -> Route {
-    let mut tool = ToolSpec::host(&held.tool);
-    tool.auto_approvable = held.auto_approvable;
-    if held.command {
-        tool = tool.command();
-    }
-    let args = serde_json::from_str(&held.args).unwrap_or_else(|_| serde_json::Value::String(held.args.clone()));
-    // The pane is the person's own conversation with the system agent.
-    let context = RequestContext { call_id: held.key.clone(), trigger: Trigger::Person, ..RequestContext::default() };
-    approval_requested(&held.app, tool, args, Caller::SystemAgent, context)
+    with(|a| a.bus_requested(held)).unwrap_or_else(|| Route::Refused("approvals are not set up".into()))
 }
 
 pub fn take_bus_decisions() -> Vec<(RequestId, Decision, String)> {
diff --git a/crates/shell/src/approvals/tests.rs b/crates/shell/src/approvals/tests.rs
index 6b41ace1..329ae884 100644
--- a/crates/shell/src/approvals/tests.rs
+++ b/crates/shell/src/approvals/tests.rs
@@ -993,32 +993,31 @@ fn only_settings_and_the_sheet_make_a_person_gesture() {
 
 // ---------------------------------------------------------------- the relay seam
 
+/// On approvals of its own, never the shell's (`super::with`): those are
+/// the process's, and the tests that run app agents keep their consent
+/// and relay there while this runs.
 #[test]
 fn the_relay_gets_decisions_made_before_it_was_installed() {
-    super::init_memory();
-    let route = super::approval_requested("os.mail", ToolSpec::host("mail.archive").not_auto_approvable(), json!({"id": 1}), Caller::SystemAgent, ctx("g1", Trigger::Person));
-    assert!(matches!(route, Route::Sheet(_)));
-    let (sheet, id) = super::with(|a| {
+    let mut a = super::Approvals::memory();
+    let front = |a: &super::Approvals| {
         let s = a.router.front_sheet().unwrap();
         (s.id, s.lines[0].request.clone())
-    })
-    .unwrap();
-    super::with(|a| a.router.answer(sheet, &id, Answer::Deny, &ApprovalGesture::sheet_tap(), T0)).unwrap().unwrap();
+    };
+    let route = a.approval_requested("os.mail", ToolSpec::host("mail.archive").not_auto_approvable(), json!({"id": 1}), Caller::SystemAgent, ctx("g1", Trigger::Person));
+    assert!(matches!(route, Route::Sheet(_)));
+    let (sheet, id) = front(&a);
+    a.router.answer(sheet, &id, Answer::Deny, &ApprovalGesture::sheet_tap(), T0).unwrap();
     let relay = RecordingRelay::default();
-    super::set_relay(Box::new(relay.clone()));
+    a.set_relay(Box::new(relay.clone()));
     assert_eq!(relay.take(), vec![(RequestId("g1".into()), Decision::Deny, "denied on the sheet".into())]);
     // From now on, straight to it.
-    super::approval_requested("os.mail", ToolSpec::host("mail.archive").not_auto_approvable(), json!({"id": 2}), Caller::SystemAgent, ctx("g2", Trigger::Person));
-    let (sheet, id) = super::with(|a| {
-        let s = a.router.front_sheet().unwrap();
-        (s.id, s.lines[0].request.clone())
-    })
-    .unwrap();
-    super::with(|a| a.router.answer(sheet, &id, Answer::Once, &ApprovalGesture::sheet_tap(), T0)).unwrap().unwrap();
+    a.approval_requested("os.mail", ToolSpec::host("mail.archive").not_auto_approvable(), json!({"id": 2}), Caller::SystemAgent, ctx("g2", Trigger::Person));
+    let (sheet, id) = front(&a);
+    a.router.answer(sheet, &id, Answer::Once, &ApprovalGesture::sheet_tap(), T0).unwrap();
     assert_eq!(relay.take().len(), 1);
     // The AI bus's held `confirm: host` calls come back to the shell, not
     // to the relay: the Terminal's `run` asks the person, never a rule.
-    super::with(|a| a.router.create_rule(&ApprovalGesture::settings_tap(), RuleDraft::everything("terminal", 30), T0)).unwrap().unwrap();
+    a.router.create_rule(&ApprovalGesture::settings_tap(), RuleDraft::everything("terminal", 30), T0).unwrap();
     let held = crate::ai_bus::HeldCall {
         key: "bus:w4:c1".into(),
         app: "terminal".into(),
@@ -1027,19 +1026,18 @@ fn the_relay_gets_decisions_made_before_it_was_installed() {
         auto_approvable: false,
         command: true,
     };
-    assert!(matches!(super::bus_requested(&held), Route::Sheet(_)));
-    let (sheet, id, caller, args) = super::with(|a| {
+    assert!(matches!(a.bus_requested(&held), Route::Sheet(_)));
+    let (sheet, id, caller, args) = {
         let s = a.router.front_sheet().unwrap();
         (s.id, s.lines[0].request.clone(), s.lines[0].caller.clone(), s.lines[0].args.join(" "))
-    })
-    .unwrap();
+    };
     assert_eq!(id, RequestId("bus:w4:c1".into()));
     assert_eq!(caller, "The system agent");
     assert_eq!(args, "command (1 line):   1 \u{2502} ls", "a command, one numbered row per line");
-    super::with(|a| a.router.answer(sheet, &id, Answer::Once, &ApprovalGesture::sheet_tap(), T0)).unwrap().unwrap();
+    a.router.answer(sheet, &id, Answer::Once, &ApprovalGesture::sheet_tap(), T0).unwrap();
     assert!(relay.take().is_empty());
-    assert_eq!(super::take_bus_decisions(), vec![(id, Decision::ApproveOnce, "approved on the sheet".into())]);
-    assert!(!super::consent_granted("os.news"), "developer mode is off in tests: nothing is granted");
+    assert_eq!(a.bus.take(), vec![(id, Decision::ApproveOnce, "approved on the sheet".into())]);
+    assert!(!a.consent_granted("os.news"), "developer mode is off in tests: nothing is granted");
 }
 
 /// The module host's gate: the first ask shows the first-use sheet and
diff --git a/crates/shell/src/apps.rs b/crates/shell/src/apps.rs
index 5cba914d..64b30f32 100644
--- a/crates/shell/src/apps.rs
+++ b/crates/shell/src/apps.rs
@@ -141,6 +141,32 @@ pub fn system_card_apps() -> Vec<crate::clients::AppDef> {
     Vec::new()
 }
 
+/// System apps a test registers for itself (the glance tile tests'
+/// probes). They join App Hub's registry, the one [`system_card_apps`]
+/// lists, which is process-wide and never forgets an app, so a test of the
+/// build's own catalog saw them or not depending on which tests had run
+/// before it in the same process. A test registers its app here, and the
+/// catalog tests leave these out.
+#[cfg(test)]
+pub(crate) mod test_system_apps {
+    use std::sync::Mutex;
+
+    static IDS: Mutex<Vec<&'static str>> = Mutex::new(Vec::new());
+
+    /// Register `app` for a test. It is noted first, so a catalog that
+    /// lists it was read after it was noted.
+    #[cfg(feature = "app-hub")]
+    pub(crate) fn register(app: octosense_appstore::system::SystemApp) {
+        IDS.lock().unwrap_or_else(|e| e.into_inner()).push(app.id);
+        octosense_appstore::system::register_system_app(app);
+    }
+
+    /// Whether a test registered the system app `id` (an `os.` id).
+    pub(crate) fn is_test_app(id: &str) -> bool {
+        IDS.lock().unwrap_or_else(|e| e.into_inner()).contains(&id)
+    }
+}
+
 /// The services contained apps call through `host.request` (ADR 0004)
 /// that are not the assistant's, registered once, before the first system
 /// app can open: `mail` keeps accounts and passwords for the Mail app;
@@ -658,12 +684,19 @@ mod tests {
             .collect()
     }
 
+    /// The build's own rows among `rows`: without the system apps other
+    /// tests registered for themselves ([`super::test_system_apps`]).
+    /// `rows` must be read before this looks, as an argument is.
+    fn build_rows(rows: Vec<crate::clients::AppDef>) -> Vec<crate::clients::AppDef> {
+        rows.into_iter().filter(|row| !card_manifest_id(row).is_some_and(super::test_system_apps::is_test_app)).collect()
+    }
+
     #[cfg(feature = "mobile-apps")]
     #[test]
     fn bundled_apps_open_without_catalog_files_or_child_processes() {
         use makepad_widgets::*;
         let _one_rinx = crate::module_host::RINX_INSTANCE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
-        let catalog = bundled_catalog();
+        let catalog = build_rows(bundled_catalog());
         // The linked modules in link order (AppCard is opt-in, `app-appcard`,
         // not part of `mobile-apps`; `settings` is the phone product's), then
         // the system apps no native module of the same id replaces.
@@ -718,7 +751,7 @@ mod tests {
         let mut cx = Cx::new(Box::new(|_, _| {}));
         cx.with_vm(makepad_widgets::script_mod);
         let mut host = crate::module_host::ModuleHost::default();
-        for (index, app) in bundled_catalog().iter().enumerate() {
+        for (index, app) in build_rows(bundled_catalog()).iter().enumerate() {
             let module = registry.module(&app.id).unwrap();
             let client = index as u64 + 1;
             host.create(&mut cx, client, module, module_open(module, app).unwrap(), dvec2(400.0, 700.0)).unwrap();
@@ -768,7 +801,7 @@ mod tests {
     fn the_system_apps_ship_as_card_apps() {
         let registry = AppRegistry::default();
         let native = registry.linked_ids();
-        let ids: Vec<String> = system_card_apps().into_iter().map(|app| app.id).collect();
+        let ids: Vec<String> = build_rows(system_card_apps()).into_iter().map(|app| app.id).collect();
         let expected: Vec<&str> = system_app_ids().iter().copied().filter(|id| !native.contains(id)).collect();
         assert_eq!(ids, expected);
         for id in &ids {
diff --git a/crates/shell/src/glance_card.rs b/crates/shell/src/glance_card.rs
index 7716a342..6906a252 100644
--- a/crates/shell/src/glance_card.rs
+++ b/crates/shell/src/glance_card.rs
@@ -839,7 +839,8 @@ mod tests {
     }
 
     /// A system app, registered from a pack made on the fly, whose manifest
-    /// grants `glance` and `storage` and nothing else.
+    /// grants `glance` and `storage` and nothing else. It is registered as
+    /// a test's, so the catalog tests running beside these leave it out.
     #[cfg(feature = "app-hub")]
     fn register_test_app(id: &'static str) {
         let dir = std::env::temp_dir().join(format!("glance-tile-app-{id}-{}", std::process::id()));
@@ -852,7 +853,7 @@ mod tests {
         );
         std::fs::write(dir.join("manifest.json"), manifest).unwrap();
         let pack = serde_json::to_string(&octosense_app_hub::pack::pack_dir(&dir).unwrap()).unwrap();
-        octosense_appstore::system::register_system_app(octosense_appstore::system::SystemApp { id, name: "Glance test", pack: Box::leak(pack.into_boxed_str()), assets: &[] });
+        crate::apps::test_system_apps::register(octosense_appstore::system::SystemApp { id, name: "Glance test", pack: Box::leak(pack.into_boxed_str()), assets: &[] });
     }
 
     /// A Cx with the widgets and the tile frame registered, for driving
diff --git a/crates/shell/src/host_tools/scenario_tests.rs b/crates/shell/src/host_tools/scenario_tests.rs
index 9e4e1125..083d6216 100644
--- a/crates/shell/src/host_tools/scenario_tests.rs
+++ b/crates/shell/src/host_tools/scenario_tests.rs
@@ -688,6 +688,23 @@ fn the_system_agent_and_the_person_work_with_one_app_agent_at_once() {
     assert_eq!((rows[audience]["lane"].clone(), rows[publish]["lane"].clone()), (json!("person"), json!("system_agent")));
     assert!(task < ask && ask < audience && audience < publish, "merged by time: task {task}, ask {ask}, audience {audience}, publish {publish}");
     assert!(rows.iter().all(|m| !m["content"].as_str().unwrap_or("").contains("<shared_history")), "the shared block is in neither transcript");
+
+    // 3g. A reload names its tool rows (octos#2675): the history's tool rows
+    // carry the tool's name and call id, so the panel shows News's agent's
+    // call by name, and the system chat its delegation, not "tool".
+    let named = |items: &[crate::system_chat::model::Item], tool: &str| {
+        items.iter().any(|i| matches!(i, crate::system_chat::model::Item::Tool { name, call_id, .. } if name == tool && !call_id.is_empty()))
+    };
+    let share = at(&|m| m["role"] == "tool" && m["tool_name"] == "news_share");
+    assert_eq!(rows[share]["lane"], "system_agent", "{rows:#?}");
+    assert!(rows[share]["tool_call_id"].as_str().is_some_and(|id| !id.is_empty()), "{:#?}", rows[share]);
+    let mut panel = crate::app_chat::model::Conversation::new(APP);
+    panel.load_history(&history["messages"]);
+    assert!(named(&panel.chat.items, "news_share"), "{:#?}", panel.chat.items);
+    let system = s.broker.host_request("session/hydrate", json!({"session_id": SYSTEM, "include": ["messages"]})).expect("the system chat's history");
+    let mut pane = crate::system_chat::model::ChatModel::new();
+    pane.load_history(&system["messages"]);
+    assert!(named(&pane.items, "peer_send_input"), "{:#?}", pane.items);
 }
 
 /// (a) Nobody answers: at a short deadline the shell's router denies the
diff --git a/crates/shell/src/module_input_tests.rs b/crates/shell/src/module_input_tests.rs
index f7b5b752..023feda6 100644
--- a/crates/shell/src/module_input_tests.rs
+++ b/crates/shell/src/module_input_tests.rs
@@ -6,6 +6,12 @@
 //! which a GestureView ignores. News's story rows are GestureViews, so a
 //! click on Mail's inbox footer, over News's third story, opened that story
 //! (the instrument's B3).
+//!
+//! A hover goes the same way. The window in front takes a hover inside it
+//! even where none of its widgets does, and a tile behind lets a hover a
+//! window in front took by. Before, no tile claimed a move, so a hover over
+//! Mail's empty part reached News's widgets unclaimed: they lit up and set
+//! their cursors under Mail.
 
 use crate::module_host::ModuleHost;
 use crate::module_view::MpModuleView;
@@ -27,12 +33,13 @@ script_mod! {
     }
 }
 
-/// An app's root that counts the presses reaching it. A tappable one takes
-/// them as makepad's GestureView does: a button press through
+/// An app's root that counts the presses and hovers reaching it. A tappable
+/// one takes them as makepad's GestureView does: a button press through
 /// `hits_with_capture_overload`, which co-captures a press another area
 /// already claimed, and a touch straight from the raw stream. A claim alone
-/// never keeps a press from it. An inert one takes nothing, like the empty
-/// part of a window (Mail's inbox footer).
+/// never keeps a press from it. It takes a hover through the same hit test,
+/// as a Button or a View does, which claims the move. An inert one takes
+/// nothing, like the empty part of a window (Mail's inbox footer).
 #[derive(Script, ScriptHook, Widget)]
 pub struct TapProbe {
     #[uid]
@@ -54,6 +61,12 @@ pub struct TapProbe {
     /// Presses it took and saw released over it.
     #[rust]
     taps: usize,
+    /// Hovers (mouse moves with no button held) that reached the app.
+    #[rust]
+    moves: usize,
+    /// Hovers it took.
+    #[rust]
+    hovers: usize,
     /// The touch it follows.
     #[rust]
     touch: Option<u64>,
@@ -63,6 +76,7 @@ impl Widget for TapProbe {
     fn handle_event(&mut self, cx: &mut Cx, event: &Event, _scope: &mut Scope) {
         match event {
             Event::MouseDown(_) => self.seen += 1,
+            Event::MouseMove(_) => self.moves += 1,
             Event::TouchUpdate(update) => {
                 self.seen += update.touches.iter().filter(|t| t.state == TouchState::Start).count();
             }
@@ -88,10 +102,10 @@ impl Widget for TapProbe {
             }
             return;
         }
-        if let Hit::FingerUp(e) = event.hits_with_capture_overload(cx, area, true) {
-            if e.is_over {
-                self.taps += 1;
-            }
+        match event.hits_with_capture_overload(cx, area, true) {
+            Hit::FingerUp(e) if e.is_over => self.taps += 1,
+            Hit::FingerHoverIn(_) | Hit::FingerHoverOver(_) => self.hovers += 1,
+            _ => {}
         }
     }
 
@@ -112,6 +126,8 @@ enum Root {
     Inert,
     /// Makepad's own GestureView.
     Gesture,
+    /// Makepad's own Button.
+    Button,
 }
 
 struct InputProbe {
@@ -142,6 +158,10 @@ impl AppModule for InputProbe {
                 let value = script_eval!(vm, { use mod.widgets.* GestureView {} });
                 WidgetRef::script_from_value(vm, value)
             }
+            Root::Button => {
+                let value = script_eval!(vm, { use mod.widgets.* Button { text: "Read" } });
+                WidgetRef::script_from_value(vm, value)
+            }
             Root::Tappable | Root::Inert => {
                 let value = script_eval!(vm, { use mod.widgets.* TapProbe {} });
                 let root = WidgetRef::script_from_value(vm, value);
@@ -169,6 +189,8 @@ static NEWS: InputProbe = InputProbe { id: "news-probe", root: Root::Tappable };
 static MAIL: InputProbe = InputProbe { id: "mail-probe", root: Root::Inert };
 /// News with makepad's GestureView as its row, as its bundle has it.
 static GESTURE_NEWS: InputProbe = InputProbe { id: "gesture-probe", root: Root::Gesture };
+/// News with makepad's Button under the pointer, as its tab bar has them.
+static BUTTON_NEWS: InputProbe = InputProbe { id: "button-probe", root: Root::Button };
 
 fn setup() -> (Cx, ModuleHost) {
     let mut cx = Cx::new(Box::new(|_, _| {}));
@@ -242,6 +264,18 @@ fn mouse_up(abs: Vec2d) -> Event {
     Event::MouseUp(MouseUpEvent { abs, button: MouseButton::PRIMARY, window_id: WindowId(0, 0), modifiers: Default::default(), time: 1.1 })
 }
 
+/// A mouse move with no button held.
+fn hover(abs: Vec2d) -> Event {
+    Event::MouseMove(MouseMoveEvent {
+        abs,
+        lock_delta: Vec2d::default(),
+        window_id: WindowId(0, 0),
+        modifiers: Default::default(),
+        time: 1.2,
+        handled: Cell::new(Area::Empty),
+    })
+}
+
 fn touch(abs: Vec2d, state: TouchState) -> Event {
     Event::TouchUpdate(TouchUpdateEvent {
         time: 1.0,
@@ -296,6 +330,15 @@ fn counts(cx: &mut Cx, host: &mut ModuleHost, client: u64) -> (usize, usize) {
     .unwrap()
 }
 
+/// (hovers seen, hovers taken) of a probe app.
+fn hover_counts(cx: &mut Cx, host: &mut ModuleHost, client: u64) -> (usize, usize) {
+    host.dispatch(cx, client, "a test read", |_, root| {
+        let probe = root.borrow::<TapProbe>().unwrap();
+        (probe.moves, probe.hovers)
+    })
+    .unwrap()
+}
+
 /// News is opened, then Mail, which cascades over it. A press inside both
 /// lands on Mail where Mail has nothing to take it, over a News row.
 const NEWS_AT: (f64, f64) = (20.0, 40.0);
@@ -368,6 +411,70 @@ fn a_gesture_view_behind_the_window_in_front_never_captures_its_press() {
     close(cx, host, vec![news, mail], frame, &[1, 2]);
 }
 
+/// A hover on the front window where it takes none: Mail's tile takes it,
+/// and News's app behind never sees it.
+#[test]
+fn a_hover_on_the_window_in_front_never_reaches_the_app_behind() {
+    let (mut cx, mut host, news, mail, frame) = news_and_mail(&NEWS);
+    let over_both = dvec2(OVER_BOTH.0, OVER_BOTH.1);
+    let moved = [hover(over_both)];
+    assert_eq!(offer(&mut cx, &[&mail, &news], &moved), [], "a hover raises nothing");
+    assert_eq!(hover_counts(&mut cx, &mut host, 2), (1, 0), "Mail's app saw it; nothing there took it");
+    assert_eq!(hover_counts(&mut cx, &mut host, 1), (0, 0), "News's app never saw it, so its row did not light up");
+    // So Mail's tile took it: any window further back sees it claimed.
+    let Event::MouseMove(e) = &moved[0] else { unreachable!() };
+    assert!(!e.handled.get().is_empty(), "the hover left Mail unclaimed");
+    // Where News is in front of nothing, its row takes the hover...
+    offer(&mut cx, &[&mail, &news], &[hover(dvec2(NEWS_ONLY.0, NEWS_ONLY.1))]);
+    assert_eq!(hover_counts(&mut cx, &mut host, 1), (1, 1));
+    // ...and the move that takes the pointer on over Mail still reaches News,
+    // so the row sees its hover end. Mail took that move, so nothing lights
+    // up, and no move after it reaches News.
+    offer(&mut cx, &[&mail, &news], &[hover(over_both), hover(over_both + dvec2(10.0, 0.0))]);
+    assert_eq!(hover_counts(&mut cx, &mut host, 1), (2, 1), "one move to end the hover, none after it");
+    // Mail's app sees every move: those over it, and the one outside it.
+    assert_eq!(hover_counts(&mut cx, &mut host, 2), (4, 0));
+    close(cx, host, vec![news, mail], frame, &[1, 2]);
+}
+
+/// With makepad's own Button as the app behind: a hover it takes lights it
+/// up (`hover.on`) and asks for the hand cursor. A hover on Mail where Mail
+/// takes none does neither.
+#[test]
+fn a_button_behind_the_window_in_front_never_lights_up_under_it() {
+    let (mut cx, mut host, news, mail, frame) = news_and_mail(&BUTTON_NEWS);
+    let lit = |cx: &mut Cx, host: &mut ModuleHost| {
+        host.dispatch(cx, 1, "a test read", |cx, root| root.borrow::<Button>().unwrap().animator_in_state(cx, ids!(hover.on)))
+            .unwrap()
+    };
+    offer(&mut cx, &[&mail, &news], &[hover(dvec2(OVER_BOTH.0, OVER_BOTH.1))]);
+    assert_eq!(cx.mouse_cursor(), MouseCursor::Default, "News's button showed its hand over Mail");
+    assert!(!lit(&mut cx, &mut host), "News's button lit up under Mail");
+    // Where News is in front, the button takes the hover.
+    offer(&mut cx, &[&mail, &news], &[hover(dvec2(NEWS_ONLY.0, NEWS_ONLY.1))]);
+    assert_eq!(cx.mouse_cursor(), MouseCursor::Hand);
+    assert!(lit(&mut cx, &mut host));
+    close(cx, host, vec![news, mail], frame, &[1, 2]);
+}
+
+/// The closed face of an app that stopped after an error takes a hover
+/// inside it, as it takes a press: the app under the face never sees it.
+#[test]
+fn a_hover_on_a_stopped_face_never_reaches_the_app_behind() {
+    let (mut cx, mut host) = setup();
+    create(&mut cx, &mut host, 1, &NEWS);
+    create(&mut cx, &mut host, 2, &NEWS);
+    let (stopped, under) = (tile(&mut cx, &host, 1), tile(&mut cx, &host, 2));
+    stopped.borrow_mut::<MpModuleView>().unwrap().show_failed(&mut cx, "News");
+    let frame = draw_stack(&mut cx, &[(&under, at(NEWS_AT.0, NEWS_AT.1)), (&stopped, at(MAIL_AT.0, MAIL_AT.1))]);
+    assert_eq!(offer(&mut cx, &[&stopped, &under], &[hover(dvec2(OVER_BOTH.0, OVER_BOTH.1))]), []);
+    assert_eq!(hover_counts(&mut cx, &mut host, 2), (0, 0), "the app under the face saw the hover");
+    // Clear of the face, the app under it takes the hover.
+    offer(&mut cx, &[&stopped, &under], &[hover(dvec2(NEWS_ONLY.0, NEWS_ONLY.1))]);
+    assert_eq!(hover_counts(&mut cx, &mut host, 2), (1, 1));
+    close(cx, host, vec![stopped, under], frame, &[1, 2]);
+}
+
 /// The closed face of an app that stopped after an error takes presses the
 /// same way. A click on a window over its Restart does not restart it, and a
 /// click on the face raises no window behind it.
@@ -383,7 +490,7 @@ fn a_stopped_tile_takes_only_a_press_nothing_in_front_took() {
     // another app under it, reaching out right of Mail.
     let (under_at, stopped_at, mail_at) = (at(150.0, 0.0), at(100.0, 100.0), at(60.0, 120.0));
     let frame = draw_stack(&mut cx, &[(&under, under_at), (&stopped, stopped_at), (&over, mail_at)]);
-    let restart = stopped.borrow::<MpModuleView>().unwrap().restart_button().expect("the closed face has its Restart");
+    let restart = stopped.borrow::<MpModuleView>().unwrap().restart_button(&cx).expect("the closed face has its Restart");
     assert!(restart.is_inside_of(mail_at) && under_at.contains(restart.center()), "Mail covers the Restart: {restart:?}");
     let front_to_back = [&over, &stopped, &under];
     assert_eq!(click(&mut cx, &front_to_back, restart.center()), [Asked::Raise(2)], "a click on Mail is Mail's");
@@ -398,9 +505,37 @@ fn a_stopped_tile_takes_only_a_press_nothing_in_front_took() {
     drop(frame);
     let mail_at = at(500.0, 300.0);
     let frame = draw_stack(&mut cx, &[(&under, under_at), (&stopped, stopped_at), (&over, mail_at)]);
-    let restart = stopped.borrow::<MpModuleView>().unwrap().restart_button().unwrap();
+    let restart = stopped.borrow::<MpModuleView>().unwrap().restart_button(&cx).unwrap();
     assert!(!mail_at.contains(restart.center()));
     assert_eq!(click(&mut cx, &front_to_back, restart.center()), [Asked::Restart(1)]);
     assert_eq!(counts(&mut cx, &mut host, 3), (0, 0));
     close(cx, host, vec![stopped, over, under], frame, &[1, 2, 3]);
 }
+
+/// The closed face's Restart responds where it is drawn. The face centres
+/// its line and button as its turtle ends, after the button was walked, and
+/// it hit-tested the rect it walked: the face's top left, where nothing is
+/// drawn. A click or a tap on the visible button did nothing but raise the
+/// window, and a click at the top left restarted the app.
+#[test]
+fn the_restart_on_a_stopped_face_responds_where_it_is_drawn() {
+    let (mut cx, mut host) = setup();
+    create(&mut cx, &mut host, 1, &NEWS);
+    let stopped = tile(&mut cx, &host, 1);
+    stopped.borrow_mut::<MpModuleView>().unwrap().show_failed(&mut cx, "News");
+    let face = at(100.0, 100.0);
+    let frame = draw_stack(&mut cx, &[(&stopped, face)]);
+    let restart = stopped.borrow::<MpModuleView>().unwrap().restart_button(&cx).expect("the closed face has its Restart");
+    // Centred across the face, just under its middle (the line is above it).
+    assert!((restart.center().x - face.center().x).abs() < 1.0, "Restart is not centred across the face: {restart:?}");
+    assert!((restart.pos.y - face.center().y).abs() < restart.size.y, "Restart is not at the face's middle: {restart:?}");
+    assert_eq!(click(&mut cx, &[&stopped], restart.center()), [Asked::Restart(1)], "a click on the visible Restart");
+    assert_eq!(tap(&mut cx, &[&stopped], restart.center()), [Asked::Restart(1)], "a tap on the visible Restart");
+    // The face's top left, where the button was walked: a press there is a
+    // press on the face, which raises the window and restarts nothing.
+    let top_left = face.pos + dvec2(20.0, 50.0);
+    assert!(!restart.contains(top_left));
+    assert_eq!(click(&mut cx, &[&stopped], top_left), [Asked::Raise(1)], "a click at the face's top left restarted the app");
+    assert_eq!(tap(&mut cx, &[&stopped], top_left), [Asked::Raise(1)], "a tap at the face's top left restarted the app");
+    close(cx, host, vec![stopped], frame, &[1]);
+}
diff --git a/crates/shell/src/module_view.rs b/crates/shell/src/module_view.rs
index 759a4e47..fb2e36b6 100644
--- a/crates/shell/src/module_view.rs
+++ b/crates/shell/src/module_view.rs
@@ -88,6 +88,10 @@ pub struct MpModuleView {
     /// The WM's focus is on this tile: keys reach the root.
     #[rust]
     focused: bool,
+    /// One of the app's widgets took the last hover the root was handed
+    /// (`hover_claim`): it holds the hover until a move tells it otherwise.
+    #[rust]
+    hovered: bool,
     /// The root has drawn at least once.
     #[rust]
     drawn: bool,
@@ -105,9 +109,6 @@ pub struct MpModuleView {
     /// the line the tile shows once the shell has named the app.
     #[rust]
     stopped: Option<String>,
-    /// Where the Restart button was drawn.
-    #[rust]
-    restart_rect: Option<Rect>,
     /// Out of sight on the phone (`set_asleep`): the app gets no frames and
     /// its redraws are held, but timers, network replies and messages
     /// still reach it, so its state stays current (and audio keeps
@@ -153,7 +154,6 @@ impl MpModuleView {
         self.vm_id = vm_id;
         self.drawn = false;
         self.stopped = None;
-        self.restart_rect = None;
         self.draw_bg.redraw(cx);
     }
 
@@ -179,13 +179,17 @@ impl MpModuleView {
             }
         }
         self.focused = false;
+        self.hovered = false;
         if self.stopped.is_none() {
             self.stopped = Some("The app stopped after an error".to_string());
         }
         self.draw_bg.redraw(cx);
     }
 
-    /// The closed face: a line and a Restart button, centred.
+    /// The closed face: a line and a Restart button, centred. The face's
+    /// turtle centres them as it ends, which moves the button after it was
+    /// walked, so a press is tested against the drawn button (`on_restart`),
+    /// not the rect `walk_turtle` gave: that one is at the face's top left.
     fn draw_stopped(&mut self, cx: &mut Cx2d, rect: Rect) {
         let Some(line) = self.stopped.clone() else { return };
         let ground = self.draw_bg.color;
@@ -198,17 +202,31 @@ impl MpModuleView {
         cx.begin_turtle(Walk::abs_rect(button), Layout { align: Align { x: 0.5, y: 0.5 }, ..Layout::default() });
         self.draw_button_text.draw_walk(cx, Walk::fit(), Align::default(), "Restart");
         cx.end_turtle();
-        self.restart_rect = Some(button);
         cx.end_turtle();
     }
 
+    /// The press at `abs` is on the Restart button, where it is drawn: the
+    /// face hit-tests it by its own area, as any widget is hit-tested, so it
+    /// follows the face's centring and whatever clips the window.
+    fn on_restart(&self, cx: &Cx, abs: Vec2d) -> bool {
+        let button = self.draw_button.area();
+        button.is_valid(cx) && button.clipped_rect(cx).contains(abs)
+    }
+
     /// A press on the closed face: Restart, or just focus the tile. The face
     /// takes presses as the live tile does: only one inside it that nothing
     /// in front claimed, and it claims what it takes, so a click on a window
     /// over it never restarts the app and a click on it raises no window
-    /// behind it.
+    /// behind it. It claims a hover inside it the same way, so nothing behind
+    /// it lights up under the face.
     fn handle_stopped_event(&mut self, cx: &mut Cx, event: &Event) {
         let rect = self.area.is_valid(cx).then(|| self.area.rect(cx));
+        if let Some((claim, abs)) = hover_claim(cx, event) {
+            if claim.get().is_empty() && rect.is_some_and(|r| r.contains(abs)) {
+                claim.set(self.area);
+            }
+            return;
+        }
         if pointer_start(event, rect) != PointerStart::Inside {
             return;
         }
@@ -224,7 +242,7 @@ impl MpModuleView {
             return;
         }
         claim.set(self.area);
-        if self.restart_rect.is_some_and(|r| r.contains(abs)) {
+        if self.on_restart(cx, abs) {
             cx.widget_action(self.uid, MpRunViewAction::Restart { client });
         } else {
             cx.widget_action(self.uid, MpRunViewAction::Clicked { client });
@@ -237,6 +255,7 @@ impl MpModuleView {
     pub fn clear_root(&mut self, cx: &mut Cx) {
         self.root = None;
         self.focused = false;
+        self.hovered = false;
         self.draw_bg.redraw(cx);
     }
 
@@ -246,8 +265,9 @@ impl MpModuleView {
 
     /// Where the closed face drew its Restart (module_input_tests.rs).
     #[cfg(test)]
-    pub(crate) fn restart_button(&self) -> Option<Rect> {
-        self.restart_rect
+    pub(crate) fn restart_button(&self, cx: &Cx) -> Option<Rect> {
+        let button = self.draw_button.area();
+        button.is_valid(cx).then(|| button.rect(cx))
     }
 }
 
@@ -353,6 +373,18 @@ fn press_claim(event: &Event) -> Option<&std::cell::Cell<Area>> {
     }
 }
 
+/// A hover: a mouse move with no button held, with the cell that records
+/// who took it and where it is. Like a press, a hover that reaches a tile
+/// already claimed was taken in front of it. A move with a button held is
+/// no hover: it belongs to whatever captured the press, and passes wherever
+/// it goes.
+fn hover_claim<'a>(cx: &Cx, event: &'a Event) -> Option<(&'a std::cell::Cell<Area>, Vec2d)> {
+    match event {
+        Event::MouseMove(e) if cx.fingers.first_mouse_button.is_none() => Some((&e.handled, e.abs)),
+        _ => None,
+    }
+}
+
 impl Widget for MpModuleView {
     fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
         if self.stopped.is_some() {
@@ -430,6 +462,18 @@ impl Widget for MpModuleView {
         if press.is_some_and(|claim| !claim.get().is_empty()) {
             return;
         }
+        // A hover inside, with its claim (`hover_claim`). One a window in
+        // front took is not this instance's either: the root never sees it,
+        // so no widget under that window lights up or sets its cursor. The
+        // one exception: while a widget of this app still holds the hover
+        // from the last move (`hovered`), the root gets this move too, so
+        // that widget sees its hover end. Claimed, the move lets no other
+        // hover start.
+        let hover = hover_claim(cx, event).map(|(claim, abs)| (claim, rect.is_some_and(|r| r.contains(abs))));
+        if hover.is_some_and(|(claim, inside)| inside && !claim.get().is_empty() && !self.hovered) {
+            return;
+        }
+        let hover_unclaimed = hover.is_some_and(|(claim, _)| claim.get().is_empty());
         if press.is_some() {
             if let Some(client) = self.client {
                 // The WM moves focus here (and back to us through
@@ -469,6 +513,17 @@ impl Widget for MpModuleView {
                 handled.set(self.area);
             }
         }
+        // A hover inside this tile is the tile's in the same way. Before, no
+        // tile claimed a move, so a hover over the part of Mail that takes
+        // none reached News behind it unclaimed: its widgets lit up and set
+        // their cursors under Mail. A process tile's `event.hits` claims
+        // hovers too.
+        if let Some((claim, inside)) = hover {
+            self.hovered = hover_unclaimed && !claim.get().is_empty();
+            if inside && claim.get().is_empty() {
+                claim.set(self.area);
+            }
+        }
     }
 
     fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
@@ -594,4 +649,26 @@ mod tests {
         assert!(press_claim(&touch(dvec2(200.0, 400.0), TouchState::Move)).is_none(), "only a start is a press");
         assert!(press_claim(&Event::Startup).is_none());
     }
+
+    /// A mouse move with no button held is a hover with a claim. With a
+    /// button held it is a drag, which passes to whatever captured the press;
+    /// a finger's move is no hover either.
+    #[test]
+    fn only_a_mouse_move_with_no_button_held_is_a_hover_to_claim() {
+        let mut cx = Cx::new(Box::new(|_, _| {}));
+        let at = dvec2(200.0, 400.0);
+        let moved = Event::MouseMove(MouseMoveEvent {
+            abs: at,
+            lock_delta: Vec2d::default(),
+            window_id: WindowId(0, 0),
+            modifiers: Default::default(),
+            time: 0.0,
+            handled: Default::default(),
+        });
+        assert!(hover_claim(&cx, &moved).is_some_and(|(_, abs)| abs == at));
+        assert!(hover_claim(&cx, &touch(at, TouchState::Move)).is_none());
+        assert!(hover_claim(&cx, &Event::Startup).is_none());
+        cx.fingers.first_mouse_button = Some((MouseButton::PRIMARY, WindowId(0, 0)));
+        assert!(hover_claim(&cx, &moved).is_none(), "a drag is no hover");
+    }
 }
diff --git a/crates/shell/src/sandbox/tests.rs b/crates/shell/src/sandbox/tests.rs
index 1abc3103..d8269de5 100644
--- a/crates/shell/src/sandbox/tests.rs
+++ b/crates/shell/src/sandbox/tests.rs
@@ -66,6 +66,33 @@ fn run(program: &str, args: &[&str], policy: &Policy) -> (bool, String) {
     (out.status.success(), format!("{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr)))
 }
 
+/// What `nc -v -z` said became of its connect: `Ok` when it connected, the
+/// reason it printed when the connect failed, `None` when it said neither
+/// (it never ran its connect: `sandbox-exec` refused to start it, say).
+/// Apple's nc writes `nc: connectx to … failed: <reason>`, OpenBSD's
+/// `nc: connect to … failed: <reason>`.
+fn connect_outcome(out: &str) -> Option<Result<(), &str>> {
+    for line in out.lines() {
+        if line.starts_with("Connection to ") && line.ends_with("succeeded!") {
+            return Some(Ok(()));
+        }
+        if line.starts_with("nc: connect") {
+            if let Some((_, why)) = line.split_once(" failed: ") {
+                return Some(Err(why.trim()));
+            }
+        }
+    }
+    None
+}
+
+/// A connect the sandbox itself refused: EPERM from Seatbelt and seccomp,
+/// EACCES from Landlock. Every other error is decided past the sandbox's
+/// check (an absent listener, the network stack), so it means the sandbox
+/// let the connect out.
+fn refused_by_sandbox(why: &str) -> bool {
+    why == "Operation not permitted" || why == "Permission denied"
+}
+
 fn sandbox_works_here() -> bool {
     if cfg!(target_os = "macos") {
         return Path::new(macos::SANDBOX_EXEC).is_file();
@@ -110,12 +137,23 @@ fn a_jail_only_app_reads_its_jail_and_is_refused_everything_else() {
     let (ok, out) = run("/bin/sh", &["-c", &format!("echo x > {}/written", root.display())], &Policy { processes: true, ..policy.clone() });
     assert!(!ok, "it writes nothing outside: {out}");
 
-    // Network: the hub on loopback, nothing else.
-    let nc = |port: u16| run("/usr/bin/nc", &["-z", "-w", "2", "127.0.0.1", &port.to_string()], &policy);
-    let (ok, out) = nc(hub_port);
-    assert!(ok, "the hub is reachable: {out}");
+    // Network: the hub on loopback, nothing else. What is asked is the
+    // sandbox's verdict on each connect, so nc says what became of it
+    // (`-v`) instead of only exiting 1, and only the sandbox's own refusal
+    // counts as one: a connect the sandbox lets out may still be refused by
+    // the network stack, which is not this test's business.
+    let nc = |port: u16| run("/usr/bin/nc", &["-v", "-n", "-z", "-w", "2", "127.0.0.1", &port.to_string()], &policy);
+    let (_, out) = nc(hub_port);
+    match connect_outcome(&out) {
+        Some(Ok(())) => {}
+        Some(Err(why)) => {
+            assert!(!refused_by_sandbox(why), "the sandbox lets the hub through: {out}");
+            eprintln!("the hub's connect left the sandbox and failed past it: {why}");
+        }
+        None => panic!("nc said nothing about the hub's connect: {out}"),
+    }
     let (ok, out) = nc(other_port);
-    assert!(!ok, "any other connection is refused: {out}");
+    assert!(!ok && matches!(connect_outcome(&out), Some(Err(why)) if refused_by_sandbox(why)), "any other connection is refused by the sandbox: {out}");
 
     // Processes: none.
     let (ok, out) = run("/bin/sh", &["-c", "/bin/echo first; /bin/echo spawned"], &policy);
diff --git a/crates/toolbox/README.md b/crates/toolbox/README.md
index 15d565c6..f9ec9826 100644
--- a/crates/toolbox/README.md
+++ b/crates/toolbox/README.md
@@ -167,7 +167,7 @@ Backends:
     - no cookies, credentials or proxies, and 401/402/403 are failures, so there is no paywall or login bypass;
     - **SSRF blocking** on every fetch and every redirect hop. Loopback, private, link-local (including cloud-metadata 169.254.169.254 and `fd00:ec2::254`), unique-local, shared (CGNAT), multicast, reserved and IPv4-mapped forms are refused, both as URL literals and in DNS answers. A resolver filters the addresses the connection actually uses, so DNS rebinding cannot get past the check. `localhost` names are refused.
   - **Licenses**: `dom_smoothie`, `dom_query`, `gjson`, `html-escape` (MIT), `flagset` (Apache-2.0), `quick-xml` (MIT), and Mozilla's `cssparser` and `selectors` (MPL-2.0, unmodified; the workspace already links them through `scraper`). All of these are behind the `live` feature.
-- **The octos research engine** (`research::octos::OctosResearch`, feature `octos-engine`). It depends on `octos-research` through the workspace's one octos pin, and needs octos#2568 (reader), #2582 (metasearch), #2585 (`octos_research::toolbox`), #2590 (read-failure reasons, posts marked as posts) and #2594 (stub and consent pages, whole-topic feed matching, a soft deadline for slow engines), all in the pin (octos ae230ce0, which contains 3b5d17a4). It only finds and reads; everything under "The policy" above stays in the host unchanged.
+- **The octos research engine** (`research::octos::OctosResearch`, feature `octos-engine`). It depends on `octos-research` through the workspace's one octos pin, and needs octos#2568 (reader), #2582 (metasearch), #2585 (`octos_research::toolbox`), #2590 (read-failure reasons, posts marked as posts) and #2594 (stub and consent pages, whole-topic feed matching, a soft deadline for slow engines), all in the pin (octos 056173e8, which contains 3b5d17a4). It only finds and reads; everything under "The policy" above stays in the host unchanged.
   - **One definition of an app's reach.** The app's grant **is** `octos_research::toolbox::Scope`; nothing is mapped. Each search is narrowed by octos's `Scope::search_args`, in the host (above) and again here, so a language, region, category or domain outside the grant is refused there and the recency is clamped. The search asks the engines for a candidate pool of three times the app's `limit` (at most 30, `candidate_pool`) so the host's filters still leave `limit`; `max_results` bounds what the app gets, not the pool. Each read is checked with `Scope::check_domain` twice: the link, then the page the browser ended on, the publisher for a Google News link.
   - **Search** is the octos metasearch (`octos_research::metasearch`), category `news`: Google News in the language's own edition, GDELT, publisher feeds, Hacker News and Mastodon, plus keyed engines when their keys are set.
     - Octos fans the query out under a 15 s deadline, then merges, deduplicates and ranks the results. It spaces requests per host, honours `Retry-After`, caches with ETags, and suspends a failing engine with doubling backoff. That backoff is how GDELT's 429s are handled.
@@ -246,7 +246,7 @@ The wiring is in place behind `toolbox-peers` (`crates/ai-host/src/toolbox_peers
 
 ## Commands
 
-The pinned octos (`ae230ce0`) includes `octos-research`, so no override is needed any more. On 1 Oct 2026 `cargo test --locked -p octosense-toolbox` passed at the pin (83 tests). The others below were run on 28 Sep 2026 against octos's merge of #2585 (7bec0918) through a local override, before the pin moved; at the pin `apps.yml` runs the plain, `live` and `octos-engine` tests and both clippy lines, and the live and real-model runs are **unverified** at the pin.
+The pinned octos (`056173e8`) includes `octos-research`, so no override is needed any more. On 2 Oct 2026 `cargo test --locked -p octosense-toolbox` passed at the pin (83 tests). The others below were run on 28 Sep 2026 against octos's merge of #2585 (7bec0918) through a local override, before the pin moved; at the pin `apps.yml` runs the plain, `live` and `octos-engine` tests and both clippy lines, and the live and real-model runs are **unverified** at the pin.
 
 ```sh
 cargo test --locked -p octosense-toolbox                     # 83 tests, fixtures only (the thin scope parser)
diff --git a/docs/adr/0004-native-apps-hosting-and-peers.md b/docs/adr/0004-native-apps-hosting-and-peers.md
index d882b348..0af01898 100644
--- a/docs/adr/0004-native-apps-hosting-and-peers.md
+++ b/docs/adr/0004-native-apps-hosting-and-peers.md
@@ -3,7 +3,7 @@
 - **Date:** 2026-09-28
 - **Status:** Accepted (2026-09-28); amended 2026-09-29 (section 6: `host.ask` dropped for octos's `ask_user_question`; sections 10 and 12: `terminal.run` only where the Terminal runs as a process; factual corrections from the gap review, marked where made; sections 4 and 8: interactive app cards; section 6: one shared conversation per app agent, then the same day two parallel lanes that share history; follow-ups from the 2026-09-29 code review; section 4: which apps have an agent, peers prepared at consent, the shell's "Ask <app>" panel); **Implemented** (2026-09-29): every plan step and every gap from the 2026-09-28 review is on `main`, and the full CI (Desktop, Phone, Apps and services, ROM) passed on `74e1d713`. The follow-ups below remain open work, not part of this decision's implementation.
 - **Scope:** How OctoSense declares, links, hosts, isolates and trusts its bundled native Rust apps on each target; where every app keeps its data and what its agent may read; how every bundled app, native or script, owns an octos app agent; how the system agent and app agents work across apps; and how the person approves what they do, live or in advance.
-- **Relates to:** [ADR 0001](0001-one-octosense-repository.md); [ADR 0002](0002-event-driven-app-agents.md) (app agents; amended by this ADR); [Home ADR 0002](home/0002-agentic-app-security-model.md) and [Home ADR 0004](home/0004-system-apps-are-contained-script-apps.md) (amended); Rinx [ADR 0007](https://github.com/hagency-org/Rinx/blob/main/docs/adr/0007-host-owned-octos-app-peers.md); octos UPCR-2026-034 (host-owned app peers, merged), UPCR-2026-035 ([octos#2567](https://github.com/octos-org/octos/pull/2567), host tools per app peer, merged; OctoSense pins its follow-ups, now octos ae230ce0 (4a3ec9f9 plus the security fixes #2653, #2655 and #2656) with octos#2621, #2626, #2636, #2644, #2652, #2654, #2657, #2658 and the UPCR additions #2647 (`read_parent`), #2649 (`peer/purge`) and #2648 (`session/tool_list/set`)) and UPCR-2026-036 (`serve --host-managed`, [octos#2591](https://github.com/octos-org/octos/pull/2591), merged); [octos#2601](https://github.com/octos-org/octos/pull/2601) (tool origin, per-connection ownership); [ADR 0003](0003-shared-octos-client-access.md) (Talk to Octos, OctoSense [#98](https://github.com/OctoSense-org/OctoSense/pull/98): external clients never reach app agents).
+- **Relates to:** [ADR 0001](0001-one-octosense-repository.md); [ADR 0002](0002-event-driven-app-agents.md) (app agents; amended by this ADR); [Home ADR 0002](home/0002-agentic-app-security-model.md) and [Home ADR 0004](home/0004-system-apps-are-contained-script-apps.md) (amended); Rinx [ADR 0007](https://github.com/hagency-org/Rinx/blob/main/docs/adr/0007-host-owned-octos-app-peers.md); octos UPCR-2026-034 (host-owned app peers, merged), UPCR-2026-035 ([octos#2567](https://github.com/octos-org/octos/pull/2567), host tools per app peer, merged; OctoSense pins its follow-ups, now octos 056173e8 (4a3ec9f9 plus the security fixes #2653, #2655 and #2656, and #2675, hydrate rows that name their tool calls) with octos#2621, #2626, #2636, #2644, #2652, #2654, #2657, #2658 and the UPCR additions #2647 (`read_parent`), #2649 (`peer/purge`) and #2648 (`session/tool_list/set`)) and UPCR-2026-036 (`serve --host-managed`, [octos#2591](https://github.com/octos-org/octos/pull/2591), merged); [octos#2601](https://github.com/octos-org/octos/pull/2601) (tool origin, per-connection ownership); [ADR 0003](0003-shared-octos-client-access.md) (Talk to Octos, OctoSense [#98](https://github.com/OctoSense-org/OctoSense/pull/98): external clients never reach app agents).
 
 ## Context
 
@@ -43,7 +43,7 @@
 
 ### What octos provides (octos `main` e6223ef, verified)
 
-Verified at e6223ef when this ADR was written. OctoSense now pins octos ae230ce0 (the merge of octos#2656, low fixes for host-owned app peers; after #2655, the unknown-outcome interlock kept across a kernel restart, and #2653, a bound workspace that no longer resolves to its recorded path is refused rather than re-rooted; before that 4a3ec9f9, the merge of octos#2648, a host session's durable exact tool list, `session/tool_list/set`; after #2649, `peer/purge`, #2647, `peer/context/open` `read_parent`, #2658, `peer/tools/unregister`, #2657, a host session's tools registered by the host's own connection without an app peer's token, #2654, host tool claims bounded per peer, #2652, a refused host `turn/start` no longer consumes its `peer/input`, #2651, the model cannot `peer_close` a host-owned app peer, and #2650; before that fe08d8e6, the merge of octos#2645, which holds #2644, a running turn shown in the other lane's shared history, and #2636, the parallel person context with shared history; after #2626, the shared peer conversation, #2630, `peer_gather` accepting the kernel's own `result.md`, #2621, `peer/input/reject`, and #2616, the #2567 follow-ups); the corrections dated 2026-09-29 below were checked against c608384d, the pin before it.
+Verified at e6223ef when this ADR was written. OctoSense now pins octos 056173e8 (the merge of octos#2675, `session/hydrate` rows that carry a tool row's `tool_call_id` and `tool_name` and an assistant row's `tool_calls`, so a reloaded transcript names its tool rows; after #2672, #2671, #2669, #2665, #2664 and #2261; before that ae230ce0, the merge of octos#2656, low fixes for host-owned app peers; after #2655, the unknown-outcome interlock kept across a kernel restart, and #2653, a bound workspace that no longer resolves to its recorded path is refused rather than re-rooted; before that 4a3ec9f9, the merge of octos#2648, a host session's durable exact tool list, `session/tool_list/set`; after #2649, `peer/purge`, #2647, `peer/context/open` `read_parent`, #2658, `peer/tools/unregister`, #2657, a host session's tools registered by the host's own connection without an app peer's token, #2654, host tool claims bounded per peer, #2652, a refused host `turn/start` no longer consumes its `peer/input`, #2651, the model cannot `peer_close` a host-owned app peer, and #2650; before that fe08d8e6, the merge of octos#2645, which holds #2644, a running turn shown in the other lane's shared history, and #2636, the parallel person context with shared history; after #2626, the shared peer conversation, #2630, `peer_gather` accepting the kernel's own `result.md`, #2621, `peer/input/reject`, and #2616, the #2567 follow-ups); the corrections dated 2026-09-29 below were checked against c608384d, the pin before it.
 
 - **Peers are sessions, not processes.** One kernel process per shell; every peer is a session in it (tokio tasks) with its own workspace, memory namespace, transcript and model lane. Tools such as the shell run as short child processes in the peer's workspace.
 - **No 8-peer ceiling.** `peer/prepare` stages 1–8 peers **per call** (`n`); the only total is a soft cap of 8192 live peer registrations. The model's `peer_handoff` tool is limited to 4 per turn; host-owned app peers are not created through it. OctoSense's broker prepares one peer per call.
diff --git a/tools/test_kernel_artifact.py b/tools/test_kernel_artifact.py
index 2dd7716b..84da0492 100644
--- a/tools/test_kernel_artifact.py
+++ b/tools/test_kernel_artifact.py
@@ -14,7 +14,7 @@
 kernel = importlib.util.module_from_spec(spec)
 spec.loader.exec_module(kernel)
 
-REV = "ae230ce04d57f3c29cf6c2518e5956a86c07d788"
+REV = "056173e85b150e387805fc307fe231064ac1ed35"
 
 
 def lock_with(*revs):