fix(relay-node): repair native Codex registration and hook delivery

CHANGELOG.md

@@ -13,7 +13,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Session hooks keep receiving messages when the session-socket pointer directory is a user-owned symlink to private runtime storage; inaccessible or shared symlink targets remain refused.
 - `agent-relay-probe connect create` starts a new room when Cloud has already closed the saved one, even before its saved expiry, instead of refusing with "already has a pending or active room". `connect end` clears a room that has expired, ended or no longer exists instead of failing; `end` and `extend` let Cloud, not the local clock, decide whether a room is over.
+- Loaded Codex user chats automatically join and stay registered without a desktop window owner; registration presence no longer implies an idle message-delivery route.
 
 ## [18.1.0] - 2026-11-11
 

crates/relay-node/contract/CoreContract.swift

@@ -2312,6 +2312,9 @@ public struct LocalAgent: Codable, Equatable, Hashable, Sendable {
 
 /// A session on this computer, with its registration when it has one.
 public struct LocalSession: Codable, Equatable, Hashable, Sendable {
+    /// Registration/transport presence is not proof that the model can
+    /// receive a message. Absent on older cores and when no wait is known.
+    public let deliveryWait: String?
     public let directory: String?
     /// What holds this session's transcript, for a session that can be
     /// held at all (see [`SessionHolder`]).
@@ -2338,7 +2341,8 @@ public struct LocalSession: Codable, Equatable, Hashable, Sendable {
     public let title: String
     public let updatedAtMs: Int64?
 
-    public init(directory: String? = nil, holder: SessionHolder? = nil, host: String? = nil, live: Bool, project: String? = nil, registration: SessionRegistration? = nil, running: Bool? = nil, suggestedName: String, target: Target, title: String, updatedAtMs: Int64? = nil) {
+    public init(deliveryWait: String? = nil, directory: String? = nil, holder: SessionHolder? = nil, host: String? = nil, live: Bool, project: String? = nil, registration: SessionRegistration? = nil, running: Bool? = nil, suggestedName: String, target: Target, title: String, updatedAtMs: Int64? = nil) {
+        self.deliveryWait = deliveryWait
         self.directory = directory
         self.holder = holder
         self.host = host
@@ -2353,6 +2357,7 @@ public struct LocalSession: Codable, Equatable, Hashable, Sendable {
     }
 
     enum CodingKeys: String, CodingKey {
+        case deliveryWait = "delivery_wait"
         case directory
         case holder
         case host
@@ -2368,6 +2373,7 @@ public struct LocalSession: Codable, Equatable, Hashable, Sendable {
 
     public init(from decoder: Decoder) throws {
         let c = try decoder.container(keyedBy: CodingKeys.self)
+        self.deliveryWait = try c.decodeIfPresent(String.self, forKey: .deliveryWait)
         self.directory = try c.decodeIfPresent(String.self, forKey: .directory)
         self.holder = try c.decodeIfPresent(SessionHolder.self, forKey: .holder)
         self.host = try c.decodeIfPresent(String.self, forKey: .host)
@@ -2383,6 +2389,7 @@ public struct LocalSession: Codable, Equatable, Hashable, Sendable {
 
     public func encode(to encoder: Encoder) throws {
         var c = encoder.container(keyedBy: CodingKeys.self)
+        try c.encodeIfPresent(self.deliveryWait, forKey: .deliveryWait)
         try c.encode(self.directory, forKey: .directory)
         try c.encodeIfPresent(self.holder, forKey: .holder)
         try c.encodeIfPresent(self.host, forKey: .host)

crates/relay-node/src/relay/agents.rs

@@ -19,7 +19,7 @@ use crate::relay::managed_sessions::ManagedAuthority;
 use crate::relay::people::identity_hash;
 use crate::relay::protocol::{ErrorKind, RpcError};
 use crate::relay::push::{PushState, PushTarget};
-use crate::relay::sessions::DiscoveredSession;
+use crate::relay::sessions::{AutomaticCandidate, DiscoveredSession};
 use crate::relay::state::{Level, Listing};
 use crate::relay::store::{
     iso8601_now, random_hex, AgentAlias, CleanupKind, PendingCleanup, Registration, SessionKind,
@@ -250,6 +250,34 @@ fn is_name_taken(error: &relaycast::RelayError) -> bool {
 }
 
 impl Core {
+    /// A trusted host can request a global pass, but cannot name the chat
+    /// to register. Coalesce signals and leave network work off hook calls.
+    pub(crate) fn request_codex_discovery(self: &Arc<Self>) {
+        use std::sync::atomic::Ordering;
+        if self.codex_discovery_refresh.swap(true, Ordering::AcqRel) {
+            return;
+        }
+        let core = self.clone();
+        struct Reset(Arc<Core>);
+        impl Drop for Reset {
+            fn drop(&mut self) {
+                self.0
+                    .codex_discovery_refresh
+                    .store(false, Ordering::Release);
+            }
+        }
+        let reset = Reset(core.clone());
+        tokio::spawn(async move {
+            let _reset = reset;
+            for attempt in 0..3 {
+                if attempt > 0 {
+                    tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+                }
+                core.activate_new_sessions().await;
+            }
+        });
+    }
+
     /// The agents or the sign-in changed: the spawn node is claimed for them,
     /// the people in the workspace are trusted like the person, and the
     /// account hears of it.
@@ -429,6 +457,26 @@ impl Core {
         description: Option<&str>,
         added_by_session: bool,
         auto_activated: bool,
+    ) -> Result<Registered, RpcError> {
+        self.register_session_authorized(
+            session,
+            raw_name,
+            description,
+            added_by_session,
+            auto_activated,
+            None,
+        )
+        .await
+    }
+
+    async fn register_session_authorized(
+        &self,
+        session: &DiscoveredSession,
+        raw_name: Option<&str>,
+        description: Option<&str>,
+        added_by_session: bool,
+        auto_activated: bool,
+        candidate: Option<&AutomaticCandidate>,
     ) -> Result<Registered, RpcError> {
         let target = &session.target;
         let lock = self.target_locks.get(&target.key());
@@ -472,7 +520,16 @@ impl Core {
         if is_managed(target.kind) {
             self.verify_managed_registration_authority(target).await?;
         }
-        if !session.live {
+        let runtime_admission = if let Some(candidate) = candidate {
+            let directory = self.plugins.sessions.clone();
+            let candidate = candidate.clone();
+            tokio::task::spawn_blocking(move || directory.automatic_candidate_current(&candidate))
+                .await
+                .unwrap_or(false)
+        } else {
+            false
+        };
+        if !session.live && !runtime_admission {
             return Err(RpcError::new(
                 ErrorKind::Refused,
                 "This session is not running.",
@@ -514,6 +571,27 @@ impl Core {
                 "No Agent Relay workspace key on this computer.",
             )
         })?;
+        let still_admitted = if let Some(candidate) = candidate {
+            let directory = self.plugins.sessions.clone();
+            let candidate = candidate.clone();
+            tokio::task::spawn_blocking(move || directory.automatic_candidate_current(&candidate))
+                .await
+                .unwrap_or(false)
+        } else {
+            runtime_admission
+        };
+        if candidate.is_some()
+            && (!still_admitted
+                || !auto_activation::activation_applies(
+                    &self.store.read(auto_activation::ActivationSettings::of),
+                    target.kind,
+                ))
+        {
+            return Err(RpcError::new(
+                ErrorKind::Refused,
+                "Automatic admission is disabled or its runtime proof expired.",
+            ));
+        }
         let mut candidate = name;
         let mut attempt = 1;
         let registration = loop {
@@ -1432,25 +1510,31 @@ impl Core {
         let discovered = tokio::task::spawn_blocking(move || {
             sessions.pi_auto_join(pi_auto_join);
             let all = sessions.sessions();
-            let live: HashSet<Target> = all
-                .iter()
-                .filter(|session| session.live)
-                .map(|session| session.target.clone())
-                .collect();
+            let live = sessions.present_targets(&all);
             let targets: Vec<Target> = registered.iter().map(|(_, t)| t.clone()).collect();
             let archived = sessions.archived(&targets);
             let archived: Vec<String> = registered
                 .into_iter()
                 .filter(|(_, target)| archived.contains(target))
                 .map(|(name, _)| name)
                 .collect();
-            let found = sessions.auto_activation_sessions();
+            let found = sessions.automatic_candidates();
             (found, all, live, archived, sessions.cleared(&targets))
         })
         .await;
         if let Ok((_, _, live, _, _)) = &discovered {
+            *self
+                .runtime_presence
+                .lock()
+                .unwrap_or_else(|e| e.into_inner()) =
+                Some((std::time::Instant::now(), live.clone()));
             // Relay Connect credentials follow the same running sessions.
             self.connect.lock().unwrap().observe_live_targets(live);
+        } else {
+            *self
+                .runtime_presence
+                .lock()
+                .unwrap_or_else(|e| e.into_inner()) = None;
         }
         let (found, all, mut live, archived, cleared) = discovered.unwrap_or_default();
         self.mark_sessions_archived(&archived);
@@ -1460,10 +1544,10 @@ impl Core {
         let spawned_live = self.spawned_live();
         live.retain(|target| !spawned.contains(target));
         live.extend(spawned_live);
-        let mut found: HashMap<Target, DiscoveredSession> = found
+        let mut found: HashMap<Target, AutomaticCandidate> = found
             .into_iter()
-            .filter(|session| !spawned.contains(&session.target))
-            .map(|session| (session.target.clone(), session))
+            .filter(|candidate| !spawned.contains(&candidate.session.target))
+            .map(|candidate| (candidate.session.target.clone(), candidate))
             .collect();
         let moved = self.follow_cleared(&cleared);
         let now = chrono::Utc::now();

crates/relay-node/src/relay/agents/activation_journal.rs

@@ -56,7 +56,7 @@ impl Core {
     /// admission when the fleet was never reached.
     pub(super) async fn auto_activate_session(
         &self,
-        session: &DiscoveredSession,
+        candidate: &AutomaticCandidate,
         now_text: &str,
     ) -> ActivationAttempt {
         if self.workspace().is_some_and(|workspace| {
@@ -79,7 +79,14 @@ impl Core {
             ));
         }
         match self
-            .register_session_with_origin(session, None, None, false, true)
+            .register_session_authorized(
+                &candidate.session,
+                None,
+                None,
+                false,
+                true,
+                Some(candidate),
+            )
             .await
         {
             Ok(_) => ActivationAttempt::Attempted(Ok(())),
@@ -111,15 +118,16 @@ impl Core {
     /// journal itself could not be written.
     pub(super) async fn activate_sessions(
         &self,
-        sessions: impl IntoIterator<Item = DiscoveredSession>,
+        sessions: impl IntoIterator<Item = AutomaticCandidate>,
         mut remaining: usize,
         wait_reason: &str,
         now_text: &str,
         failures: &mut Vec<String>,
     ) -> (Vec<String>, BTreeMap<String, String>) {
         let mut cleared = Vec::new();
         let mut blocked = BTreeMap::new();
-        for session in sessions {
+        for candidate in sessions {
+            let session = &candidate.session;
             let key = session.target.key();
             if self
                 .store
@@ -131,7 +139,7 @@ impl Core {
                 blocked.insert(key, wait_reason.to_string());
                 continue;
             }
-            match self.auto_activate_session(&session, now_text).await {
+            match self.auto_activate_session(&candidate, now_text).await {
                 ActivationAttempt::Paused(message) => {
                     blocked.insert(key.clone(), message.clone());
                     failures.push(format!("{key}: {message}"));

crates/relay-node/src/relay/cli.rs

@@ -264,7 +264,7 @@ const SESSION_START_TIMEOUT: Duration = Duration::from_secs(8);
 pub fn codex_stop_hook(socket: Option<&Path>, build: &Build) -> Result<()> {
     let mut input = Vec::new();
     let _ = std::io::stdin().take(4 << 20).read_to_end(&mut input);
-    let answer = (|| -> Result<Value> {
+    let (answer, receipt) = (|| -> Result<(Value, Option<(std::path::PathBuf, Vec<u8>)>)> {
         let hook: Value = serde_json::from_slice(&input)?;
         let body = serde_json::to_vec(&json!({
             "session_id": hook["session_id"],
@@ -286,14 +286,48 @@ pub fn codex_stop_hook(socket: Option<&Path>, build: &Build) -> Result<()> {
             socket_response(&socket, "POST", "/codex/stop-hook", &body, timeout)?;
         anyhow::ensure!((200..300).contains(&status), "refused");
         let response: Value = serde_json::from_slice(&response)?;
-        Ok(response["data"].clone())
+        let mut answer = response["data"].clone();
+        let receipt = answer
+            .as_object_mut()
+            .and_then(|object| object.remove("relayIdentityReceipt"))
+            .and_then(|value| value.as_str().map(str::to_string))
+            .map(|receipt| {
+                let body = serde_json::to_vec(&json!({"session_id":hook["session_id"],
+                    "hook_event_name":"RelayIdentityReceipt", "receipt":receipt}))?;
+                Ok::<_, anyhow::Error>((socket, body))
+            })
+            .transpose()?;
+        Ok((answer, receipt))
     })()
     .ok()
-    .filter(Value::is_object)
-    .unwrap_or_else(|| json!({}));
+    .filter(|(answer, _)| answer.is_object())
+    .unwrap_or_else(|| (json!({}), None));
     let mut stdout = std::io::stdout();
-    stdout.write_all(&serde_json::to_vec(&answer)?)?;
+    write_codex_hook_answer(&mut stdout, &answer, || {
+        if let Some((socket, body)) = receipt {
+            // Output is already flushed; acknowledgement cannot replace it
+            // with {} or extend the normal hook budget substantially.
+            let _ = socket_response(
+                &socket,
+                "POST",
+                "/codex/stop-hook",
+                &body,
+                Duration::from_millis(250),
+            );
+        }
+    })
+}
+
+/// Flush context to the host before acknowledging the startup response.
+fn write_codex_hook_answer(
+    stdout: &mut impl Write,
+    answer: &Value,
+    acknowledge: impl FnOnce(),
+) -> Result<()> {
+    stdout.write_all(&serde_json::to_vec(answer)?)?;
     stdout.write_all(b"\n")?;
+    stdout.flush()?;
+    acknowledge();
     Ok(())
 }
 
@@ -656,6 +690,46 @@ fn socket_response_with(
 mod tests {
     use super::*;
 
+    /// Failed writes/flushes must leave startup fallback available.
+    #[test]
+    fn codex_startup_ack_follows_successful_output_flush() {
+        struct Output {
+            bytes: Vec<u8>,
+            fail_write: bool,
+            fail_flush: bool,
+        }
+        impl Write for Output {
+            fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
+                if self.fail_write {
+                    return Err(std::io::ErrorKind::BrokenPipe.into());
+                }
+                self.bytes.extend_from_slice(bytes);
+                Ok(bytes.len())
+            }
+            fn flush(&mut self) -> std::io::Result<()> {
+                if self.fail_flush {
+                    Err(std::io::ErrorKind::BrokenPipe.into())
+                } else {
+                    Ok(())
+                }
+            }
+        }
+        for (fail_write, fail_flush) in [(false, false), (true, false), (false, true)] {
+            let mut output = Output {
+                bytes: Vec::new(),
+                fail_write,
+                fail_flush,
+            };
+            let mut acknowledged = false;
+            let result =
+                write_codex_hook_answer(&mut output, &json!({"hookSpecificOutput":{}}), || {
+                    acknowledged = true
+                });
+            assert_eq!(result.is_ok(), !fail_write && !fail_flush);
+            assert_eq!(acknowledged, result.is_ok());
+        }
+    }
+
     use crate::relay::transport::{CoreListener, CoreStream};
     use std::future::Future;
     use tokio::io::{AsyncBufReadExt, AsyncWriteExt};