fix(cortex-cli): address validation feedback from PR review

- Fix clippy::bind_instead_of_map in debug_cmd/handlers/config.rs
  by replacing and_then() with map() since closure always returns Some()

- Fix duplicate error output in alias_cmd.rs and plugin_cmd.rs
  by using std::process::exit(1) after JSON error output instead of bail!()
  to avoid duplicating error message to stderr

- Replace raw .unwrap() calls with safer patterns in dag_cmd/helpers.rs
  using if-let guards and Option::and_then() instead of panicking

- Improve is_read_only_command() in exec_cmd/autonomy.rs to use
  exact word matching instead of prefix matching to prevent false
  positives (e.g., 'catfile' no longer matches 'cat')

Author: echobt

src/cortex-cli/src/alias_cmd.rs

@@ -249,6 +249,8 @@ async fn run_show(args: AliasShowArgs) -> Result<()> {
                     "error": format!("Alias '{}' does not exist", args.name)
                 });
                 println!("{}", serde_json::to_string_pretty(&error)?);
+                // Exit with error code but don't duplicate error message via bail!()
+                std::process::exit(1);
             }
             bail!("Alias '{}' does not exist.", args.name);
         }

src/cortex-cli/src/dag_cmd/helpers.rs

@@ -78,8 +78,9 @@ pub fn convert_specs(input: &DagSpecInput) -> Vec<TaskSpec> {
 pub fn print_dag_summary(dag: &TaskDag) {
     println!("Tasks:");
     for task in dag.all_tasks() {
-        let deps = dag
-            .get_dependencies(task.id.unwrap())
+        let deps = task
+            .id
+            .and_then(|id| dag.get_dependencies(id))
             .map(|d| d.len())
             .unwrap_or(0);
         let dep_str = if deps > 0 {
@@ -130,7 +131,7 @@ pub fn print_execution_summary(stats: &DagExecutionStats, format: DagOutputForma
                 "skipped": stats.skipped_tasks,
                 "duration_secs": stats.total_duration.as_secs_f64()
             });
-            println!("{}", serde_json::to_string_pretty(&output).unwrap());
+            println!("{}", serde_json::to_string_pretty(&output).expect("JSON serialization should not fail for DagExecutionStats"));
         }
         DagOutputFormat::Compact => {
             println!(
@@ -181,7 +182,7 @@ pub fn print_ascii_graph(dag: &TaskDag, spec: &DagSpecInput) {
         for task_id in tasks_at_depth {
             if let Some(task) = dag.get_task(*task_id) {
                 let deps = dag.get_dependencies(*task_id);
-                let arrow = if deps.map(|d| !d.is_empty()).unwrap_or(false) {
+                let arrow = if deps.is_some_and(|d| !d.is_empty()) {
                     "└─► "
                 } else {
                     "● "
@@ -206,7 +207,7 @@ pub fn print_dot_graph(dag: &TaskDag, spec: &DagSpecInput) {
     println!();
 
     for task in dag.all_tasks() {
-        let task_id = task.id.unwrap();
+        let Some(task_id) = task.id else { continue };
         let color = match task.status {
             TaskStatus::Completed => "green",
             TaskStatus::Failed => "red",
@@ -225,7 +226,7 @@ pub fn print_dot_graph(dag: &TaskDag, spec: &DagSpecInput) {
     println!();
 
     for task in dag.all_tasks() {
-        let task_id = task.id.unwrap();
+        let Some(task_id) = task.id else { continue };
         if let Some(deps) = dag.get_dependencies(task_id) {
             for dep_id in deps {
                 println!("  \"{}\" -> \"{}\";", dep_id.inner(), task_id.inner());
@@ -245,14 +246,14 @@ pub fn print_mermaid_graph(dag: &TaskDag, spec: &DagSpecInput) {
     // Create task ID to safe name mapping
     let mut id_to_name: HashMap<TaskId, String> = HashMap::new();
     for task in dag.all_tasks() {
-        let task_id = task.id.unwrap();
+        let Some(task_id) = task.id else { continue };
         let safe_name = task.name.replace([' ', '-'], "_");
         id_to_name.insert(task_id, safe_name.clone());
         println!("    {}[{}]", safe_name, task.name);
     }
 
     for task in dag.all_tasks() {
-        let task_id = task.id.unwrap();
+        let Some(task_id) = task.id else { continue };
         if let Some(deps) = dag.get_dependencies(task_id) {
             for dep_id in deps {
                 if let (Some(from), Some(to)) = (id_to_name.get(dep_id), id_to_name.get(&task_id)) {

src/cortex-cli/src/debug_cmd/handlers/config.rs

@@ -33,15 +33,15 @@ pub async fn run_config(args: ConfigArgs) -> Result<()> {
         global_config_toml // Default to .toml path for display
     };
 
-    let local_config = std::env::current_dir().ok().and_then(|d| {
+    let local_config = std::env::current_dir().ok().map(|d| {
         let local_toml = d.join(".cortex/config.toml");
         let local_json = d.join(".cortex/config.json");
         if local_toml.exists() {
-            Some(local_toml)
+            local_toml
         } else if local_json.exists() {
-            Some(local_json)
+            local_json
         } else {
-            Some(local_toml) // Default to .toml path for display
+            local_toml // Default to .toml path for display
         }
     });
 

src/cortex-cli/src/exec_cmd/autonomy.rs

@@ -90,34 +90,31 @@ impl AutonomyLevel {
 
 /// Check if a command is read-only (safe for read-only mode).
 pub fn is_read_only_command(cmd: &str) -> bool {
-    let read_only_patterns = [
-        "cat",
-        "less",
-        "head",
-        "tail",
-        "ls",
-        "pwd",
-        "echo",
-        "whoami",
-        "date",
-        "uname",
-        "ps",
-        "top",
-        "git status",
-        "git log",
-        "git diff",
-        "git branch",
-        "find",
-        "grep",
-        "rg",
-        "fd",
-        "tree",
-        "wc",
-        "file",
+    let read_only_commands = [
+        "cat", "less", "head", "tail", "ls", "pwd", "echo", "whoami", "date", "uname", "ps", "top",
+        "find", "grep", "rg", "fd", "tree", "wc", "file",
     ];
+    let read_only_git_subcommands = ["git status", "git log", "git diff", "git branch"];
 
     let cmd_lower = cmd.to_lowercase();
-    read_only_patterns.iter().any(|p| cmd_lower.starts_with(p))
+
+    // Check git subcommands first (they contain spaces)
+    if read_only_git_subcommands
+        .iter()
+        .any(|p| cmd_lower.starts_with(p))
+    {
+        return true;
+    }
+
+    // Extract the first word (the command itself) for exact matching
+    let first_word = cmd_lower.split_whitespace().next().unwrap_or("");
+
+    // Also check for absolute paths (e.g., /bin/cat, /usr/bin/ls)
+    let command_name = first_word.rsplit('/').next().unwrap_or(first_word);
+
+    read_only_commands
+        .iter()
+        .any(|p| command_name == *p || first_word == *p)
 }
 
 #[cfg(test)]
@@ -146,12 +143,25 @@ mod tests {
 
     #[test]
     fn test_is_read_only_command() {
+        // Basic read-only commands
         assert!(is_read_only_command("cat file.txt"));
         assert!(is_read_only_command("ls -la"));
         assert!(is_read_only_command("git status"));
         assert!(is_read_only_command("git log --oneline"));
+        assert!(is_read_only_command("pwd"));
+        assert!(is_read_only_command("echo hello"));
+        assert!(is_read_only_command("/bin/cat file.txt"));
+        assert!(is_read_only_command("/usr/bin/ls -la"));
+
+        // Non-read-only commands
         assert!(!is_read_only_command("rm -rf /"));
         assert!(!is_read_only_command("git push"));
+
+        // Ensure prefix matching doesn't cause false positives (Issue #3820)
+        assert!(!is_read_only_command("catfile")); // Not "cat file"
+        assert!(!is_read_only_command("lsmod")); // Not "ls mod"
+        assert!(!is_read_only_command("datestamp")); // Not "date stamp"
+        assert!(!is_read_only_command("categorical-analysis")); // Not "cat"
     }
 
     #[test]

src/cortex-cli/src/plugin_cmd.rs

@@ -409,6 +409,8 @@ async fn run_show(args: PluginShowArgs) -> Result<()> {
                 "error": format!("Plugin '{}' is not installed", args.name)
             });
             println!("{}", serde_json::to_string_pretty(&error)?);
+            // Exit with error code but don't duplicate error message via bail!()
+            std::process::exit(1);
         }
         bail!("Plugin '{}' is not installed.", args.name);
     }