Prompt before trusting local project directories

codex-rs/config/src/loader/mod.rs

@@ -293,7 +293,6 @@ pub async fn load_config_layers_state(
     }
 
     let mut startup_warnings = None;
-    let mut project_root = None;
     if let Some(cwd) = cwd {
         let mut merged_so_far = TomlValue::Table(toml::map::Map::new());
         for layer in &layers {
@@ -351,7 +350,6 @@ pub async fn load_config_layers_state(
             strict_config,
         )
         .await?;
-        project_root = Some(project_trust_context.project_root.clone());
         layers.extend(project_layers.layers);
         startup_warnings = Some(project_layers.startup_warnings);
     }
@@ -434,7 +432,6 @@ pub async fn load_config_layers_state(
         config_requirements_toml.clone().try_into()?,
         config_requirements_toml.into_toml(),
     )?
-    .with_project_root(project_root)
     .with_user_and_project_exec_policy_rules_ignored(ignore_user_and_project_exec_policy_rules);
     Ok(match startup_warnings {
         Some(startup_warnings) => config_layer_stack.with_startup_warnings(startup_warnings),

codex-rs/config/src/state.rs

@@ -256,9 +256,6 @@ pub struct ConfigLayerStack {
     /// `None` means the loader did not check for stack-level warnings, while
     /// `Some(vec![])` means it checked and found nothing to report.
     startup_warnings: Option<Vec<String>>,
-
-    /// Project root resolved from the non-project config layers.
-    project_root: Option<AbsolutePathBuf>,
 }
 
 impl ConfigLayerStack {
@@ -275,21 +272,9 @@ impl ConfigLayerStack {
             requirements_toml,
             ignore_user_and_project_exec_policy_rules: false,
             startup_warnings: None,
-            project_root: None,
         })
     }
 
-    /// Records the project root resolved while loading this stack.
-    pub fn with_project_root(mut self, project_root: Option<AbsolutePathBuf>) -> Self {
-        self.project_root = project_root;
-        self
-    }
-
-    /// Returns the project root resolved from the non-project layers.
-    pub fn project_root(&self) -> Option<&AbsolutePathBuf> {
-        self.project_root.as_ref()
-    }
-
     pub fn with_user_and_project_exec_policy_rules_ignored(
         mut self,
         ignore_user_and_project_exec_policy_rules: bool,
@@ -416,7 +401,6 @@ impl ConfigLayerStack {
             ignore_user_and_project_exec_policy_rules: self
                 .ignore_user_and_project_exec_policy_rules,
             startup_warnings: self.startup_warnings.clone(),
-            project_root: self.project_root.clone(),
         })
     }
 
@@ -451,7 +435,6 @@ impl ConfigLayerStack {
             ignore_user_and_project_exec_policy_rules: self
                 .ignore_user_and_project_exec_policy_rules,
             startup_warnings: self.startup_warnings.clone(),
-            project_root: self.project_root.clone(),
         }
     }
 

codex-rs/core/src/agent/role.rs

@@ -219,8 +219,7 @@ mod reload {
             layers,
             config.config_layer_stack.requirements().clone(),
             config.config_layer_stack.requirements_toml().clone(),
-        )?
-        .with_project_root(config.config_layer_stack.project_root().cloned()))
+        )?)
     }
 
     fn deserialize_effective_config(

codex-rs/core/src/agent/role_tests.rs

@@ -159,7 +159,6 @@ async fn apply_role_preserves_unspecified_keys() {
         TomlValue::String("base-model".to_string()),
     )])
     .await;
-    let project_root = config.config_layer_stack.project_root().cloned();
     config.codex_linux_sandbox_exe = Some(PathBuf::from("/tmp/codex-linux-sandbox"));
     config.main_execve_wrapper_exe = Some(PathBuf::from("/tmp/codex-execve-wrapper"));
     let role_path = write_role_config(
@@ -188,10 +187,6 @@ async fn apply_role_preserves_unspecified_keys() {
         (config.model.as_deref(), config.model_reasoning_effort),
         (Some("spawn-model"), Some(ReasoningEffort::Low)),
     );
-    assert_eq!(
-        config.config_layer_stack.project_root(),
-        project_root.as_ref()
-    );
     assert_eq!(
         config.codex_linux_sandbox_exe,
         Some(PathBuf::from("/tmp/codex-linux-sandbox"))

codex-rs/core/src/config/config_tests.rs

@@ -9642,41 +9642,6 @@ async fn active_project_does_not_match_configured_alias_for_canonical_cwd() -> a
     Ok(())
 }
 
-#[tokio::test]
-async fn active_project_honors_custom_project_root_markers() -> anyhow::Result<()> {
-    let codex_home = TempDir::new()?;
-    let project_root = codex_home.path().join("project");
-    let nested = project_root.join("nested");
-    std::fs::create_dir_all(&nested)?;
-    std::fs::write(project_root.join(".hg"), "")?;
-    let project_key = project_root.display().to_string().replace('\\', "\\\\");
-    std::fs::write(
-        codex_home.path().join(CONFIG_TOML_FILE),
-        format!(
-            r#"project_root_markers = [".hg"]
-
-[projects."{project_key}"]
-trust_level = "untrusted"
-"#,
-        ),
-    )?;
-
-    let config = ConfigBuilder::without_managed_config_for_tests()
-        .codex_home(codex_home.path().to_path_buf())
-        .harness_overrides(ConfigOverrides {
-            cwd: Some(nested),
-            ..Default::default()
-        })
-        .build()
-        .await?;
-
-    assert_eq!(
-        config.active_project.trust_level,
-        Some(TrustLevel::Untrusted)
-    );
-    Ok(())
-}
-
 #[test]
 fn test_set_default_oss_provider() -> std::io::Result<()> {
     let temp_dir = TempDir::new()?;
@@ -10621,10 +10586,6 @@ save_fields_resolved_from_model_catalog = false
 #[tokio::test]
 async fn debug_config_lockfile_load_path_loads_lock_from_nested_table() -> std::io::Result<()> {
     let codex_home = TempDir::new()?;
-    let project_root = codex_home.path().join("project");
-    let nested = project_root.join("nested");
-    std::fs::create_dir_all(&nested)?;
-    std::fs::write(project_root.join(".hg"), "")?;
     let lock_path = codex_home.path().join("session.config.lock.toml");
     std::fs::write(
         &lock_path,
@@ -10640,9 +10601,7 @@ codex_version = "older-version"
     std::fs::write(
         codex_home.path().join(CONFIG_TOML_FILE),
         format!(
-            r#"project_root_markers = [".hg"]
-
-[debug.config_lockfile]
+            r#"[debug.config_lockfile]
 load_path = '{}'
 allow_codex_version_mismatch = true
 save_fields_resolved_from_model_catalog = false
@@ -10653,14 +10612,10 @@ save_fields_resolved_from_model_catalog = false
 
     let config = ConfigBuilder::without_managed_config_for_tests()
         .codex_home(codex_home.path().to_path_buf())
-        .fallback_cwd(Some(nested))
+        .fallback_cwd(Some(codex_home.path().to_path_buf()))
         .build()
         .await?;
 
-    assert_eq!(
-        config.config_layer_stack.project_root(),
-        Some(&project_root.abs())
-    );
     assert!(config.config_lock_toml.is_some());
     assert!(config.config_lock_allow_codex_version_mismatch);
     assert!(!config.config_lock_save_fields_resolved_from_model_catalog);

codex-rs/core/src/config/mod.rs

@@ -1488,8 +1488,7 @@ impl ConfigBuilder {
                 vec![lock_layer],
                 config_layer_stack.requirements().clone(),
                 config_layer_stack.requirements_toml().clone(),
-            )?
-            .with_project_root(config_layer_stack.project_root().cloned());
+            )?;
             let mut config = Config::load_config_with_layer_stack(
                 LOCAL_FS.as_ref(),
                 lock_config_toml,
@@ -1799,7 +1798,6 @@ impl Config {
                 .requirements_toml()
                 .clone(),
         )?
-        .with_project_root(refreshed_config.config_layer_stack.project_root().cloned())
         .with_user_and_project_exec_policy_rules_ignored(
             refreshed_config
                 .config_layer_stack
@@ -3348,21 +3346,12 @@ impl Config {
             .into_iter()
             .map(|path| AbsolutePathBuf::resolve_path_against_base(path, resolved_cwd.as_path()))
             .collect();
-        let project_root = config_layer_stack
-            .project_root()
-            .cloned()
-            .unwrap_or_else(|| resolved_cwd.clone());
         let repo_root = resolve_root_git_project_for_trust(fs, &resolved_cwd).await;
         let active_project = cfg
             .get_active_project(
                 resolved_cwd.as_path(),
-                Some(project_root.as_path()),
+                repo_root.as_ref().map(AbsolutePathBuf::as_path),
             )
-            .or_else(|| {
-                repo_root.as_ref().and_then(|repo_root| {
-                    cfg.get_active_project(repo_root.as_path(), /*repo_root*/ None)
-                })
-            })
             .unwrap_or(ProjectConfig { trust_level: None });
         let permission_config_syntax = resolve_permission_config_syntax(
             &config_layer_stack,