@webinson/peer 0.4.16 → 0.4.17

package/mod/codex/client/0001-memory.patch

@@ -0,0 +1,327 @@
+diff --git a/codex-rs/config/src/lib.rs b/codex-rs/config/src/lib.rs
+index 9b6cd84..6e22c31 100644
+--- a/codex-rs/config/src/lib.rs
++++ b/codex-rs/config/src/lib.rs
+@@ -34,6 +34,7 @@ mod model_provider_defaults;
+ mod model_provider_requirements;
+ mod overrides;
+ mod path_context;
++pub mod peer_thread_mark;
+ pub mod permissions_toml;
+ mod plugin_edit;
+ pub mod profile_toml;
+diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rs
+index a6640ad..7b0dd75 100644
+--- a/codex-rs/core/src/config/mod.rs
++++ b/codex-rs/core/src/config/mod.rs
+@@ -192,6 +192,7 @@ pub use codex_config::Constrained;
+ pub use codex_config::ConstraintError;
+ pub use codex_config::ConstraintResult;
+ pub use codex_config::LoaderOverrides;
++pub use codex_config::peer_thread_mark;
+ pub use codex_network_proxy::NetworkProxyAuditMetadata;
+ use codex_sandboxing::compatibility_sandbox_policy_for_permission_profile;
+ pub use codex_sandboxing::system_bwrap_warning;
+diff --git a/codex-rs/core/src/session/mcp_runtime.rs b/codex-rs/core/src/session/mcp_runtime.rs
+index ac0bc4a..a1a0b76 100644
+--- a/codex-rs/core/src/session/mcp_runtime.rs
++++ b/codex-rs/core/src/session/mcp_runtime.rs
+@@ -116,7 +116,8 @@ impl Session {
+             session_source: session_configuration.session_source.clone(),
+             environments: resolved_environments.clone(),
+             local_process_cwd,
+-            disabled_plugin_ids: session_configuration.disabled_plugin_ids.clone(),
++            disabled_plugin_ids: self
++                .peer_disabled_plugins(&session_configuration.disabled_plugin_ids),
+         };
+         self.publish_mcp_runtime(
+             &desired,
+diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs
+index bc2f4c2..d609646 100644
+--- a/codex-rs/core/src/session/mod.rs
++++ b/codex-rs/core/src/session/mod.rs
+@@ -4169,7 +4169,7 @@ impl Session {
+                     .with_session_source(&turn_context.session_source)
+                     .with_selected_environments(&environments.all_selections()),
+                     &mcp.config().plugins,
+-                    &turn_context.disabled_plugin_ids,
++                    &self.peer_disabled_plugins(&turn_context.disabled_plugin_ids),
+                 )
+                 .await;
+             for contributor in self.services.extensions.tool_contributors() {
+@@ -4722,7 +4722,7 @@ impl Session {
+             .plugins_manager
+             .plugins_for_config(&turn_context.config.plugins_config_input())
+             .await
+-            .without_plugins(&turn_context.disabled_plugin_ids);
++            .without_plugins(&self.peer_disabled_plugins(&turn_context.disabled_plugin_ids));
+         let recommended_plugin_candidates = if turn_context
+             .config
+             .features
+diff --git a/codex-rs/core/src/session/plugin_selection.rs b/codex-rs/core/src/session/plugin_selection.rs
+index 0a9580d..59c2e54 100644
+--- a/codex-rs/core/src/session/plugin_selection.rs
++++ b/codex-rs/core/src/session/plugin_selection.rs
+@@ -6,11 +6,16 @@ use super::Session;
+ use super::turn_context::TurnContext;
+ 
+ impl Session {
++    pub(super) fn peer_disabled_plugins(&self, configured: &[String]) -> Vec<String> {
++        codex_config::peer_thread_mark::disabled_plugins(&self.thread_id.to_string(), configured)
++    }
++
+     pub(crate) async fn activate_plugin_selection(&self, turn_context: &TurnContext) {
++        let disabled = self.peer_disabled_plugins(&turn_context.disabled_plugin_ids);
+         let config = {
+             let mut state = self.state.lock().await;
+-            if state.active_disabled_plugin_ids != turn_context.disabled_plugin_ids {
+-                state.active_disabled_plugin_ids = turn_context.disabled_plugin_ids.clone();
++            if state.active_disabled_plugin_ids != disabled {
++                state.active_disabled_plugin_ids.clone_from(&disabled);
+                 self.mark_mcp_runtime_dirty();
+             }
+             Arc::clone(&state.session_configuration.original_config_do_not_use)
+@@ -20,7 +25,7 @@ impl Session {
+             .plugins_manager
+             .plugins_for_config(&config.plugins_config_input())
+             .await
+-            .without_plugins(&turn_context.disabled_plugin_ids);
++            .without_plugins(&disabled);
+         // Cache changes from another process do not notify this session's hook runtime.
+         if !self.hooks().matches_plugin_hooks(
+             plugin_outcome.iter_effective_plugin_hook_sources(),
+diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rs
+index 8e2d7b3..e513f3e 100644
+--- a/codex-rs/core/src/session/session.rs
++++ b/codex-rs/core/src/session/session.rs
+@@ -1214,7 +1214,11 @@ impl Session {
+         let thread_extension_data_for_mcp = &thread_extension_data;
+         let mcp_originator = session_configuration.originator.clone();
+         let mcp_session_source = session_configuration.session_source.clone();
+-        let mcp_disabled_plugin_ids = session_configuration.disabled_plugin_ids.clone();
++        let peer_disabled_plugin_ids = codex_config::peer_thread_mark::disabled_plugins(
++            &thread_id.to_string(),
++            &session_configuration.disabled_plugin_ids,
++        );
++        let mcp_disabled_plugin_ids = peer_disabled_plugin_ids.clone();
+         let auth_and_mcp_fut = async move {
+             let auth = mcp_auth.await;
+             if config_for_mcp.features.plugin_recommendations_enabled() {
+@@ -1576,7 +1580,9 @@ impl Session {
+             if let Some(pin) = thread_extension_data.remove::<ReasoningEffortPin>() {
+                 state.reasoning_effort_pin = pin.as_ref().clone();
+             }
+-            state.active_disabled_plugin_ids = session_configuration.disabled_plugin_ids.clone();
++            state
++                .active_disabled_plugin_ids
++                .clone_from(&peer_disabled_plugin_ids);
+             let managed_network_requirements_configured = config
+                 .config_layer_stack
+                 .requirements_toml()
+@@ -1657,7 +1663,7 @@ impl Session {
+                 &config,
+                 plugins_manager.as_ref(),
+                 resolved_environments.single_local_environment(),
+-                &session_configuration.disabled_plugin_ids,
++                &peer_disabled_plugin_ids,
+             )
+             .await;
+             let (hooks, async_hook_results) = Hooks::new(
+@@ -1986,7 +1992,7 @@ impl Session {
+                                 .current_auth_matches(latest_auth.as_ref()),
+                             session_source: &session_configuration.session_source,
+                             originator: &session_configuration.originator,
+-                            disabled_plugin_ids: &session_configuration.disabled_plugin_ids,
++                            disabled_plugin_ids: &peer_disabled_plugin_ids,
+                             environments: McpEnvironmentScope::Selected(
+                                 &resolved_environment_selections,
+                             ),
+diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs
+index 5cd4d77..92beb82 100644
+--- a/codex-rs/core/src/session/turn.rs
++++ b/codex-rs/core/src/session/turn.rs
+@@ -1038,7 +1038,7 @@ async fn required_mcp_servers_for_input(
+         .plugins_manager
+         .plugins_for_config(&turn_context.config.plugins_config_input())
+         .await
+-        .without_plugins(&turn_context.disabled_plugin_ids);
++        .without_plugins(&sess.peer_disabled_plugins(&turn_context.disabled_plugin_ids));
+     let current_config = sess.services.mcp_runtime.current_config();
+     let mentioned_plugins =
+         collect_explicit_plugin_mentions(user_input, loaded_plugins.capability_summaries());
+@@ -1900,7 +1900,7 @@ pub(crate) async fn prepare_tool_recommendations(
+         .plugins_manager
+         .plugins_for_config(&turn_context.config.plugins_config_input())
+         .await
+-        .without_plugins(&turn_context.disabled_plugin_ids);
++        .without_plugins(&sess.peer_disabled_plugins(&turn_context.disabled_plugin_ids));
+     let tool_suggest_is_enabled = tool_suggest_enabled(turn_context);
+     let auth = if tool_suggest_is_enabled {
+         sess.services.auth_manager.auth().await
+diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rs
+index a25dd60..bdd0c03 100644
+--- a/codex-rs/core/src/session/turn_context.rs
++++ b/codex-rs/core/src/session/turn_context.rs
+@@ -1311,7 +1311,9 @@ impl Session {
+             .plugins_manager
+             .plugins_for_config(&plugins_input)
+             .await
+-            .without_plugins(&session_configuration.disabled_plugin_ids);
++            .without_plugins(
++                &self.peer_disabled_plugins(&session_configuration.disabled_plugin_ids),
++            );
+         let trusted_plugin_roots = TrustedPluginRoots::from_plugin_load_outcome(
+             &plugin_outcome,
+             per_turn_config.codex_home.as_path(),
+diff --git a/codex-rs/ext/memories/src/extension.rs b/codex-rs/ext/memories/src/extension.rs
+index 3d68e6f..f58f2af 100644
+--- a/codex-rs/ext/memories/src/extension.rs
++++ b/codex-rs/ext/memories/src/extension.rs
+@@ -1,6 +1,7 @@
+ use std::sync::Arc;
+ 
+ use codex_core::config::Config;
++use codex_core::config::peer_thread_mark;
+ use codex_core::context::ContextualUserFragment;
+ use codex_core::context::MemoryContextFragment;
+ use codex_extension_api::ConfigContributor;
+@@ -63,7 +64,10 @@ impl ContextContributor for MemoriesExtension {
+             let Some(config) = thread_store.get::<MemoriesExtensionConfig>() else {
+                 return Vec::new();
+             };
+-            if !config.enabled {
++            if !config.enabled
++                || peer_thread_mark::mode(thread_store.level_id())
++                    == peer_thread_mark::Mode::Jellyfish
++            {
+                 return Vec::new();
+             }
+ 
+@@ -145,7 +149,10 @@ impl ToolContributor for MemoriesExtension {
+         let Some(config) = thread_store.get::<MemoriesExtensionConfig>() else {
+             return Vec::new();
+         };
+-        if !config.enabled || !config.dedicated_tools {
++        if !config.enabled
++            || !config.dedicated_tools
++            || peer_thread_mark::mode(thread_store.level_id()) == peer_thread_mark::Mode::Jellyfish
++        {
+             return Vec::new();
+         }
+ 
+diff --git a/codex-rs/hooks/src/engine/dispatcher.rs b/codex-rs/hooks/src/engine/dispatcher.rs
+index cc45564..a2d750b 100644
+--- a/codex-rs/hooks/src/engine/dispatcher.rs
++++ b/codex-rs/hooks/src/engine/dispatcher.rs
+@@ -211,6 +211,49 @@ pub(super) async fn execute_handler(
+ ) -> HandlerRunResult {
+     match &handler.kind {
+         ConfiguredHandlerKind::Command { command, env, .. } => {
++            if let Some(home) = codex_config::peer_thread_mark::home()
++                && env
++                    .get("PLUGIN_ROOT")
++                    .is_some_and(|root| super::peer_memory::is_openviking(root))
++            {
++                let mut fallback = event_input.clone();
++                fallback["transcript_path"] = Value::Null;
++                if let Some(path) = fallback.get_mut("agent_transcript_path") {
++                    *path = Value::Null;
++                }
++                let input = event_input.clone();
++                let projection_home = home.clone();
++                let projected = tokio::task::spawn_blocking(move || {
++                    super::peer_memory::project(&projection_home, input)
++                })
++                .await
++                .unwrap_or(fallback);
++                let mut env = env.clone();
++                let enabled = if event_input["session_id"].as_str().is_some_and(|id| {
++                    codex_config::peer_thread_mark::mode_at(&home, id)
++                        == codex_config::peer_thread_mark::Mode::Elephant
++                }) {
++                    "1"
++                } else {
++                    "0"
++                };
++                env.insert("OPENVIKING_AUTO_RECALL".into(), enabled.into());
++                env.insert("OPENVIKING_AUTO_CAPTURE".into(), enabled.into());
++                // The startup sweep must not see state from an unfiltered Codex run.
++                env.insert(
++                    "OPENVIKING_CODEX_STATE_DIR".to_string(),
++                    home.join("codex-capture/openviking").display().to_string(),
++                );
++                return run_command(
++                    &engine.command_runtime,
++                    handler,
++                    command,
++                    &env,
++                    &projected.to_string(),
++                    cwd,
++                )
++                .await;
++            }
+             run_command(
+                 &engine.command_runtime,
+                 handler,
+diff --git a/codex-rs/hooks/src/engine/mod.rs b/codex-rs/hooks/src/engine/mod.rs
+index 5e3daf5..b83cf63 100644
+--- a/codex-rs/hooks/src/engine/mod.rs
++++ b/codex-rs/hooks/src/engine/mod.rs
+@@ -4,6 +4,7 @@ pub(crate) mod dispatcher;
+ mod matcher;
+ pub(crate) mod mcp_runner;
+ pub(crate) mod output_parser;
++mod peer_memory;
+ mod plugin_fingerprint;
+ mod plugin_trust;
+ pub(crate) mod schema_loader;
+diff --git a/codex-rs/memories/write/src/rollout_input.rs b/codex-rs/memories/write/src/rollout_input.rs
+index fa86e25..1c22b55 100644
+--- a/codex-rs/memories/write/src/rollout_input.rs
++++ b/codex-rs/memories/write/src/rollout_input.rs
+@@ -42,13 +42,18 @@ pub(crate) async fn read_recent_rollout_items(path: &Path) -> anyhow::Result<Vec
+         let mut header = String::new();
+         std::io::BufReader::new((&mut reader).take(MAX_RECORD_BYTES as u64))
+             .read_line(&mut header)?;
+-        anyhow::ensure!(
+-            matches!(
+-                codex_rollout::parse_rollout_line(&header)?.item,
+-                RolloutItem::SessionMeta(_)
+-            ),
+-            "memory extraction requires valid session metadata within the record limit"
+-        );
++        let RolloutItem::SessionMeta(session) = codex_rollout::parse_rollout_line(&header)?.item
++        else {
++            anyhow::bail!(
++                "memory extraction requires valid session metadata within the record limit"
++            );
++        };
++        let windows = codex_config::peer_thread_mark::home().map_or_else(Vec::new, |home| {
++            codex_config::peer_thread_mark::windows(&home, &session.meta.id.to_string())
++        });
++        let has_jellyfish = windows
++            .iter()
++            .any(|window| window.mode == codex_config::peer_thread_mark::Mode::Jellyfish);
+         let mut scanner = ReverseJsonlScanner::new(reader)?.with_max_record_bytes(MAX_RECORD_BYTES);
+         let mut remaining = MAX_ROLLOUT_BYTES;
+         let mut items = Vec::new();
+@@ -59,6 +64,19 @@ pub(crate) async fn read_recent_rollout_items(path: &Path) -> anyhow::Result<Vec
+             let ScanOutcome::Parsed(mut line) = outcome else {
+                 continue;
+             };
++            if has_jellyfish
++                && chrono::DateTime::parse_from_rfc3339(&line.timestamp)
++                    .ok()
++                    .is_none_or(|at| {
++                        codex_config::peer_thread_mark::contains(
++                            &windows,
++                            codex_config::peer_thread_mark::Mode::Jellyfish,
++                            at.timestamp_millis(),
++                        )
++                    })
++            {
++                continue;
++            }
+             if !matches!(
+                 &line.item,
+                 RolloutItem::ResponseItem(_) | RolloutItem::InterAgentCommunication(_)

package/mod/codex/client/0002-terminal.patch

@@ -0,0 +1,308 @@
+diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs
+index fbc1090..96690b2 100644
+--- a/codex-rs/tui/src/app.rs
++++ b/codex-rs/tui/src/app.rs
+@@ -239,6 +239,7 @@ mod managed_worktree_creation;
+ mod misalignment_policy;
+ mod model_defaults;
+ mod new_session;
++mod peer_thread_mark;
+ mod quick_dials;
+ mod turn_tips;
+ pub(crate) use new_session::has_launch_setting;
+diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs
+index 3d31b74..5a4fc05 100644
+--- a/codex-rs/tui/src/app/event_dispatch.rs
++++ b/codex-rs/tui/src/app/event_dispatch.rs
+@@ -2832,6 +2832,12 @@ impl App {
+             AppEvent::ResetMemories => {
+                 self.reset_memories_with_app_server(app_server).await;
+             }
++            AppEvent::PeerThreadMark { thread_id, action } => {
++                self.peer_thread_request(app_server, thread_id, action).await;
++            }
++            AppEvent::PeerThreadMarkResult { thread_id, action, result } => {
++                self.peer_thread_result(app_server, thread_id, action, result).await;
++            }
+             AppEvent::UpdateRateLimitSwitchPromptHidden(hidden) => {
+                 self.chat_widget.set_rate_limit_switch_prompt_hidden(hidden);
+             }
+diff --git a/codex-rs/tui/src/app/owned_transcript.rs b/codex-rs/tui/src/app/owned_transcript.rs
+index 312185e..a73d4fe 100644
+--- a/codex-rs/tui/src/app/owned_transcript.rs
++++ b/codex-rs/tui/src/app/owned_transcript.rs
+@@ -461,6 +461,9 @@ impl App {
+                 let size = tui.prepare_draw_size()?;
+                 self.render_owned_transcript(tui, size)?;
+             }
++            if self.chat_widget.handle_peer_mouse(*mouse) {
++                return Ok(true);
++            }
+             if self.chat_widget.no_modal_or_popup_active()
+                 && self
+                     .chat_widget
+diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs
+index 2adc303..032bcc0 100644
+--- a/codex-rs/tui/src/app_event.rs
++++ b/codex-rs/tui/src/app_event.rs
+@@ -1500,6 +1500,16 @@ pub(crate) enum AppEvent {
+     /// Clear all persisted local memory artifacts via the app-server.
+     ResetMemories,
+ 
++    PeerThreadMark {
++        thread_id: ThreadId,
++        action: crate::chatwidget::peer_thread_mark::PeerAction,
++    },
++    PeerThreadMarkResult {
++        thread_id: ThreadId,
++        action: crate::chatwidget::peer_thread_mark::PeerAction,
++        result: Result<crate::chatwidget::peer_thread_mark::PeerReply, String>,
++    },
++
+     /// Update whether the rate limit switch prompt has been acknowledged for the session.
+     UpdateRateLimitSwitchPromptHidden(bool),
+ 
+diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs
+index 68868be..9bdc5ab 100644
+--- a/codex-rs/tui/src/chatwidget.rs
++++ b/codex-rs/tui/src/chatwidget.rs
+@@ -327,6 +327,7 @@ mod model_command;
+ mod model_popup_state;
+ mod model_popups;
+ mod notifications;
++pub(crate) mod peer_thread_mark;
+ pub(crate) mod quick_dials;
+ mod session_model_selection;
+ use self::notifications::Notification;
+@@ -681,6 +682,7 @@ pub(crate) struct ChatWidget {
+     pet_image_support_override: Option<crate::pets::PetImageSupport>,
+     thread_id: Option<ThreadId>,
+     thread_name: Option<String>,
++    peer_mark: peer_thread_mark::PeerBandState,
+     thread_rename_block_message: Option<String>,
+     active_side_conversation: bool,
+     blocks_direct_input: bool,
+diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rs
+index 7b2d08c..5f6101d 100644
+--- a/codex-rs/tui/src/chatwidget/constructor.rs
++++ b/codex-rs/tui/src/chatwidget/constructor.rs
+@@ -263,6 +263,7 @@ impl ChatWidget {
+             last_rendered_width: std::cell::Cell::new(None),
+             feedback,
+             current_rollout_path: None,
++            peer_mark: Default::default(),
+             current_cwd,
+             workspace_command_runner,
+             instruction_source_paths: Vec::new(),
+diff --git a/codex-rs/tui/src/chatwidget/protocol.rs b/codex-rs/tui/src/chatwidget/protocol.rs
+index be7da50..2f7d2f8 100644
+--- a/codex-rs/tui/src/chatwidget/protocol.rs
++++ b/codex-rs/tui/src/chatwidget/protocol.rs
+@@ -444,6 +444,9 @@ impl ChatWidget {
+         let mut question_drafts = None;
+         let live_turn =
+             replay_kind.is_none() && self.last_turn_id() == Some(notification.turn.id.as_str());
++        if live_turn {
++            self.request_peer_action(peer_thread_mark::PeerAction::Refresh);
++        }
+         let mut recourse = self.safety_recourse.take_if(|_| live_turn);
+         let was_replaying_turn_completion = self.thread_usage.replaying_turn_completion;
+         self.thread_usage.replaying_turn_completion = replay_kind.is_some();
+diff --git a/codex-rs/tui/src/chatwidget/rendering.rs b/codex-rs/tui/src/chatwidget/rendering.rs
+index 4f31674..e2ceac2 100644
+--- a/codex-rs/tui/src/chatwidget/rendering.rs
++++ b/codex-rs/tui/src/chatwidget/rendering.rs
+@@ -258,17 +258,21 @@ impl ChatWidget {
+             options.separate_status_line = options.command_popup_placement
+                 != crate::bottom_pane::CommandPopupPlacement::AboveComposer;
+             let bottom_pane = self.bottom_pane.backdrop_with_options(options);
++            let mut flex = 1;
+             let above_composer = if self.quick_dial_menu {
+                 RenderableItem::Owned(Box::new(self.quick_dial_hud()))
+             } else if let Some(pending) = &self.safety_recourse
+                 && !self.bottom_pane.has_active_view()
+             {
+                 RenderableItem::Borrowed(&pending.notice)
++            } else if let Some(band) = self.peer_band() {
++                flex = 0;
++                RenderableItem::Owned(Box::new(band))
+             } else {
+                 return bottom_pane;
+             };
+             let mut column = FlexRenderable::new();
+-            column.push(/*flex*/ 1, above_composer);
++            column.push(flex, above_composer);
+             column.push(/*flex*/ 0, bottom_pane);
+             RenderableItem::Owned(Box::new(column))
+         }
+diff --git a/codex-rs/tui/src/chatwidget/session_flow.rs b/codex-rs/tui/src/chatwidget/session_flow.rs
+index a1ff412..9b55d39 100644
+--- a/codex-rs/tui/src/chatwidget/session_flow.rs
++++ b/codex-rs/tui/src/chatwidget/session_flow.rs
+@@ -135,6 +135,7 @@ impl ChatWidget {
+         self.current_rollout_path = session.rollout_path.clone();
+         self.current_cwd = Some(session.cwd.to_path_buf());
+         self.config.cwd = session.cwd.clone();
++        self.reset_peer_band();
+         self.config.model_provider_id = session.model_provider_id.clone();
+         self.set_daybreak_enabled(self.daybreak_enabled);
+         if connector_scope_changed {
+@@ -417,6 +418,7 @@ impl ChatWidget {
+     ) {
+         if self.thread_id == Some(thread_id) {
+             self.thread_name = thread_name;
++            self.restore_peer_title();
+             self.refresh_status_surfaces();
+             self.request_redraw();
+             self.maybe_send_next_queued_input();
+diff --git a/codex-rs/tui/src/chatwidget/slash_dispatch.rs b/codex-rs/tui/src/chatwidget/slash_dispatch.rs
+index 79a9018..91c2c4f 100644
+--- a/codex-rs/tui/src/chatwidget/slash_dispatch.rs
++++ b/codex-rs/tui/src/chatwidget/slash_dispatch.rs
+@@ -304,6 +304,7 @@ impl ChatWidget {
+                 self.request_redraw();
+             }
+             SlashCommand::Clear => {
++                self.stop_peer_before_clear();
+                 self.app_event_tx.send(AppEvent::ClearUi { name: None });
+             }
+             SlashCommand::Resume => {
+@@ -483,10 +484,22 @@ impl ChatWidget {
+             SlashCommand::Memories => {
+                 self.open_memories_popup();
+             }
++            SlashCommand::Peer => {
++                self.request_peer_action(peer_thread_mark::PeerAction::Start(None))
++            }
++            SlashCommand::PeerMode => self.open_peer_modes(),
++            SlashCommand::PeerList => self.request_peer_action(peer_thread_mark::PeerAction::List),
++            SlashCommand::PeerThread => {
++                self.request_peer_action(peer_thread_mark::PeerAction::Thread)
++            }
++            SlashCommand::PeerAll => {
++                self.request_peer_action(peer_thread_mark::PeerAction::All(String::new()))
++            }
+             SlashCommand::Quit | SlashCommand::Exit => {
+                 self.request_quit_without_confirmation();
+             }
+             SlashCommand::Logout => {
++                self.stop_peer_before_clear();
+                 self.app_event_tx.send(AppEvent::Logout);
+             }
+             SlashCommand::Copy => {
+@@ -805,6 +818,27 @@ impl ChatWidget {
+             return;
+         }
+         match cmd {
++            SlashCommand::Peer => {
++                use peer_thread_mark::PeerAction;
++                let action = match trimmed {
++                    "start" => PeerAction::Start(None),
++                    "stop" => PeerAction::Stop,
++                    "elephant" => PeerAction::Elephant,
++                    "jellyfish" => PeerAction::Jellyfish,
++                    _ => PeerAction::Start(Some(self.prepared_inline_user_message(
++                        args,
++                        text_elements,
++                        local_images,
++                        remote_image_urls,
++                        mention_bindings,
++                        source,
++                    ))),
++                };
++                self.request_peer_action(action);
++            }
++            SlashCommand::PeerAll => {
++                self.request_peer_action(peer_thread_mark::PeerAction::All(args))
++            }
+             SlashCommand::Model if !trimmed.is_empty() => {
+                 self.handle_model_command_args(trimmed);
+                 self.app_event_tx.send(AppEvent::SettingsSelectionClosed);
+@@ -933,6 +967,7 @@ impl ChatWidget {
+                 );
+             }
+             SlashCommand::Clear if !trimmed.is_empty() => {
++                self.stop_peer_before_clear();
+                 self.app_event_tx.send(AppEvent::ClearUi {
+                     name: Some(trimmed.to_string()),
+                 });
+@@ -1350,6 +1385,11 @@ impl ChatWidget {
+             | SlashCommand::Experimental
+             | SlashCommand::AutoReview
+             | SlashCommand::Memories
++            | SlashCommand::Peer
++            | SlashCommand::PeerMode
++            | SlashCommand::PeerList
++            | SlashCommand::PeerThread
++            | SlashCommand::PeerAll
+             | SlashCommand::Quit
+             | SlashCommand::Exit
+             | SlashCommand::Logout
+diff --git a/codex-rs/tui/src/slash_command.rs b/codex-rs/tui/src/slash_command.rs
+index dfd0538..5858bca 100644
+--- a/codex-rs/tui/src/slash_command.rs
++++ b/codex-rs/tui/src/slash_command.rs
+@@ -25,6 +25,11 @@ pub enum SlashCommand {
+     #[strum(to_string = "approve")]
+     AutoReview,
+     Memories,
++    Peer,
++    PeerMode,
++    PeerList,
++    PeerThread,
++    PeerAll,
+     Skills,
+     Import,
+     Hooks,
+@@ -153,6 +158,11 @@ impl SlashCommand {
+             SlashCommand::Experimental => "toggle experimental features",
+             SlashCommand::AutoReview => "approve one retry of a recent auto-review denial",
+             SlashCommand::Memories => "configure memory use and generation",
++            SlashCommand::Peer => "share this thread, or stop sharing",
++            SlashCommand::PeerMode => "choose Elephant, Jellyfish, or Inactive",
++            SlashCommand::PeerList => "browse the workspace's shared threads",
++            SlashCommand::PeerThread => "browse memories saved by this thread",
++            SlashCommand::PeerAll => "search your OpenViking memories",
+             SlashCommand::Mcp => "list MCP tools; use /mcp verbose or /mcp login <name>",
+             SlashCommand::Apps => "manage apps",
+             SlashCommand::Plugins => "browse plugins",
+@@ -173,6 +183,8 @@ impl SlashCommand {
+         matches!(
+             self,
+             SlashCommand::Review
++                | SlashCommand::Peer
++                | SlashCommand::PeerAll
+                 | SlashCommand::Model
+                 | SlashCommand::Permissions
+                 | SlashCommand::Title
+@@ -262,6 +274,8 @@ impl SlashCommand {
+             | SlashCommand::ElevateSandbox
+             | SlashCommand::Experimental
+             | SlashCommand::Memories
++            | SlashCommand::Peer
++            | SlashCommand::PeerMode
+             | SlashCommand::Import
+             | SlashCommand::Review
+             | SlashCommand::Plan
+@@ -297,6 +311,9 @@ impl SlashCommand {
+             | SlashCommand::Mcp
+             | SlashCommand::Apps
+             | SlashCommand::Plugins
++            | SlashCommand::PeerList
++            | SlashCommand::PeerThread
++            | SlashCommand::PeerAll
+             | SlashCommand::Title
+             | SlashCommand::Statusline
+             | SlashCommand::AutoReview
+@@ -318,6 +335,11 @@ impl SlashCommand {
+             SlashCommand::Copy => !cfg!(target_os = "android"),
+             SlashCommand::App => cfg!(any(target_os = "macos", target_os = "windows")),
+             SlashCommand::Voice => true,
++            SlashCommand::Peer
++            | SlashCommand::PeerMode
++            | SlashCommand::PeerList
++            | SlashCommand::PeerThread
++            | SlashCommand::PeerAll => codex_config::peer_thread_mark::home().is_some(),
+             SlashCommand::Rollout | SlashCommand::TestApproval => cfg!(debug_assertions),
+             _ => true,
+         }