diff --git a/codex-rs/core/src/tools/handlers/multi_agents_tests.rs b/codex-rs/core/src/tools/handlers/multi_agents_tests.rs
index 87ce5afec9..93866cf089 100644
--- a/codex-rs/core/src/tools/handlers/multi_agents_tests.rs
+++ b/codex-rs/core/src/tools/handlers/multi_agents_tests.rs
@@ -2,6 +2,7 @@ use super::*;
 use crate::AuthManager;
 use crate::CodexAuth;
 use crate::ThreadManager;
+use crate::agent::WatchdogRegistration;
 use crate::built_in_model_providers;
 use crate::codex::make_session_and_context;
 use crate::config::DEFAULT_AGENT_MAX_DEPTH;
@@ -30,6 +31,7 @@ use crate::tools::handlers::multi_agents_v2::ListAgentsHandler as ListAgentsHand
 use crate::tools::handlers::multi_agents_v2::SendMessageHandler as SendMessageHandlerV2;
 use crate::tools::handlers::multi_agents_v2::SpawnAgentHandler as SpawnAgentHandlerV2;
 use crate::tools::handlers::multi_agents_v2::WaitAgentHandler as WaitAgentHandlerV2;
+use crate::tools::handlers::multi_agents_v2::WatchdogSelfCloseHandlerV2;
 use crate::turn_diff_tracker::TurnDiffTracker;
 use codex_features::Feature;
 use codex_protocol::AgentPath;
@@ -89,6 +91,54 @@ fn thread_manager() -> ThreadManager {
     )
 }
 
+async fn attach_watchdog_helper_for_tests(
+    manager: &ThreadManager,
+    agent_control: &crate::agent::AgentControl,
+    config: &crate::config::Config,
+) -> ThreadId {
+    let owner = manager
+        .start_thread(config.clone())
+        .await
+        .expect("owner thread should start");
+    let target = agent_control
+        .spawn_agent(
+            config.clone(),
+            Op::UserInput {
+                items: Vec::new(),
+                final_output_json_schema: None,
+            },
+            None,
+        )
+        .await
+        .expect("watchdog target thread should start");
+    let helper = manager
+        .start_thread(config.clone())
+        .await
+        .expect("helper thread should start");
+    agent_control
+        .register_watchdog(WatchdogRegistration {
+            owner_thread_id: owner.thread_id,
+            target_thread_id: target,
+            child_depth: 1,
+            interval_s: 30,
+            prompt: "check in".to_string(),
+            config: config.clone(),
+        })
+        .await
+        .expect("watchdog registration should succeed");
+    agent_control
+        .set_watchdog_active_helper_for_tests(target, helper.thread_id)
+        .await;
+    assert_eq!(
+        agent_control
+            .watchdog_owner_for_active_helper(helper.thread_id)
+            .await,
+        Some(owner.thread_id),
+        "watchdog helper should be registered for owner"
+    );
+    helper.thread_id
+}
+
 fn history_contains_inter_agent_communication(
     history_items: &[ResponseItem],
     expected: &InterAgentCommunication,
@@ -175,6 +225,11 @@ struct ListedAgentResult {
     last_task_message: Option<String>,
 }
 
+#[derive(Debug, Deserialize, PartialEq)]
+struct WatchdogSelfCloseResult {
+    previous_status: AgentStatus,
+}
+
 #[tokio::test]
 async fn handler_rejects_non_function_payloads() {
     let (session, turn) = make_session_and_context().await;
@@ -3001,6 +3056,116 @@ async fn close_agent_submits_shutdown_and_returns_previous_status() {
     assert_eq!(status_after, AgentStatus::NotFound);
 }
 
+#[tokio::test]
+async fn watchdog_self_close_rejects_non_watchdog_thread() {
+    let (mut session, turn) = make_session_and_context().await;
+    let manager = thread_manager();
+    let agent_control = manager.agent_control();
+    let thread = manager
+        .start_thread(turn.config.as_ref().clone())
+        .await
+        .expect("thread should start");
+    session.services.agent_control = agent_control.clone();
+    session.conversation_id = thread.thread_id;
+
+    let err = WatchdogSelfCloseHandler
+        .handle(invocation(
+            Arc::new(session),
+            Arc::new(turn),
+            "watchdog_self_close",
+            function_payload(json!({})),
+        ))
+        .await
+        .expect_err("non-watchdog threads should be rejected");
+
+    assert_eq!(
+        err,
+        FunctionCallError::RespondToModel(
+            "watchdog_self_close is only available in watchdog check-in threads.".to_string(),
+        )
+    );
+}
+
+#[tokio::test]
+async fn watchdog_self_close_closes_watchdog_helper_and_returns_previous_status() {
+    let (mut session, turn) = make_session_and_context().await;
+    let manager = thread_manager();
+    let agent_control = manager.agent_control();
+    session.services.agent_control = agent_control.clone();
+    let helper_thread_id =
+        attach_watchdog_helper_for_tests(&manager, &agent_control, turn.config.as_ref()).await;
+    session.conversation_id = helper_thread_id;
+    let status_before = agent_control.get_status(helper_thread_id).await;
+
+    let output = WatchdogSelfCloseHandler
+        .handle(invocation(
+            Arc::new(session),
+            Arc::new(turn),
+            "watchdog_self_close",
+            function_payload(json!({})),
+        ))
+        .await
+        .expect("watchdog helper should be allowed to self-close");
+    let (content, success) = expect_text_output(output);
+    let result: WatchdogSelfCloseResult =
+        serde_json::from_str(&content).expect("watchdog self-close result should be json");
+
+    assert_eq!(
+        result,
+        WatchdogSelfCloseResult {
+            previous_status: status_before,
+        }
+    );
+    assert_eq!(success, Some(true));
+    assert_eq!(
+        agent_control.get_status(helper_thread_id).await,
+        AgentStatus::NotFound
+    );
+}
+
+#[tokio::test]
+async fn multi_agent_v2_watchdog_self_close_closes_watchdog_helper_and_returns_previous_status() {
+    let (mut session, mut turn) = make_session_and_context().await;
+    let manager = thread_manager();
+    let agent_control = manager.agent_control();
+    session.services.agent_control = agent_control.clone();
+    let mut config = turn.config.as_ref().clone();
+    config
+        .features
+        .enable(Feature::MultiAgentV2)
+        .expect("test config should allow feature update");
+    let helper_thread_id =
+        attach_watchdog_helper_for_tests(&manager, &agent_control, &config).await;
+    session.conversation_id = helper_thread_id;
+    turn.config = Arc::new(config);
+    let status_before = agent_control.get_status(helper_thread_id).await;
+
+    let output = WatchdogSelfCloseHandlerV2
+        .handle(invocation(
+            Arc::new(session),
+            Arc::new(turn),
+            "watchdog_self_close",
+            function_payload(json!({})),
+        ))
+        .await
+        .expect("watchdog helper should be allowed to self-close");
+    let (content, success) = expect_text_output(output);
+    let result: WatchdogSelfCloseResult =
+        serde_json::from_str(&content).expect("watchdog self-close result should be json");
+
+    assert_eq!(
+        result,
+        WatchdogSelfCloseResult {
+            previous_status: status_before,
+        }
+    );
+    assert_eq!(success, Some(true));
+    assert_eq!(
+        agent_control.get_status(helper_thread_id).await,
+        AgentStatus::NotFound
+    );
+}
+
 #[tokio::test]
 async fn tool_handlers_cascade_close_and_resume_and_keep_explicitly_closed_subtrees_closed() {
     let (_session, turn) = make_session_and_context().await;
diff --git a/codex-rs/core/src/tools/handlers/multi_agents_v2.rs b/codex-rs/core/src/tools/handlers/multi_agents_v2.rs
index 4c9fb1bf7c..d0b7dec8d9 100644
--- a/codex-rs/core/src/tools/handlers/multi_agents_v2.rs
+++ b/codex-rs/core/src/tools/handlers/multi_agents_v2.rs
@@ -34,6 +34,7 @@ pub(crate) use list_agents::Handler as ListAgentsHandler;
 pub(crate) use send_message::Handler as SendMessageHandler;
 pub(crate) use spawn::Handler as SpawnAgentHandler;
 pub(crate) use wait::Handler as WaitAgentHandler;
+pub(crate) use watchdog_self_close::Handler as WatchdogSelfCloseHandlerV2;
 
 mod assign_task;
 mod close_agent;
diff --git a/codex-rs/core/src/tools/spec.rs b/codex-rs/core/src/tools/spec.rs
index 4cd4952611..80a8c5f440 100644
--- a/codex-rs/core/src/tools/spec.rs
+++ b/codex-rs/core/src/tools/spec.rs
@@ -37,29 +37,25 @@ use codex_protocol::protocol::SandboxPolicy;
 use codex_protocol::protocol::SessionSource;
 use codex_protocol::protocol::SubAgentSource;
 use codex_tools::CommandToolOptions;
+use codex_tools::DiscoverablePluginInfo;
 use codex_tools::DiscoverableTool;
+use codex_tools::DiscoverableToolAction;
 use codex_tools::DiscoverableToolType;
+use codex_tools::FreeformTool;
+use codex_tools::FreeformToolFormat;
 use codex_tools::ResponsesApiNamespace;
 use codex_tools::ResponsesApiNamespaceTool;
+use codex_tools::ResponsesApiTool;
 use codex_tools::ShellToolOptions;
 use codex_tools::SpawnAgentToolOptions;
-use codex_tools::ToolSearchAppInfo;
-use codex_tools::ToolSuggestEntry;
 use codex_tools::ViewImageToolOptions;
 use codex_tools::WaitAgentTimeoutOptions;
 use codex_tools::augment_tool_spec_for_code_mode;
 use codex_tools::create_assign_task_tool;
 use codex_tools::create_close_agent_tool_v1;
 use codex_tools::create_close_agent_tool_v2;
-use codex_tools::create_code_mode_tool;
 use codex_tools::create_exec_command_tool;
-use codex_tools::create_js_repl_reset_tool;
-use codex_tools::create_js_repl_tool;
-use codex_tools::create_list_agents_tool;
-use codex_tools::create_list_dir_tool;
-use codex_tools::create_list_mcp_resource_templates_tool;
-use codex_tools::create_list_mcp_resources_tool;
-use codex_tools::create_read_mcp_resource_tool;
+use codex_tools::create_list_agents_tool as create_list_agents_tool_v2;
 use codex_tools::create_report_agent_job_result_tool;
 use codex_tools::create_request_permissions_tool;
 use codex_tools::create_request_user_input_tool;
@@ -71,33 +67,47 @@ use codex_tools::create_shell_tool;
 use codex_tools::create_spawn_agent_tool_v1;
 use codex_tools::create_spawn_agent_tool_v2;
 use codex_tools::create_spawn_agents_on_csv_tool;
-use codex_tools::create_test_sync_tool;
-use codex_tools::create_tool_search_tool;
-use codex_tools::create_tool_suggest_tool;
 use codex_tools::create_view_image_tool;
 use codex_tools::create_wait_agent_tool_v1;
 use codex_tools::create_wait_agent_tool_v2;
-use codex_tools::create_wait_tool;
+use codex_tools::create_watchdog_self_close_tool;
 use codex_tools::create_write_stdin_tool;
 use codex_tools::dynamic_tool_to_responses_api_tool;
 use codex_tools::mcp_tool_to_responses_api_tool;
 use codex_tools::tool_spec_to_code_mode_tool_definition;
 use codex_utils_absolute_path::AbsolutePathBuf;
+use codex_utils_template::Template;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
+use std::sync::LazyLock;
 
 pub type JsonSchema = codex_tools::JsonSchema;
 
 #[cfg(test)]
 pub(crate) use codex_tools::mcp_call_tool_result_output_schema;
 
+const TOOL_SEARCH_DESCRIPTION_TEMPLATE_SOURCE: &str =
+    include_str!("../../templates/search_tool/tool_description.md");
+const TOOL_SEARCH_DESCRIPTION_TEMPLATE_KEY: &str = "app_descriptions";
+const WATCHDOG_TOOLS_NAMESPACE: &str = "watchdog";
+const WATCHDOG_TOOLS_NAMESPACE_DESCRIPTION: &str =
+    "Watchdog-only tools for parent-thread recovery and watchdog check-in lifecycle control.";
+static TOOL_SEARCH_DESCRIPTION_TEMPLATE: LazyLock<Template> = LazyLock::new(|| {
+    Template::parse(TOOL_SEARCH_DESCRIPTION_TEMPLATE_SOURCE)
+        .unwrap_or_else(|err| panic!("tool_search description template must parse: {err}"))
+});
+const TOOL_SUGGEST_DESCRIPTION_TEMPLATE_SOURCE: &str =
+    include_str!("../../templates/search_tool/tool_suggest_description.md");
+const TOOL_SUGGEST_DESCRIPTION_TEMPLATE_KEY: &str = "discoverable_tools";
+static TOOL_SUGGEST_DESCRIPTION_TEMPLATE: LazyLock<Template> = LazyLock::new(|| {
+    Template::parse(TOOL_SUGGEST_DESCRIPTION_TEMPLATE_SOURCE)
+        .unwrap_or_else(|err| panic!("tool_suggest description template must parse: {err}"))
+});
 const WEB_SEARCH_CONTENT_TYPES: [&str; 2] = ["text", "image"];
-const AGENT_TOOLS_NAMESPACE: &str = "agents";
-const AGENT_TOOLS_NAMESPACE_DESCRIPTION: &str = "Agent collaboration tools for spawning, messaging, waiting on, listing, and closing subagents.";
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum ShellCommandBackendConfig {
@@ -367,6 +377,597 @@ fn supports_image_generation(model_info: &ModelInfo) -> bool {
     model_info.input_modalities.contains(&InputModality::Image)
 }
 
+fn create_wait_tool() -> ToolSpec {
+    let properties = BTreeMap::from([
+        (
+            "cell_id".to_string(),
+            JsonSchema::String {
+                description: Some("Identifier of the running exec cell.".to_string()),
+            },
+        ),
+        (
+            "yield_time_ms".to_string(),
+            JsonSchema::Number {
+                description: Some(
+                    "How long to wait (in milliseconds) for more output before yielding again."
+                        .to_string(),
+                ),
+            },
+        ),
+        (
+            "max_tokens".to_string(),
+            JsonSchema::Number {
+                description: Some(
+                    "Maximum number of output tokens to return for this wait call.".to_string(),
+                ),
+            },
+        ),
+        (
+            "terminate".to_string(),
+            JsonSchema::Boolean {
+                description: Some("Whether to terminate the running exec cell.".to_string()),
+            },
+        ),
+    ]);
+
+    ToolSpec::Function(ResponsesApiTool {
+        name: WAIT_TOOL_NAME.to_string(),
+        description: format!(
+            "Waits on a yielded `{PUBLIC_TOOL_NAME}` cell and returns new output or completion.\n{}",
+            codex_code_mode::build_wait_tool_description().trim()
+        ),
+        strict: false,
+        parameters: JsonSchema::Object {
+            properties,
+            required: Some(vec!["cell_id".to_string()]),
+            additional_properties: Some(false.into()),
+        },
+        output_schema: None,
+        defer_loading: None,
+    })
+}
+
+fn create_test_sync_tool() -> ToolSpec {
+    let barrier_properties = BTreeMap::from([
+        (
+            "id".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Identifier shared by concurrent calls that should rendezvous".to_string(),
+                ),
+            },
+        ),
+        (
+            "participants".to_string(),
+            JsonSchema::Number {
+                description: Some(
+                    "Number of tool calls that must arrive before the barrier opens".to_string(),
+                ),
+            },
+        ),
+        (
+            "timeout_ms".to_string(),
+            JsonSchema::Number {
+                description: Some(
+                    "Maximum time in milliseconds to wait at the barrier".to_string(),
+                ),
+            },
+        ),
+    ]);
+
+    let properties = BTreeMap::from([
+        (
+            "sleep_before_ms".to_string(),
+            JsonSchema::Number {
+                description: Some(
+                    "Optional delay in milliseconds before any other action".to_string(),
+                ),
+            },
+        ),
+        (
+            "sleep_after_ms".to_string(),
+            JsonSchema::Number {
+                description: Some(
+                    "Optional delay in milliseconds after completing the barrier".to_string(),
+                ),
+            },
+        ),
+        (
+            "barrier".to_string(),
+            JsonSchema::Object {
+                properties: barrier_properties,
+                required: Some(vec!["id".to_string(), "participants".to_string()]),
+                additional_properties: Some(false.into()),
+            },
+        ),
+    ]);
+
+    ToolSpec::Function(ResponsesApiTool {
+        name: "test_sync_tool".to_string(),
+        description: "Internal synchronization helper used by Codex integration tests.".to_string(),
+        strict: false,
+        defer_loading: None,
+        parameters: JsonSchema::Object {
+            properties,
+            required: None,
+            additional_properties: Some(false.into()),
+        },
+        output_schema: None,
+    })
+}
+
+fn create_tool_search_tool(
+    app_tools: &HashMap<String, ToolInfo>,
+    include_watchdog_tools: bool,
+) -> ToolSpec {
+    let properties = BTreeMap::from([
+        (
+            "query".to_string(),
+            JsonSchema::String {
+                description: Some("Search query for apps tools.".to_string()),
+            },
+        ),
+        (
+            "limit".to_string(),
+            JsonSchema::Number {
+                description: Some(format!(
+                    "Maximum number of tools to return (defaults to {TOOL_SEARCH_DEFAULT_LIMIT})."
+                )),
+            },
+        ),
+    ]);
+    let mut app_descriptions = BTreeMap::new();
+    if include_watchdog_tools {
+        app_descriptions.insert(
+            WATCHDOG_TOOLS_NAMESPACE.to_string(),
+            Some(WATCHDOG_TOOLS_NAMESPACE_DESCRIPTION.to_string()),
+        );
+    }
+    for tool in app_tools.values() {
+        if tool.server_name != CODEX_APPS_MCP_SERVER_NAME {
+            continue;
+        }
+
+        let Some(connector_name) = tool
+            .connector_name
+            .as_deref()
+            .map(str::trim)
+            .filter(|connector_name| !connector_name.is_empty())
+        else {
+            continue;
+        };
+
+        let connector_description = tool
+            .connector_description
+            .as_deref()
+            .map(str::trim)
+            .filter(|connector_description| !connector_description.is_empty())
+            .map(str::to_string);
+
+        app_descriptions
+            .entry(connector_name.to_string())
+            .and_modify(|existing: &mut Option<String>| {
+                if existing.is_none() {
+                    *existing = connector_description.clone();
+                }
+            })
+            .or_insert(connector_description);
+    }
+
+    let app_descriptions = if app_descriptions.is_empty() {
+        "None currently enabled.".to_string()
+    } else {
+        app_descriptions
+            .into_iter()
+            .map(
+                |(connector_name, connector_description)| match connector_description {
+                    Some(connector_description) => {
+                        format!("- {connector_name}: {connector_description}")
+                    }
+                    None => format!("- {connector_name}"),
+                },
+            )
+            .collect::<Vec<_>>()
+            .join("\n")
+    };
+
+    let description = TOOL_SEARCH_DESCRIPTION_TEMPLATE
+        .render([(
+            TOOL_SEARCH_DESCRIPTION_TEMPLATE_KEY,
+            app_descriptions.as_str(),
+        )])
+        .unwrap_or_else(|err| panic!("tool_search description template must render: {err}"));
+
+    ToolSpec::ToolSearch {
+        execution: "client".to_string(),
+        description,
+        parameters: JsonSchema::Object {
+            properties,
+            required: Some(vec!["query".to_string()]),
+            additional_properties: Some(false.into()),
+        },
+    }
+}
+
+fn create_tool_suggest_tool(discoverable_tools: &[DiscoverableTool]) -> ToolSpec {
+    let discoverable_tool_ids = discoverable_tools
+        .iter()
+        .map(DiscoverableTool::id)
+        .collect::<Vec<_>>()
+        .join(", ");
+    let properties = BTreeMap::from([
+        (
+            "tool_type".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Type of discoverable tool to suggest. Use \"connector\" or \"plugin\"."
+                        .to_string(),
+                ),
+            },
+        ),
+        (
+            "action_type".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Suggested action for the tool. Use \"install\" or \"enable\".".to_string(),
+                ),
+            },
+        ),
+        (
+            "tool_id".to_string(),
+            JsonSchema::String {
+                description: Some(format!(
+                    "Connector or plugin id to suggest. Must be one of: {discoverable_tool_ids}."
+                )),
+            },
+        ),
+        (
+            "suggest_reason".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Concise one-line user-facing reason why this tool can help with the current request."
+                        .to_string(),
+                ),
+            },
+        ),
+    ]);
+    let discoverable_tools = format_discoverable_tools(discoverable_tools);
+    let description = TOOL_SUGGEST_DESCRIPTION_TEMPLATE
+        .render([(
+            TOOL_SUGGEST_DESCRIPTION_TEMPLATE_KEY,
+            discoverable_tools.as_str(),
+        )])
+        .unwrap_or_else(|err| panic!("tool_suggest description template must render: {err}"));
+
+    ToolSpec::Function(ResponsesApiTool {
+        name: TOOL_SUGGEST_TOOL_NAME.to_string(),
+        description,
+        strict: false,
+        defer_loading: None,
+        parameters: JsonSchema::Object {
+            properties,
+            required: Some(vec![
+                "tool_type".to_string(),
+                "action_type".to_string(),
+                "tool_id".to_string(),
+                "suggest_reason".to_string(),
+            ]),
+            additional_properties: Some(false.into()),
+        },
+        output_schema: None,
+    })
+}
+
+fn format_discoverable_tools(discoverable_tools: &[DiscoverableTool]) -> String {
+    let mut discoverable_tools = discoverable_tools.to_vec();
+    discoverable_tools.sort_by(|left, right| {
+        left.name()
+            .cmp(right.name())
+            .then_with(|| left.id().cmp(right.id()))
+    });
+
+    discoverable_tools
+        .into_iter()
+        .map(|tool| {
+            let description = match &tool {
+                DiscoverableTool::Connector(connector) => connector
+                    .description
+                    .as_deref()
+                    .filter(|description| !description.trim().is_empty())
+                    .map(ToString::to_string)
+                    .unwrap_or_else(|| "No description provided.".to_string()),
+                DiscoverableTool::Plugin(plugin) => plugin
+                    .description
+                    .as_deref()
+                    .filter(|description| !description.trim().is_empty())
+                    .map(ToString::to_string)
+                    .unwrap_or_else(|| format_plugin_summary(plugin.as_ref())),
+            };
+            let default_action = match tool.tool_type() {
+                DiscoverableToolType::Connector => DiscoverableToolAction::Install,
+                DiscoverableToolType::Plugin => DiscoverableToolAction::Install,
+            };
+            let tool_type = match tool.tool_type() {
+                DiscoverableToolType::Connector => "connector",
+                DiscoverableToolType::Plugin => "plugin",
+            };
+            let default_action = match default_action {
+                DiscoverableToolAction::Install => "install",
+                DiscoverableToolAction::Enable => "enable",
+            };
+            format!(
+                "- {} (id: `{}`, type: {}, action: {}): {}",
+                tool.name(),
+                tool.id(),
+                tool_type,
+                default_action,
+                description
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn format_plugin_summary(plugin: &DiscoverablePluginInfo) -> String {
+    let mut details = Vec::new();
+    if plugin.has_skills {
+        details.push("skills".to_string());
+    }
+    if !plugin.mcp_server_names.is_empty() {
+        details.push(format!(
+            "MCP servers: {}",
+            plugin.mcp_server_names.join(", ")
+        ));
+    }
+    if !plugin.app_connector_ids.is_empty() {
+        details.push(format!(
+            "app connectors: {}",
+            plugin.app_connector_ids.join(", ")
+        ));
+    }
+
+    if details.is_empty() {
+        "No description provided.".to_string()
+    } else {
+        details.join("; ")
+    }
+}
+
+fn create_list_dir_tool() -> ToolSpec {
+    let properties = BTreeMap::from([
+        (
+            "dir_path".to_string(),
+            JsonSchema::String {
+                description: Some("Absolute path to the directory to list.".to_string()),
+            },
+        ),
+        (
+            "offset".to_string(),
+            JsonSchema::Number {
+                description: Some(
+                    "The entry number to start listing from. Must be 1 or greater.".to_string(),
+                ),
+            },
+        ),
+        (
+            "limit".to_string(),
+            JsonSchema::Number {
+                description: Some("The maximum number of entries to return.".to_string()),
+            },
+        ),
+        (
+            "depth".to_string(),
+            JsonSchema::Number {
+                description: Some(
+                    "The maximum directory depth to traverse. Must be 1 or greater.".to_string(),
+                ),
+            },
+        ),
+    ]);
+
+    ToolSpec::Function(ResponsesApiTool {
+        name: "list_dir".to_string(),
+        description:
+            "Lists entries in a local directory with 1-indexed entry numbers and simple type labels."
+                .to_string(),
+        strict: false,
+        defer_loading: None,
+        parameters: JsonSchema::Object {
+            properties,
+            required: Some(vec!["dir_path".to_string()]),
+            additional_properties: Some(false.into()),
+        },
+        output_schema: None,
+    })
+}
+
+fn create_js_repl_tool() -> ToolSpec {
+    // Keep JS input freeform, but block the most common malformed payload shapes
+    // (JSON wrappers, quoted strings, and markdown fences) before they reach the
+    // runtime `reject_json_or_quoted_source` validation. The API's regex engine
+    // does not support look-around, so this uses a "first significant token"
+    // pattern rather than negative lookaheads.
+    const JS_REPL_FREEFORM_GRAMMAR: &str = r#"
+start: pragma_source | plain_source
+
+pragma_source: PRAGMA_LINE NEWLINE js_source
+plain_source: PLAIN_JS_SOURCE
+
+js_source: JS_SOURCE
+
+PRAGMA_LINE: /[ \t]*\/\/ codex-js-repl:[^\r\n]*/
+NEWLINE: /\r?\n/
+PLAIN_JS_SOURCE: /(?:\s*)(?:[^\s{\"`]|`[^`]|``[^`])[\s\S]*/
+JS_SOURCE: /(?:\s*)(?:[^\s{\"`]|`[^`]|``[^`])[\s\S]*/
+"#;
+
+    ToolSpec::Freeform(FreeformTool {
+        name: "js_repl".to_string(),
+        description: "Runs JavaScript in a persistent Node kernel with top-level await. This is a freeform tool: send raw JavaScript source text, optionally with a first-line pragma like `// codex-js-repl: timeout_ms=15000`; do not send JSON/quotes/markdown fences."
+            .to_string(),
+        format: FreeformToolFormat {
+            r#type: "grammar".to_string(),
+            syntax: "lark".to_string(),
+            definition: JS_REPL_FREEFORM_GRAMMAR.to_string(),
+        },
+    })
+}
+
+fn create_js_repl_reset_tool() -> ToolSpec {
+    ToolSpec::Function(ResponsesApiTool {
+        name: "js_repl_reset".to_string(),
+        description:
+            "Restarts the js_repl kernel for this run and clears persisted top-level bindings."
+                .to_string(),
+        strict: false,
+        defer_loading: None,
+        parameters: JsonSchema::Object {
+            properties: BTreeMap::new(),
+            required: None,
+            additional_properties: Some(false.into()),
+        },
+        output_schema: None,
+    })
+}
+
+fn create_code_mode_tool(
+    enabled_tools: &[(String, String)],
+    code_mode_only_enabled: bool,
+) -> ToolSpec {
+    const CODE_MODE_FREEFORM_GRAMMAR: &str = r#"
+start: pragma_source | plain_source
+pragma_source: PRAGMA_LINE NEWLINE SOURCE
+plain_source: SOURCE
+
+PRAGMA_LINE: /[ \t]*\/\/ @exec:[^\r\n]*/
+NEWLINE: /\r?\n/
+SOURCE: /[\s\S]+/
+"#;
+
+    ToolSpec::Freeform(FreeformTool {
+        name: PUBLIC_TOOL_NAME.to_string(),
+        description: codex_code_mode::build_exec_tool_description(
+            enabled_tools,
+            code_mode_only_enabled,
+        ),
+        format: FreeformToolFormat {
+            r#type: "grammar".to_string(),
+            syntax: "lark".to_string(),
+            definition: CODE_MODE_FREEFORM_GRAMMAR.to_string(),
+        },
+    })
+}
+
+fn create_list_mcp_resources_tool() -> ToolSpec {
+    let properties = BTreeMap::from([
+        (
+            "server".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Optional MCP server name. When omitted, lists resources from every configured server."
+                        .to_string(),
+                ),
+            },
+        ),
+        (
+            "cursor".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Opaque cursor returned by a previous list_mcp_resources call for the same server."
+                        .to_string(),
+                ),
+            },
+        ),
+    ]);
+
+    ToolSpec::Function(ResponsesApiTool {
+        name: "list_mcp_resources".to_string(),
+        description: "Lists resources provided by MCP servers. Resources allow servers to share data that provides context to language models, such as files, database schemas, or application-specific information. Prefer resources over web search when possible.".to_string(),
+        strict: false,
+        defer_loading: None,
+        parameters: JsonSchema::Object {
+            properties,
+            required: None,
+            additional_properties: Some(false.into()),
+        },
+        output_schema: None,
+    })
+}
+
+fn create_list_mcp_resource_templates_tool() -> ToolSpec {
+    let properties = BTreeMap::from([
+        (
+            "server".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Optional MCP server name. When omitted, lists resource templates from all configured servers."
+                        .to_string(),
+                ),
+            },
+        ),
+        (
+            "cursor".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Opaque cursor returned by a previous list_mcp_resource_templates call for the same server."
+                        .to_string(),
+                ),
+            },
+        ),
+    ]);
+
+    ToolSpec::Function(ResponsesApiTool {
+        name: "list_mcp_resource_templates".to_string(),
+        description: "Lists resource templates provided by MCP servers. Parameterized resource templates allow servers to share data that takes parameters and provides context to language models, such as files, database schemas, or application-specific information. Prefer resource templates over web search when possible.".to_string(),
+        strict: false,
+        defer_loading: None,
+        parameters: JsonSchema::Object {
+            properties,
+            required: None,
+            additional_properties: Some(false.into()),
+        },
+        output_schema: None,
+    })
+}
+
+fn create_read_mcp_resource_tool() -> ToolSpec {
+    let properties = BTreeMap::from([
+        (
+            "server".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "MCP server name exactly as configured. Must match the 'server' field returned by list_mcp_resources."
+                        .to_string(),
+                ),
+            },
+        ),
+        (
+            "uri".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Resource URI to read. Must be one of the URIs returned by list_mcp_resources."
+                        .to_string(),
+                ),
+            },
+        ),
+    ]);
+
+    ToolSpec::Function(ResponsesApiTool {
+        name: "read_mcp_resource".to_string(),
+        description:
+            "Read a specific resource from an MCP server given the server name and resource URI."
+                .to_string(),
+        strict: false,
+        defer_loading: None,
+        parameters: JsonSchema::Object {
+            properties,
+            required: Some(vec!["server".to_string(), "uri".to_string()]),
+            additional_properties: Some(false.into()),
+        },
+        output_schema: None,
+    })
+}
+
 /// TODO(dylan): deprecate once we get rid of json tool
 #[derive(Serialize, Deserialize)]
 pub(crate) struct ApplyPatchToolArgs {
@@ -391,7 +992,7 @@ fn push_tool_spec(
     }
 }
 
-fn create_agent_tools_namespace(tools: Vec<ToolSpec>) -> ToolSpec {
+fn create_watchdog_tools_namespace(tools: Vec<ToolSpec>) -> ToolSpec {
     let tools = tools
         .into_iter()
         .filter_map(|tool| match tool {
@@ -401,18 +1002,105 @@ fn create_agent_tools_namespace(tools: Vec<ToolSpec>) -> ToolSpec {
         .collect();
 
     ToolSpec::Namespace(ResponsesApiNamespace {
-        name: AGENT_TOOLS_NAMESPACE.to_string(),
-        description: AGENT_TOOLS_NAMESPACE_DESCRIPTION.to_string(),
+        name: WATCHDOG_TOOLS_NAMESPACE.to_string(),
+        description: WATCHDOG_TOOLS_NAMESPACE_DESCRIPTION.to_string(),
         tools,
     })
 }
 
-fn register_agent_tool_handler<H>(builder: &mut ToolRegistryBuilder, name: &str, handler: Arc<H>)
+fn create_compact_parent_context_tool() -> ToolSpec {
+    let properties = BTreeMap::from([
+        (
+            "reason".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Optional short reason describing why the parent appears stuck.".to_string(),
+                ),
+            },
+        ),
+        (
+            "evidence".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Optional concrete evidence of non-progress, such as repeated identical replies with no tool or file actions.".to_string(),
+                ),
+            },
+        ),
+    ]);
+
+    ToolSpec::Function(ResponsesApiTool {
+        name: "compact_parent_context".to_string(),
+        description: "Watchdog-only: request compaction for the watchdog helper's parent thread when it is idle and appears stuck."
+            .to_string(),
+        strict: false,
+        defer_loading: Some(true),
+        parameters: JsonSchema::Object {
+            properties,
+            required: None,
+            additional_properties: Some(false.into()),
+        },
+        output_schema: None,
+    })
+}
+
+fn create_list_agents_tool(agent_watchdog: bool) -> ToolSpec {
+    let description = if agent_watchdog {
+        "List agents spawned by an agent, optionally recursively. This is a status view; polling it will not make a watchdog fire."
+    } else {
+        "List agents spawned by an agent, optionally recursively."
+    };
+    let properties = BTreeMap::from([
+        (
+            "id".to_string(),
+            JsonSchema::String {
+                description: Some(
+                    "Identifier of the parent agent whose spawned agents to list. Defaults to the current agent."
+                        .to_string(),
+                ),
+            },
+        ),
+        (
+            "recursive".to_string(),
+            JsonSchema::Boolean {
+                description: Some(
+                    "When true (default), include all descendants recursively. When false, include only direct children."
+                        .to_string(),
+                ),
+            },
+        ),
+        (
+            "all".to_string(),
+            JsonSchema::Boolean {
+                description: Some(
+                    "When true, include completed/failed/canceled agents in addition to live agents."
+                        .to_string(),
+                ),
+            },
+        ),
+    ]);
+
+    ToolSpec::Function(ResponsesApiTool {
+        name: "list_agents".to_string(),
+        description: description.to_string(),
+        strict: false,
+        defer_loading: None,
+        parameters: JsonSchema::Object {
+            properties,
+            required: None,
+            additional_properties: Some(false.into()),
+        },
+        output_schema: None,
+    })
+}
+
+fn register_watchdog_tool_handler<H>(builder: &mut ToolRegistryBuilder, name: &str, handler: Arc<H>)
 where
     H: crate::tools::registry::ToolHandler + 'static,
 {
-    builder.register_handler(name, handler.clone());
-    builder.register_handler(tool_handler_key(name, Some(AGENT_TOOLS_NAMESPACE)), handler);
+    builder.register_handler(
+        tool_handler_key(name, Some(WATCHDOG_TOOLS_NAMESPACE)),
+        handler,
+    );
 }
 
 /// Builds the tool registry builder while collecting tool specs for later serialization.
@@ -459,18 +1147,20 @@ pub(crate) fn build_specs_with_discoverable_tools(
     use crate::tools::handlers::UnifiedExecHandler;
     use crate::tools::handlers::ViewImageHandler;
     use crate::tools::handlers::multi_agents::CloseAgentHandler;
-
+    use crate::tools::handlers::multi_agents::CompactParentContextHandler;
+    use crate::tools::handlers::multi_agents::ListAgentsHandler;
     use crate::tools::handlers::multi_agents::ResumeAgentHandler;
     use crate::tools::handlers::multi_agents::SendInputHandler;
     use crate::tools::handlers::multi_agents::SpawnAgentHandler;
     use crate::tools::handlers::multi_agents::WaitAgentHandler;
-
+    use crate::tools::handlers::multi_agents::WatchdogSelfCloseHandler;
     use crate::tools::handlers::multi_agents_v2::AssignTaskHandler as AssignTaskHandlerV2;
     use crate::tools::handlers::multi_agents_v2::CloseAgentHandler as CloseAgentHandlerV2;
     use crate::tools::handlers::multi_agents_v2::ListAgentsHandler as ListAgentsHandlerV2;
     use crate::tools::handlers::multi_agents_v2::SendMessageHandler as SendMessageHandlerV2;
     use crate::tools::handlers::multi_agents_v2::SpawnAgentHandler as SpawnAgentHandlerV2;
     use crate::tools::handlers::multi_agents_v2::WaitAgentHandler as WaitAgentHandlerV2;
+    use crate::tools::handlers::multi_agents_v2::WatchdogSelfCloseHandlerV2;
     let mut builder = ToolRegistryBuilder::new();
 
     let shell_handler = Arc::new(ShellHandler);
@@ -665,10 +1355,7 @@ pub(crate) fn build_specs_with_discoverable_tools(
         let search_tool_handler = Arc::new(ToolSearchHandler::new(app_tools.clone()));
         push_tool_spec(
             &mut builder,
-            create_tool_search_tool(
-                &tool_search_app_infos(&app_tools),
-                TOOL_SEARCH_DEFAULT_LIMIT,
-            ),
+            create_tool_search_tool(&app_tools, config.agent_watchdog),
             /*supports_parallel_tool_calls*/ true,
             config.code_mode_enabled,
         );
@@ -688,7 +1375,7 @@ pub(crate) fn build_specs_with_discoverable_tools(
             .filter(|tools| !tools.is_empty())
     {
         builder.push_spec_with_parallel_support(
-            create_tool_suggest_tool(&tool_suggest_entries(discoverable_tools)),
+            create_tool_suggest_tool(discoverable_tools),
             /*supports_parallel_tool_calls*/ true,
         );
         builder.register_handler(TOOL_SUGGEST_TOOL_NAME, tool_suggest_handler);
@@ -808,67 +1495,155 @@ pub(crate) fn build_specs_with_discoverable_tools(
 
     if config.collab_tools {
         if config.multi_agent_v2 {
-            let agent_tools = vec![
+            push_tool_spec(
+                &mut builder,
                 create_spawn_agent_tool_v2(SpawnAgentToolOptions {
                     available_models: &config.available_models,
                     agent_type_description: crate::agent::role::spawn_tool_spec::build(
                         &config.agent_roles,
                     ),
                 }),
+                /*supports_parallel_tool_calls*/ false,
+                config.code_mode_enabled,
+            );
+            push_tool_spec(
+                &mut builder,
                 create_send_message_tool(),
+                /*supports_parallel_tool_calls*/ false,
+                config.code_mode_enabled,
+            );
+            push_tool_spec(
+                &mut builder,
                 create_assign_task_tool(),
+                /*supports_parallel_tool_calls*/ false,
+                config.code_mode_enabled,
+            );
+            push_tool_spec(
+                &mut builder,
                 create_wait_agent_tool_v2(WaitAgentTimeoutOptions {
                     default_timeout_ms: DEFAULT_WAIT_TIMEOUT_MS,
                     min_timeout_ms: MIN_WAIT_TIMEOUT_MS,
                     max_timeout_ms: MAX_WAIT_TIMEOUT_MS,
                 }),
-                create_close_agent_tool_v2(),
-                create_list_agents_tool(),
-            ];
-            push_tool_spec(
-                &mut builder,
-                create_agent_tools_namespace(agent_tools),
                 /*supports_parallel_tool_calls*/ false,
                 config.code_mode_enabled,
             );
-            register_agent_tool_handler(&mut builder, "spawn_agent", Arc::new(SpawnAgentHandlerV2));
-            register_agent_tool_handler(
+            push_tool_spec(
                 &mut builder,
-                "send_message",
-                Arc::new(SendMessageHandlerV2),
+                create_close_agent_tool_v2(),
+                /*supports_parallel_tool_calls*/ false,
+                config.code_mode_enabled,
             );
-            register_agent_tool_handler(&mut builder, "assign_task", Arc::new(AssignTaskHandlerV2));
-            register_agent_tool_handler(&mut builder, "wait_agent", Arc::new(WaitAgentHandlerV2));
-            register_agent_tool_handler(&mut builder, "close_agent", Arc::new(CloseAgentHandlerV2));
-            register_agent_tool_handler(&mut builder, "list_agents", Arc::new(ListAgentsHandlerV2));
+            push_tool_spec(
+                &mut builder,
+                create_list_agents_tool_v2(),
+                /*supports_parallel_tool_calls*/ false,
+                config.code_mode_enabled,
+            );
+            if config.agent_watchdog {
+                push_tool_spec(
+                    &mut builder,
+                    create_watchdog_tools_namespace(vec![
+                        create_compact_parent_context_tool(),
+                        create_watchdog_self_close_tool(),
+                    ]),
+                    /*supports_parallel_tool_calls*/ false,
+                    config.code_mode_enabled,
+                );
+            }
+            builder.register_handler("spawn_agent", Arc::new(SpawnAgentHandlerV2));
+            builder.register_handler("send_message", Arc::new(SendMessageHandlerV2));
+            builder.register_handler("assign_task", Arc::new(AssignTaskHandlerV2));
+            builder.register_handler("wait_agent", Arc::new(WaitAgentHandlerV2));
+            builder.register_handler("close_agent", Arc::new(CloseAgentHandlerV2));
+            builder.register_handler("list_agents", Arc::new(ListAgentsHandlerV2));
+            if config.agent_watchdog {
+                register_watchdog_tool_handler(
+                    &mut builder,
+                    "compact_parent_context",
+                    Arc::new(CompactParentContextHandler),
+                );
+                register_watchdog_tool_handler(
+                    &mut builder,
+                    "watchdog_self_close",
+                    Arc::new(WatchdogSelfCloseHandlerV2),
+                );
+            }
         } else {
-            let agent_tools = vec![
+            push_tool_spec(
+                &mut builder,
                 create_spawn_agent_tool_v1(SpawnAgentToolOptions {
                     available_models: &config.available_models,
                     agent_type_description: crate::agent::role::spawn_tool_spec::build(
                         &config.agent_roles,
                     ),
                 }),
+                /*supports_parallel_tool_calls*/ false,
+                config.code_mode_enabled,
+            );
+            push_tool_spec(
+                &mut builder,
                 create_send_input_tool_v1(),
+                /*supports_parallel_tool_calls*/ false,
+                config.code_mode_enabled,
+            );
+            push_tool_spec(
+                &mut builder,
                 create_resume_agent_tool(),
+                /*supports_parallel_tool_calls*/ false,
+                config.code_mode_enabled,
+            );
+            push_tool_spec(
+                &mut builder,
                 create_wait_agent_tool_v1(WaitAgentTimeoutOptions {
                     default_timeout_ms: DEFAULT_WAIT_TIMEOUT_MS,
                     min_timeout_ms: MIN_WAIT_TIMEOUT_MS,
                     max_timeout_ms: MAX_WAIT_TIMEOUT_MS,
                 }),
-                create_close_agent_tool_v1(),
-            ];
-            push_tool_spec(
-                &mut builder,
-                create_agent_tools_namespace(agent_tools),
                 /*supports_parallel_tool_calls*/ false,
                 config.code_mode_enabled,
             );
-            register_agent_tool_handler(&mut builder, "spawn_agent", Arc::new(SpawnAgentHandler));
-            register_agent_tool_handler(&mut builder, "send_input", Arc::new(SendInputHandler));
-            register_agent_tool_handler(&mut builder, "resume_agent", Arc::new(ResumeAgentHandler));
-            register_agent_tool_handler(&mut builder, "wait_agent", Arc::new(WaitAgentHandler));
-            register_agent_tool_handler(&mut builder, "close_agent", Arc::new(CloseAgentHandler));
+            push_tool_spec(
+                &mut builder,
+                create_close_agent_tool_v1(),
+                /*supports_parallel_tool_calls*/ false,
+                config.code_mode_enabled,
+            );
+            if config.agent_watchdog {
+                push_tool_spec(
+                    &mut builder,
+                    create_list_agents_tool(config.agent_watchdog),
+                    /*supports_parallel_tool_calls*/ false,
+                    config.code_mode_enabled,
+                );
+                push_tool_spec(
+                    &mut builder,
+                    create_watchdog_tools_namespace(vec![
+                        create_compact_parent_context_tool(),
+                        create_watchdog_self_close_tool(),
+                    ]),
+                    /*supports_parallel_tool_calls*/ false,
+                    config.code_mode_enabled,
+                );
+            }
+            builder.register_handler("spawn_agent", Arc::new(SpawnAgentHandler));
+            builder.register_handler("send_input", Arc::new(SendInputHandler));
+            builder.register_handler("resume_agent", Arc::new(ResumeAgentHandler));
+            builder.register_handler("wait_agent", Arc::new(WaitAgentHandler));
+            builder.register_handler("close_agent", Arc::new(CloseAgentHandler));
+            builder.register_handler("list_agents", Arc::new(ListAgentsHandler));
+            if config.agent_watchdog {
+                register_watchdog_tool_handler(
+                    &mut builder,
+                    "compact_parent_context",
+                    Arc::new(CompactParentContextHandler),
+                );
+                register_watchdog_tool_handler(
+                    &mut builder,
+                    "watchdog_self_close",
+                    Arc::new(WatchdogSelfCloseHandler),
+                );
+            }
         }
     }
 
@@ -939,54 +1714,6 @@ pub(crate) fn build_specs_with_discoverable_tools(
     builder
 }
 
-fn tool_search_app_infos(app_tools: &HashMap<String, ToolInfo>) -> Vec<ToolSearchAppInfo> {
-    app_tools
-        .values()
-        .filter(|tool| tool.server_name == CODEX_APPS_MCP_SERVER_NAME)
-        .filter_map(|tool| {
-            let name = tool
-                .connector_name
-                .as_deref()
-                .map(str::trim)
-                .filter(|connector_name| !connector_name.is_empty())?
-                .to_string();
-            let description = tool
-                .connector_description
-                .as_deref()
-                .map(str::trim)
-                .filter(|connector_description| !connector_description.is_empty())
-                .map(str::to_string);
-            Some(ToolSearchAppInfo { name, description })
-        })
-        .collect()
-}
-
-fn tool_suggest_entries(discoverable_tools: &[DiscoverableTool]) -> Vec<ToolSuggestEntry> {
-    discoverable_tools
-        .iter()
-        .map(|tool| match tool {
-            DiscoverableTool::Connector(connector) => ToolSuggestEntry {
-                id: connector.id.clone(),
-                name: connector.name.clone(),
-                description: connector.description.clone(),
-                tool_type: DiscoverableToolType::Connector,
-                has_skills: false,
-                mcp_server_names: Vec::new(),
-                app_connector_ids: Vec::new(),
-            },
-            DiscoverableTool::Plugin(plugin) => ToolSuggestEntry {
-                id: plugin.id.clone(),
-                name: plugin.name.clone(),
-                description: plugin.description.clone(),
-                tool_type: DiscoverableToolType::Plugin,
-                has_skills: plugin.has_skills,
-                mcp_server_names: plugin.mcp_server_names.clone(),
-                app_connector_ids: plugin.app_connector_ids.clone(),
-            },
-        })
-        .collect()
-}
-
 #[cfg(test)]
 #[path = "spec_tests.rs"]
 mod tests;
diff --git a/codex-rs/core/src/tools/spec_tests.rs b/codex-rs/core/src/tools/spec_tests.rs
index cf43ff5e93..0aeacbd6ee 100644
--- a/codex-rs/core/src/tools/spec_tests.rs
+++ b/codex-rs/core/src/tools/spec_tests.rs
@@ -13,11 +13,7 @@ use codex_protocol::openai_models::ModelsResponse;
 use codex_tools::AdditionalProperties;
 use codex_tools::CommandToolOptions;
 use codex_tools::ConfiguredToolSpec;
-use codex_tools::DiscoverablePluginInfo;
-use codex_tools::DiscoverableTool;
 use codex_tools::FreeformTool;
-use codex_tools::ResponsesApiNamespaceTool;
-use codex_tools::ResponsesApiTool;
 use codex_tools::ResponsesApiWebSearchFilters;
 use codex_tools::ResponsesApiWebSearchUserLocation;
 use codex_tools::SpawnAgentToolOptions;
@@ -26,7 +22,6 @@ use codex_tools::WaitAgentTimeoutOptions;
 use codex_tools::create_close_agent_tool_v1;
 use codex_tools::create_close_agent_tool_v2;
 use codex_tools::create_exec_command_tool;
-use codex_tools::create_list_agents_tool;
 use codex_tools::create_request_permissions_tool;
 use codex_tools::create_request_user_input_tool;
 use codex_tools::create_resume_agent_tool;
@@ -37,6 +32,7 @@ use codex_tools::create_spawn_agent_tool_v2;
 use codex_tools::create_view_image_tool;
 use codex_tools::create_wait_agent_tool_v1;
 use codex_tools::create_wait_agent_tool_v2;
+use codex_tools::create_watchdog_self_close_tool;
 use codex_tools::create_write_stdin_tool;
 use codex_tools::mcp_tool_to_deferred_responses_api_tool;
 use codex_utils_absolute_path::AbsolutePathBuf;
@@ -174,6 +170,20 @@ fn assert_lacks_tool_name(tools: &[ConfiguredToolSpec], expected_absent: &str) {
     );
 }
 
+fn assert_contains_top_level_tool_name(tools: &[ConfiguredToolSpec], expected: &str) {
+    assert!(
+        tools.iter().any(|tool| tool.name() == expected),
+        "expected top-level tool {expected} to be present"
+    );
+}
+
+fn assert_lacks_top_level_tool_name(tools: &[ConfiguredToolSpec], expected_absent: &str) {
+    assert!(
+        !tools.iter().any(|tool| tool.name() == expected_absent),
+        "expected top-level tool {expected_absent} to be absent"
+    );
+}
+
 fn shell_tool_name(config: &ToolsConfig) -> Option<&'static str> {
     match config.shell_type {
         ConfigShellToolType::Default => Some("shell"),
@@ -230,23 +240,36 @@ fn find_tool<'a>(tools: &'a [ConfiguredToolSpec], expected_name: &str) -> &'a Co
     panic!("expected tool {expected_name}")
 }
 
-fn find_namespaced_tool<'a>(
-    tools: &'a [ConfiguredToolSpec],
-    namespace: &str,
+fn find_namespaced_tool(
+    tools: &[ConfiguredToolSpec],
+    namespace_name: &str,
     expected_name: &str,
-) -> &'a ResponsesApiTool {
-    let namespace_tool = find_tool(tools, namespace);
-    let ToolSpec::Namespace(namespace) = &namespace_tool.spec else {
-        panic!("expected {namespace} namespace tool");
-    };
-    namespace
+) -> ConfiguredToolSpec {
+    let namespace = tools
+        .iter()
+        .find_map(|tool| match &tool.spec {
+            ToolSpec::Namespace(namespace) if namespace.name == namespace_name => Some(namespace),
+            _ => None,
+        })
+        .unwrap_or_else(|| panic!("expected namespace {namespace_name}"));
+
+    let tool = namespace
         .tools
         .iter()
         .find_map(|tool| match tool {
-            ResponsesApiNamespaceTool::Function(tool) if tool.name == expected_name => Some(tool),
+            codex_tools::ResponsesApiNamespaceTool::Function(tool)
+                if tool.name == expected_name =>
+            {
+                Some(tool.clone())
+            }
             _ => None,
         })
-        .expect("expected tool in namespace")
+        .unwrap_or_else(|| panic!("expected tool {expected_name} in {namespace_name}"));
+
+    ConfiguredToolSpec::new(
+        ToolSpec::Function(tool),
+        /*supports_parallel_tool_calls*/ false,
+    )
 }
 
 fn strip_descriptions_schema(schema: &mut JsonSchema) {
@@ -418,7 +441,7 @@ fn test_full_toolset_specs_for_gpt5_codex_unified_exec_web_search() {
             create_send_message_tool(),
             create_wait_agent_tool_v2(wait_agent_timeout_options()),
             create_close_agent_tool_v2(),
-            create_list_agents_tool(),
+            create_list_agents_tool_v2(),
         ]
     } else {
         let mut collab_specs = vec![
@@ -428,10 +451,21 @@ fn test_full_toolset_specs_for_gpt5_codex_unified_exec_web_search() {
             create_wait_agent_tool_v1(wait_agent_timeout_options()),
             create_close_agent_tool_v1(),
         ];
+        if config.agent_watchdog {
+            collab_specs.push(create_list_agents_tool(config.agent_watchdog));
+        }
         collab_specs
     };
-    let spec = create_agent_tools_namespace(collab_specs.split_off(0));
-    expected.insert(spec.name().to_string(), spec);
+    for spec in collab_specs.split_off(0) {
+        expected.insert(spec.name().to_string(), spec);
+    }
+    if config.agent_watchdog {
+        let spec = create_watchdog_tools_namespace(vec![
+            create_compact_parent_context_tool(),
+            create_watchdog_self_close_tool(),
+        ]);
+        expected.insert(spec.name().to_string(), spec);
+    }
 
     if config.exec_permission_approvals_enabled {
         let spec = create_request_permissions_tool(request_permissions_tool_description());
@@ -476,16 +510,66 @@ fn test_build_specs_collab_tools_enabled() {
         &[],
     )
     .build();
-    assert_contains_tool_names(&tools, &["agents"]);
+    assert_contains_tool_names(&tools, &["tool_search"]);
+    assert_contains_tool_names(
+        &tools,
+        &["spawn_agent", "send_input", "wait_agent", "close_agent"],
+    );
     assert_lacks_tool_name(&tools, "spawn_agents_on_csv");
     assert_lacks_tool_name(&tools, "list_agents");
+    assert_lacks_tool_name(&tools, "watchdog");
+}
 
-    let spawn_agent = find_namespaced_tool(&tools, "agents", "spawn_agent");
-    let JsonSchema::Object { properties, .. } = &spawn_agent.parameters else {
-        panic!("spawn_agent should use object params");
+#[test]
+fn test_build_specs_watchdog_collab_tools_include_self_close_tool() {
+    let config = test_config();
+    let model_info = ModelsManager::construct_model_info_offline_for_tests("gpt-5-codex", &config);
+    let mut features = Features::with_defaults();
+    features.enable(Feature::Collab);
+    features.enable(Feature::AgentWatchdog);
+    features.normalize_dependencies();
+    let available_models = Vec::new();
+    let tools_config = ToolsConfig::new(&ToolsConfigParams {
+        model_info: &model_info,
+        available_models: &available_models,
+        features: &features,
+        web_search_mode: Some(WebSearchMode::Cached),
+        session_source: SessionSource::Cli,
+        sandbox_policy: &SandboxPolicy::DangerFullAccess,
+        windows_sandbox_level: WindowsSandboxLevel::Disabled,
+    });
+
+    let (tools, _) = build_specs(
+        &tools_config,
+        /*mcp_tools*/ None,
+        /*app_tools*/ None,
+        &[],
+    )
+    .build();
+
+    assert_contains_top_level_tool_name(&tools, "watchdog");
+    assert_contains_tool_names(&tools, &["tool_search", "list_agents", "close_agent"]);
+    assert_lacks_top_level_tool_name(&tools, "watchdog_self_close");
+    assert_lacks_top_level_tool_name(&tools, "compact_parent_context");
+
+    let watchdog_self_close = find_namespaced_tool(&tools, "watchdog", "watchdog_self_close");
+    let ToolSpec::Function(ResponsesApiTool {
+        defer_loading: Some(deferred),
+        ..
+    }) = &watchdog_self_close.spec
+    else {
+        panic!("watchdog_self_close should be a function tool");
     };
-    assert!(properties.contains_key("fork_context"));
-    assert!(!properties.contains_key("fork_turns"));
+    assert!(*deferred);
+    let compact_parent_context = find_namespaced_tool(&tools, "watchdog", "compact_parent_context");
+    let ToolSpec::Function(ResponsesApiTool {
+        defer_loading: Some(deferred),
+        ..
+    }) = &compact_parent_context.spec
+    else {
+        panic!("compact_parent_context should be a function tool");
+    };
+    assert!(*deferred);
 }
 
 #[test]
@@ -512,57 +596,56 @@ fn test_build_specs_multi_agent_v2_uses_task_names_and_hides_resume() {
         &[],
     )
     .build();
-    assert_contains_tool_names(&tools, &["agents"]);
+    assert_contains_tool_names(
+        &tools,
+        &[
+            "spawn_agent",
+            "send_message",
+            "assign_task",
+            "wait_agent",
+            "close_agent",
+            "list_agents",
+        ],
+    );
 
-    let spawn_agent = find_namespaced_tool(&tools, "agents", "spawn_agent");
-    let JsonSchema::Object {
-        properties: _,
-        required,
+    let spawn_agent = find_tool(&tools, "spawn_agent");
+    let ToolSpec::Function(ResponsesApiTool {
+        parameters,
+        output_schema,
         ..
-    } = &spawn_agent.parameters
+    }) = &spawn_agent.spec
     else {
         panic!("spawn_agent should be a function tool");
     };
-    let output_schema = spawn_agent
-        .output_schema
+    let JsonSchema::Object {
+        properties,
+        required,
+        ..
+    } = parameters
+    else {
+        panic!("spawn_agent should use object params");
+    };
+    assert!(properties.contains_key("task_name"));
+    assert_eq!(required.as_ref(), Some(&vec!["task_name".to_string()]));
+    let output_schema = output_schema
         .as_ref()
         .expect("spawn_agent should define output schema");
-    assert_eq!(
-        required.as_ref(),
-        Some(&vec!["task_name".to_string(), "items".to_string()])
-    );
     assert_eq!(
         output_schema["required"],
         json!(["agent_id", "task_name", "nickname"])
     );
 
-    let send_message = find_namespaced_tool(&tools, "agents", "send_message");
-    let JsonSchema::Object {
-        properties,
-        required,
-        ..
-    } = &send_message.parameters
-    else {
+    let send_message = find_tool(&tools, "send_message");
+    let ToolSpec::Function(ResponsesApiTool { parameters, .. }) = &send_message.spec else {
         panic!("send_message should be a function tool");
     };
-    assert!(properties.contains_key("items"));
-    assert!(!properties.contains_key("message"));
-    assert!(properties.contains_key("target"));
-    assert!(!properties.contains_key("interrupt"));
-    assert!(!properties.contains_key("message"));
-    assert_eq!(
-        required.as_ref(),
-        Some(&vec!["target".to_string(), "items".to_string()])
-    );
-
-    let assign_task = find_namespaced_tool(&tools, "agents", "assign_task");
     let JsonSchema::Object {
         properties,
         required,
         ..
-    } = &assign_task.parameters
+    } = parameters
     else {
-        panic!("assign_task should be a function tool");
+        panic!("send_message should use object params");
     };
     assert!(properties.contains_key("target"));
     assert!(!properties.contains_key("message"));
@@ -571,42 +654,74 @@ fn test_build_specs_multi_agent_v2_uses_task_names_and_hides_resume() {
         Some(&vec!["target".to_string(), "items".to_string()])
     );
 
-    let wait_agent = find_namespaced_tool(&tools, "agents", "wait_agent");
+    let assign_task = find_tool(&tools, "assign_task");
+    let ToolSpec::Function(ResponsesApiTool { parameters, .. }) = &assign_task.spec else {
+        panic!("assign_task should be a function tool");
+    };
     let JsonSchema::Object {
         properties,
         required,
         ..
-    } = &wait_agent.parameters
+    } = parameters
+    else {
+        panic!("assign_task should use object params");
+    };
+    assert!(properties.contains_key("target"));
+    assert!(!properties.contains_key("message"));
+    assert_eq!(
+        required.as_ref(),
+        Some(&vec!["target".to_string(), "items".to_string()])
+    );
+
+    let wait_agent = find_tool(&tools, "wait_agent");
+    let ToolSpec::Function(ResponsesApiTool {
+        parameters,
+        output_schema,
+        ..
+    }) = &wait_agent.spec
     else {
         panic!("wait_agent should be a function tool");
     };
-    let output_schema = wait_agent
-        .output_schema
+    let JsonSchema::Object {
+        properties,
+        required,
+        ..
+    } = parameters
+    else {
+        panic!("wait_agent should use object params");
+    };
+    assert!(properties.contains_key("targets"));
+    assert_eq!(required.as_ref(), Some(&vec!["targets".to_string()]));
+    let output_schema = output_schema
         .as_ref()
         .expect("wait_agent should define output schema");
-    assert!(!properties.contains_key("targets"));
-    assert!(properties.contains_key("timeout_ms"));
-    assert_eq!(required, &None);
     assert_eq!(
         output_schema["properties"]["message"]["description"],
         json!("Brief wait summary without the agent's final content.")
     );
 
-    let list_agents = find_namespaced_tool(&tools, "agents", "list_agents");
+    let list_agents = find_tool(&tools, "list_agents");
+    let ToolSpec::Function(ResponsesApiTool {
+        parameters,
+        output_schema,
+        ..
+    }) = &list_agents.spec
+    else {
+        panic!("list_agents should be a function tool");
+    };
     let JsonSchema::Object {
         properties,
         required,
         ..
-    } = &list_agents.parameters
+    } = parameters
     else {
-        panic!("list_agents should be a function tool");
+        panic!("list_agents should use object params");
     };
-    let output_schema = list_agents
-        .output_schema
-        .as_ref()
-        .expect("list_agents should define output schema");
     assert!(properties.contains_key("path_prefix"));
     assert_eq!(required.as_ref(), None);
+    let output_schema = output_schema
+        .as_ref()
+        .expect("list_agents should define output schema");
     assert_eq!(
         output_schema["properties"]["agents"]["items"]["required"],
         json!(["agent_name", "agent_status", "last_task_message"])
@@ -639,7 +754,16 @@ fn test_build_specs_enable_fanout_enables_agent_jobs_and_collab_tools() {
         &[],
     )
     .build();
-    assert_contains_tool_names(&tools, &["agents", "spawn_agents_on_csv"]);
+    assert_contains_tool_names(
+        &tools,
+        &[
+            "spawn_agent",
+            "send_input",
+            "wait_agent",
+            "close_agent",
+            "spawn_agents_on_csv",
+        ],
+    );
 }
 
 #[test]
@@ -748,7 +872,15 @@ fn test_build_specs_agent_job_worker_tools_enabled() {
     .build();
     assert_contains_tool_names(
         &tools,
-        &["agents", "spawn_agents_on_csv", "report_agent_job_result"],
+        &[
+            "spawn_agent",
+            "send_input",
+            "resume_agent",
+            "wait_agent",
+            "close_agent",
+            "spawn_agents_on_csv",
+            "report_agent_job_result",
+        ],
     );
     assert_lacks_tool_name(&tools, "request_user_input");
 }
@@ -1059,6 +1191,21 @@ fn image_generation_tools_require_feature_and_supported_model() {
     );
 }
 
+#[test]
+fn js_repl_freeform_grammar_blocks_common_non_js_prefixes() {
+    let ToolSpec::Freeform(FreeformTool { format, .. }) = create_js_repl_tool() else {
+        panic!("js_repl should use a freeform tool spec");
+    };
+
+    assert_eq!(format.syntax, "lark");
+    assert!(format.definition.contains("PRAGMA_LINE"));
+    assert!(format.definition.contains("`[^`]"));
+    assert!(format.definition.contains("``[^`]"));
+    assert!(format.definition.contains("PLAIN_JS_SOURCE"));
+    assert!(format.definition.contains("codex-js-repl:"));
+    assert!(!format.definition.contains("(?!"));
+}
+
 fn assert_model_tools(
     model_slug: &str,
     features: &Features,
@@ -1368,10 +1515,15 @@ fn test_build_specs_gpt5_codex_default() {
         &[
             "update_plan",
             "request_user_input",
+            "tool_search",
             "apply_patch",
             "web_search",
             "view_image",
-            "agents",
+            "spawn_agent",
+            "send_input",
+            "resume_agent",
+            "wait_agent",
+            "close_agent",
         ],
     );
 }
@@ -1387,10 +1539,15 @@ fn test_build_specs_gpt51_codex_default() {
         &[
             "update_plan",
             "request_user_input",
+            "tool_search",
             "apply_patch",
             "web_search",
             "view_image",
-            "agents",
+            "spawn_agent",
+            "send_input",
+            "resume_agent",
+            "wait_agent",
+            "close_agent",
         ],
     );
 }
@@ -1408,10 +1565,15 @@ fn test_build_specs_gpt5_codex_unified_exec_web_search() {
             "write_stdin",
             "update_plan",
             "request_user_input",
+            "tool_search",
             "apply_patch",
             "web_search",
             "view_image",
-            "agents",
+            "spawn_agent",
+            "send_input",
+            "resume_agent",
+            "wait_agent",
+            "close_agent",
         ],
     );
 }
@@ -1429,10 +1591,15 @@ fn test_build_specs_gpt51_codex_unified_exec_web_search() {
             "write_stdin",
             "update_plan",
             "request_user_input",
+            "tool_search",
             "apply_patch",
             "web_search",
             "view_image",
-            "agents",
+            "spawn_agent",
+            "send_input",
+            "resume_agent",
+            "wait_agent",
+            "close_agent",
         ],
     );
 }
@@ -1448,10 +1615,15 @@ fn test_gpt_5_1_codex_max_defaults() {
         &[
             "update_plan",
             "request_user_input",
+            "tool_search",
             "apply_patch",
             "web_search",
             "view_image",
-            "agents",
+            "spawn_agent",
+            "send_input",
+            "resume_agent",
+            "wait_agent",
+            "close_agent",
         ],
     );
 }
@@ -1467,10 +1639,15 @@ fn test_codex_5_1_mini_defaults() {
         &[
             "update_plan",
             "request_user_input",
+            "tool_search",
             "apply_patch",
             "web_search",
             "view_image",
-            "agents",
+            "spawn_agent",
+            "send_input",
+            "resume_agent",
+            "wait_agent",
+            "close_agent",
         ],
     );
 }
@@ -1486,9 +1663,14 @@ fn test_gpt_5_defaults() {
         &[
             "update_plan",
             "request_user_input",
+            "tool_search",
             "web_search",
             "view_image",
-            "agents",
+            "spawn_agent",
+            "send_input",
+            "resume_agent",
+            "wait_agent",
+            "close_agent",
         ],
     );
 }
@@ -1504,10 +1686,15 @@ fn test_gpt_5_1_defaults() {
         &[
             "update_plan",
             "request_user_input",
+            "tool_search",
             "apply_patch",
             "web_search",
             "view_image",
-            "agents",
+            "spawn_agent",
+            "send_input",
+            "resume_agent",
+            "wait_agent",
+            "close_agent",
         ],
     );
 }
@@ -1528,7 +1715,11 @@ fn test_gpt_5_1_codex_max_unified_exec_web_search() {
             "apply_patch",
             "web_search",
             "view_image",
-            "agents",
+            "spawn_agent",
+            "send_input",
+            "resume_agent",
+            "wait_agent",
+            "close_agent",
         ],
     );
 }
diff --git a/codex-rs/core/subagent_watchdog_prompt.md b/codex-rs/core/subagent_watchdog_prompt.md
index 070aa8ea54..cae2a4cf3d 100644
--- a/codex-rs/core/subagent_watchdog_prompt.md
+++ b/codex-rs/core/subagent_watchdog_prompt.md
@@ -1,7 +1,10 @@
 ## Watchdog-only Guidance
 
-If you are acting as a watchdog check-in agent, `compact_parent_context` may be available.
+If you are acting as a watchdog check-in agent, the deferred `watchdog` namespace may be available
+through `tool_search`.
 
-- Use `compact_parent_context` only when the parent thread is idle and appears stuck.
-- `compact_parent_context` is not part of the general subagent tool surface; do not mention or rely on it unless you are explicitly operating as a watchdog check-in agent.
-- `watchdog_self_close` is also available to this watchdog thread and can be used to end the check-in when work is complete.
+- Use `watchdog.compact_parent_context` only when the parent thread is idle and appears stuck.
+- `watchdog.compact_parent_context` is not part of the general subagent tool surface; do not
+  mention or rely on it unless you are explicitly operating as a watchdog check-in agent.
+- `watchdog.watchdog_self_close` is also available to this watchdog thread and can be used to end
+  the check-in when work is complete.
diff --git a/codex-rs/core/watchdog_agent_prompt.md b/codex-rs/core/watchdog_agent_prompt.md
index a6fd810e94..127558ef63 100644
--- a/codex-rs/core/watchdog_agent_prompt.md
+++ b/codex-rs/core/watchdog_agent_prompt.md
@@ -54,12 +54,13 @@ Use only the multi-agent tools that exist here:
 
 - `spawn_agent` (prefer `fork_context = true` when shared context matters).
 - `send_input`.
-- `compact_parent_context` (watchdog-only recovery tool; see below).
-- `watchdog_self_close` (watchdog-only immediate exit tool; see below).
+- `tool_search` to discover deferred watchdog-only tools in the `watchdog` namespace.
+- `watchdog.compact_parent_context` (watchdog-only recovery tool; see below).
+- `watchdog.watchdog_self_close` (watchdog-only immediate exit tool; see below).
 - `wait`.
 - `close_agent`.
 
-There is no cancel tool. Use `watchdog_self_close` to stop this watchdog check-in thread when its job is complete; use `close_agent` to stop subagents that are done or no longer needed.
+There is no cancel tool. Use `watchdog.watchdog_self_close` to stop this watchdog check-in thread when its job is complete; use `close_agent` to stop subagents that are done or no longer needed.
 
 When recommending watchdogs to the root agent, keep `agent_type` at the default.
 
@@ -73,7 +74,7 @@ For token protocols (for example `ping N` / `pong N`), treat those as literal te
 
 ## Parent Recovery via Context Compaction
 
-`compact_parent_context` asks the system to abbreviate/compact redundant parent-thread context so the parent can recover from loops.
+`watchdog.compact_parent_context` asks the system to abbreviate/compact redundant parent-thread context so the parent can recover from loops.
 
 Use it only as a last resort:
 
@@ -81,9 +82,9 @@ Use it only as a last resort:
 - The parent is taking no meaningful actions (no concrete commands/edits/tests) and making no progress.
 - You already sent at least one direct corrective instruction with `send_input`, and it was ignored.
 
-`watchdog_self_close` asks the runtime to end the current watchdog check-in thread immediately. Use it only after reporting status and when the check-in has no remaining work, to avoid idle watchdog loops.
+`watchdog.watchdog_self_close` asks the runtime to end the current watchdog check-in thread immediately. Use it only after reporting status and when the check-in has no remaining work, to avoid idle watchdog loops.
 
-Do not call `compact_parent_context` for routine nudges or normal delays. Prefer precise `send_input` guidance first.
+Do not call `watchdog.compact_parent_context` for routine nudges or normal delays. Prefer precise `send_input` guidance first.
 
 ## Style
 
diff --git a/codex-rs/tools/src/tool_spec_tests.rs b/codex-rs/tools/src/tool_spec_tests.rs
index b68bde60c0..98f4b90869 100644
--- a/codex-rs/tools/src/tool_spec_tests.rs
+++ b/codex-rs/tools/src/tool_spec_tests.rs
@@ -9,6 +9,7 @@ use crate::JsonSchema;
 use crate::ResponsesApiNamespace;
 use crate::ResponsesApiTool;
 use crate::create_tools_json_for_responses_api;
+use crate::create_watchdog_self_close_tool;
 use codex_protocol::config_types::WebSearchContextSize;
 use codex_protocol::config_types::WebSearchFilters as ConfigWebSearchFilters;
 use codex_protocol::config_types::WebSearchUserLocation as ConfigWebSearchUserLocation;
@@ -123,6 +124,32 @@ fn configured_tool_spec_name_delegates_to_tool_spec() {
     );
 }
 
+#[test]
+fn watchdog_self_close_tool_spec_is_deferred_and_parameterless() {
+    let ToolSpec::Function(ResponsesApiTool {
+        name,
+        defer_loading,
+        parameters,
+        output_schema,
+        ..
+    }) = create_watchdog_self_close_tool()
+    else {
+        panic!("watchdog_self_close should be a function tool");
+    };
+
+    assert_eq!(name, "watchdog_self_close");
+    assert_eq!(defer_loading, Some(true));
+    assert_eq!(
+        parameters,
+        JsonSchema::Object {
+            properties: BTreeMap::new(),
+            required: None,
+            additional_properties: Some(AdditionalProperties::Boolean(false)),
+        }
+    );
+    assert!(output_schema.is_some());
+}
+
 #[test]
 fn web_search_config_converts_to_responses_api_types() {
     assert_eq!(