fix(build): unify slash registry; add builtins (allow, mcp-add, todo, compact, autocompact); make hooks async-trait object-safe; adjust HookEvent PostExec usage; compact utf8 fix; config manager reload_all interior-mutability; packaging exclude list + async-trait dep

Author: takumi-earth

Cargo.toml

@@ -19,6 +19,19 @@ include = [
   "LICENSE",
   "THIRD_PARTY_NOTICES.md"
 ]
+# Fallback exclusions (in case include is ignored by tooling)
+exclude = [
+  "/external/**",
+  "/xtask/**",
+  "/.github/**",
+  "/target/**",
+  "/schemas/**",
+  "/scripts/**",
+  "/.gitmodules",
+  "/Makefile",
+  "/.codex/**",
+  "/Cargo.toml.orig"
+]
 
 [workspace]
 members = [".", "xtask"]
@@ -50,6 +63,7 @@ uuid = { version = ">=1.18.0", features = ["v4"] }
 chrono = { version = ">=0.4.41", default-features = false, features = ["clock"] }
 ratatui = ">=0.29"
 crossterm = ">=0.29"
+async-trait = "0.1"
 
 toml = ">=0.9.6"
 tracing = ">=0.1"

src/compact.rs

@@ -95,7 +95,7 @@ fn git_changed_files(repo: &Repository, root: &Path) -> BTreeSet<PathBuf> {
     // Index (staged)
     if let Ok(idx) = repo.index() {
         for e in idx.iter() {
-            if let Some(path) = std::str::from_utf8(e.path).ok() {
+            if let Some(path) = std::str::from_utf8(&e.path).ok() {
                 out.insert(root.join(path));
             }
         }

src/hooks.rs

@@ -53,7 +53,6 @@ pub struct HookRule {
 }
 fn default_true() -> bool { true }
 
-#[derive(Default)]
 pub struct HookRegistry {
     rules: Vec<HookRule>,
     depth: Arc<Mutex<usize>>,

src/layered_config.rs

@@ -278,7 +278,7 @@ impl ConfigManager {
             system_path, user_path, workspace_path,
             runtime_overlay: Arc::new(RwLock::new(Config::default())),
         };
-        let mut me = cm;
+        let me = cm;
         me.reload_all()?;
         me.start_watch()?;
         Ok(me)
@@ -290,7 +290,7 @@ impl ConfigManager {
         Some(p.0)
     }
 
-    pub fn reload_all(&mut self) -> Result<()> {
+    pub fn reload_all(&self) -> Result<()> {
         let mut merged = Config::default();
         if let Some(sys) = Self::read_file(&self.system_path) { merge(&mut merged, &sys); }
         if let Some(usr) = Self::read_file(&self.user_path) { merge(&mut merged, &usr); }

src/slash.rs

@@ -4,14 +4,19 @@ use anyhow::{anyhow, Result};
 use serde::Deserialize;
 use std::{collections::BTreeMap, fs, path::PathBuf, sync::Arc};
 
-use crate::layered_config::{Config, ConfigManager, Scope};
+use crate::{
+    layered_config::{Config, ConfigManager, Scope},
+    compact::Compactor,
+    todo::{TodoStore, TodoStatus},
+};
 
 #[derive(Clone)]
 pub struct SlashRegistry {
     aliases: BTreeMap<String, String>,
     macros: BTreeMap<String, Vec<String>>,
     builtins: BTreeMap<String, BTreeMap<String, String>>, // name -> args
     cfg: Arc<ConfigManager>,
+    workspace_root: PathBuf,
 }
 
 #[derive(Default, Deserialize)]
@@ -28,7 +33,7 @@ struct SlashTomlFile {
 struct SlashMacro { name: String, lines: Vec<String> }
 
 impl SlashRegistry {
-    pub fn load_from_dirs(cfg: Arc<ConfigManager>, dirs: &[PathBuf]) -> Result<Self> {
+    pub fn load_from_dirs_with_workspace(cfg: Arc<ConfigManager>, workspace_root: PathBuf, dirs: &[PathBuf]) -> Result<Self> {
         let mut aliases = BTreeMap::new();
         let mut macros: BTreeMap<String, Vec<String>> = BTreeMap::new();
         let mut builtins: BTreeMap<String, BTreeMap<String, String>> = BTreeMap::new();
@@ -45,7 +50,13 @@ impl SlashRegistry {
                 }
             }
         }
-        Ok(Self { aliases, macros, builtins, cfg })
+        Ok(Self { aliases, macros, builtins, cfg, workspace_root })
+    }
+
+    // Backwards-compatible helper: default workspace is current dir
+    pub fn load_from_dirs(cfg: Arc<ConfigManager>, dirs: &[PathBuf]) -> Result<Self> {
+        let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+        Self::load_from_dirs_with_workspace(cfg, cwd, dirs)
     }
 
     pub async fn dispatch(&self, input: &str) -> Result<String> {
@@ -81,187 +92,97 @@ impl SlashRegistry {
                 self.cfg.apply_runtime_overlay(patch)?;
                 Ok("runtime overlay applied".into())
             }
-            _ => Ok(format!("builtin:{} {}", name, serde_json::to_string(args)?)),
-        }
-    }
-}
-
-// annex/src/slash.rs content below
-
-use anyhow::{anyhow, Result};
-use std::{path::PathBuf, sync::Arc};
-
-use crate::{
-    layered_config::{Config, ConfigManager, Scope},
-    mcp_runtime::McpRuntime,
-    todo::{TodoStore, TodoStatus},
-    compact::{Compactor, AutoCompactStage},
-};
-
-#[derive(Clone)]
-pub struct SlashRegistry {
-    cmds: Vec<Arc<dyn SlashCommand>>,
-}
-impl SlashRegistry {
-    pub fn new() -> Self { Self { cmds: vec![] } }
-    pub fn register(&mut self, cmd: Arc<dyn SlashCommand>) { self.cmds.push(cmd); }
-    pub async fn dispatch(&self, input: &str) -> Result<String> {
-        let input = input.trim();
-        if !input.starts_with('/') { return Err(anyhow!("not a slash command")); }
-        let parts: Vec<&str> = input[1..].split_whitespace().collect();
-        if parts.is_empty() { return Err(anyhow!("empty command")); }
-        let name = parts[0];
-        for c in &self.cmds { if c.name() == name { return c.run(parts[1..].join(" ")).await; } }
-        Err(anyhow!("unknown command: {}", name))
-    }
-}
-
-#[async_trait::async_trait]
-pub trait SlashCommand: Send + Sync {
-    fn name(&self) -> &'static str;
-    async fn run(&self, args: String) -> Result<String>;
-}
-
-/*** Existing minimal commands from earlier snippet (not re-listed for brevity) ***/
-pub struct AllowCommand { pub cfg: Arc<ConfigManager> }
-#[async_trait::async_trait]
-impl SlashCommand for AllowCommand {
-    fn name(&self) -> &'static str { "allow" }
-    async fn run(&self, args: String) -> Result<String> {
-        let mut patch = Config::default();
-        patch.shell.allowlist_roots = vec![args.trim().to_string()];
-        self.cfg.write_patch(Scope::Workspace, &patch)?;
-        Ok(format!("added to allowlist (workspace): {}", args.trim()))
-    }
-}
-pub struct McpAddCommand { pub cfg: Arc<ConfigManager> }
-#[async_trait::async_trait]
-impl SlashCommand for McpAddCommand {
-    fn name(&self) -> &'static str { "mcp-add" }
-    async fn run(&self, args: String) -> Result<String> {
-        let mut patch = Config::default();
-        // Simple parser: JSON object {"name":"X","stdio":{"cmd": "...","args":["..."]}} or {"name":"X","tcp":{"host":"...","port":1234}}
-        let v: serde_json::Value = serde_json::from_str(&args)?;
-        let name = v.get("name").and_then(|x| x.as_str()).ok_or_else(|| anyhow!("missing name"))?;
-        let mut m = crate::layered_config::McpServer::default();
-        m.enabled = true;
-        if let Some(stdio) = v.get("stdio") {
-            m.transport = "stdio".into();
-            m.command = stdio.get("cmd").and_then(|x| x.as_str()).map(|s| s.into());
-            if let Some(a) = stdio.get("args").and_then(|x| x.as_array()) {
-                m.args = a.iter().filter_map(|x| x.as_str().map(|s| s.to_string())).collect();
+            "allow" => {
+                let root = argstr.trim();
+                if root.is_empty() { return Err(anyhow!("usage: /allow <root-binary>")); }
+                let mut patch = Config::default();
+                patch.shell.allowlist_roots = vec![root.to_string()];
+                self.cfg.write_patch(Scope::Workspace, &patch)?;
+                Ok(format!("added to allowlist (workspace): {}", root))
             }
-        } else if let Some(tcp) = v.get("tcp") {
-            m.transport = "tcp".into();
-            m.host = tcp.get("host").and_then(|x| x.as_str()).map(|s| s.into());
-            m.port = tcp.get("port").and_then(|x| x.as_u64()).map(|n| n as u16);
-        } else {
-            return Err(anyhow!("expect stdio or tcp"));
-        }
-        patch.mcp.servers.insert(name.into(), m);
-        self.cfg.write_patch(Scope::Workspace, &patch)?;
-        Ok("MCP server added (workspace)".into())
-    }
-}
-pub struct ConfigSetCommand { pub cfg: Arc<ConfigManager> }
-#[async_trait::async_trait]
-impl SlashCommand for ConfigSetCommand {
-    fn name(&self) -> &'static str { "config-set" }
-    async fn run(&self, args: String) -> Result<String> {
-        let parts: Vec<&str> = args.split_whitespace().collect();
-        if parts.len() < 2 { return Err(anyhow!("usage: /config-set <path> <value>")); }
-        let path = parts[0]; let value = parts[1..].join(" ");
-        let mut patch = Config::default();
-        match path {
-            "model.name" => patch.model.name = Some(value),
-            "history.persist" => patch.history.persist = Some(value),
-            "sandbox.mode" => patch.sandbox.mode = Some(value),
-            "sandbox.network_access" => patch.sandbox.network_access = Some(value.parse::<bool>()?),
-            _ => return Err(anyhow!("unsupported path: {}", path)),
-        }
-        self.cfg.apply_runtime_overlay(patch)?;
-        Ok("runtime overlay applied".into())
-    }
-}
-
-/*** NEW: TODO commands ***/
-pub struct TodoCommand { pub cfg: Arc<ConfigManager>, pub workspace: PathBuf }
-#[async_trait::async_trait]
-impl SlashCommand for TodoCommand {
-    fn name(&self) -> &'static str { "todo" }
-    async fn run(&self, args: String) -> Result<String> {
-        let cfg = self.cfg.get();
-        let path = cfg.todo.path.clone().unwrap_or(self.workspace.join(".codex").join("todo.json"));
-        let mut store = TodoStore::load(&path)?;
-        let parts: Vec<&str> = args.split_whitespace().collect();
-        match parts.get(0).map(|s| *s).unwrap_or("") {
-            "add" => {
-                // /todo add {"title":"…","description":"…","files":["path1","path2"],"tags":["x"]}
-                let v: serde_json::Value = serde_json::from_str(parts[1..].join(" ").trim())?;
-                let title = v.get("title").and_then(|x| x.as_str()).ok_or_else(|| anyhow!("title required"))?;
-                let desc = v.get("description").and_then(|x| x.as_str()).map(|s| s.to_string());
-                let files: Vec<PathBuf> = v.get("files").and_then(|x| x.as_array()).unwrap_or(&vec![])
-                    .iter().filter_map(|x| x.as_str().map(|s| self.workspace.join(s))).collect();
-                let tags: Vec<String> = v.get("tags").and_then(|x| x.as_array()).unwrap_or(&vec![])
-                    .iter().filter_map(|x| x.as_str().map(|s| s.to_string())).collect();
-                let it = store.add(title.to_string(), desc, files, tags);
-                store.save(&path)?;
-                Ok(format!("todo added: {} ({})", it.title, it.id))
+            "mcp-add" => {
+                // JSON: {"name":"X","stdio":{...}} or {"name":"X","tcp":{...}}
+                let v: serde_json::Value = serde_json::from_str(argstr)?;
+                let name = v.get("name").and_then(|x| x.as_str()).ok_or_else(|| anyhow!("missing name"))?;
+                let mut m = crate::layered_config::McpServer::default();
+                m.enabled = true;
+                if let Some(stdio) = v.get("stdio") {
+                    m.transport = "stdio".into();
+                    m.command = stdio.get("cmd").and_then(|x| x.as_str()).map(|s| s.into());
+                    if let Some(a) = stdio.get("args").and_then(|x| x.as_array()) {
+                        m.args = a.iter().filter_map(|x| x.as_str().map(|s| s.to_string())).collect();
+                    }
+                } else if let Some(tcp) = v.get("tcp") {
+                    m.transport = "tcp".into();
+                    m.host = tcp.get("host").and_then(|x| x.as_str()).map(|s| s.into());
+                    m.port = tcp.get("port").and_then(|x| x.as_u64()).map(|n| n as u16);
+                } else { return Err(anyhow!("expect stdio or tcp")); }
+                let mut patch = Config::default();
+                patch.mcp.servers.insert(name.into(), m);
+                self.cfg.write_patch(Scope::Workspace, &patch)?;
+                Ok("MCP server added (workspace)".into())
             }
-            "list" => {
-                let mut s = String::new();
-                for it in &store.items {
-                    s.push_str(&format!("- [{}] {} ({}) {:?}\n", match it.status { TodoStatus::Open=>" ", TodoStatus::InProgress=>">", TodoStatus::Done=>"x" }, it.title, it.id, it.files));
+            "todo" => {
+                // /todo add {json} | list | done <id> | rm <id>
+                let cfg = self.cfg.get();
+                let path = cfg.todo.path.clone().unwrap_or(self.workspace_root.join(".codex").join("todo.json"));
+                let mut store = TodoStore::load(&path)?;
+                let parts: Vec<&str> = argstr.split_whitespace().collect();
+                match parts.get(0).copied().unwrap_or("") {
+                    "add" => {
+                        let v: serde_json::Value = serde_json::from_str(parts[1..].join(" ").trim())?;
+                        let title = v.get("title").and_then(|x| x.as_str()).ok_or_else(|| anyhow!("title required"))?;
+                        let desc = v.get("description").and_then(|x| x.as_str()).map(|s| s.to_string());
+                        let files: Vec<PathBuf> = v.get("files").and_then(|x| x.as_array()).unwrap_or(&vec![])
+                            .iter().filter_map(|x| x.as_str().map(|s| self.workspace_root.join(s))).collect();
+                        let tags: Vec<String> = v.get("tags").and_then(|x| x.as_array()).unwrap_or(&vec![])
+                            .iter().filter_map(|x| x.as_str().map(|s| s.to_string())).collect();
+                        let it = store.add(title.to_string(), desc, files, tags);
+                        store.save(&path)?;
+                        Ok(format!("todo added: {} ({})", it.title, it.id))
+                    }
+                    "list" => {
+                        let mut s = String::new();
+                        for it in &store.items {
+                            s.push_str(&format!("- [{}] {} ({}) {:?}\n", match it.status { TodoStatus::Open=>" ", TodoStatus::InProgress=>">", TodoStatus::Done=>"x" }, it.title, it.id, it.files));
+                        }
+                        Ok(s)
+                    }
+                    "done" => {
+                        let id = parts.get(1).ok_or_else(|| anyhow!("usage: /todo done <id>"))?;
+                        store.set_status(id, TodoStatus::Done)?; store.save(&path)?;
+                        Ok(format!("todo {} marked done", id))
+                    }
+                    "rm" => {
+                        let id = parts.get(1).ok_or_else(|| anyhow!("usage: /todo rm <id>"))?;
+                        store.remove(id)?; store.save(&path)?;
+                        Ok(format!("todo {} removed", id))
+                    }
+                    _ => Err(anyhow!("usage: /todo [add|list|done|rm] …")),
                 }
-                Ok(s)
             }
-            "done" => {
-                let id = parts.get(1).ok_or_else(|| anyhow!("usage: /todo done <id>"))?;
-                store.set_status(id, TodoStatus::Done)?;
-                store.save(&path)?;
-                Ok(format!("todo {} marked done", id))
+            "compact" => {
+                // args JSON: {"focus":"…","include":["glob1"],"conversation_tail":"…"}
+                let v: serde_json::Value = serde_json::from_str(argstr.trim())?;
+                let focus = v.get("focus").and_then(|x| x.as_str()).map(|s| s.to_string());
+                let includes: Vec<String> = v.get("include").and_then(|x| x.as_array()).unwrap_or(&vec![])
+                    .iter().filter_map(|x| x.as_str().map(|s| s.to_string())).collect();
+                let tail = v.get("conversation_tail").and_then(|x| x.as_str()).unwrap_or("");
+                let comp = Compactor::new(self.cfg.clone(), self.workspace_root.clone());
+                let res = comp.manual_compact(focus, includes, tail)?;
+                Ok(serde_json::to_string_pretty(&res)?)
             }
-            "rm" => {
-                let id = parts.get(1).ok_or_else(|| anyhow!("usage: /todo rm <id>"))?;
-                store.remove(id)?;
-                store.save(&path)?;
-                Ok(format!("todo {} removed", id))
+            "autocompact" => {
+                let mut patch = Config::default();
+                match argstr.trim() {
+                    "on" => { patch.compact.auto_enable = true; }
+                    "off" => { patch.compact.auto_enable = false; }
+                    _ => return Err(anyhow!("usage: /autocompact on|off")),
+                }
+                self.cfg.apply_runtime_overlay(patch)?;
+                Ok(format!("auto-compact {}", argstr.trim()))
             }
-            _ => Err(anyhow!("usage: /todo [add|list|done|rm] …")),
-        }
-    }
-}
-
-/*** NEW: compact + autocompact ***/
-pub struct CompactCommand { pub cfg: Arc<ConfigManager>, pub workspace: PathBuf }
-#[async_trait::async_trait]
-impl SlashCommand for CompactCommand {
-    fn name(&self) -> &'static str { "compact" }
-    async fn run(&self, args: String) -> Result<String> {
-        // JSON input: {"focus":"…","include":["glob1","glob2"],"conversation_tail":"…"}
-        let v: serde_json::Value = serde_json::from_str(args.trim())?;
-        let focus = v.get("focus").and_then(|x| x.as_str()).map(|s| s.to_string());
-        let includes: Vec<String> = v.get("include").and_then(|x| x.as_array()).unwrap_or(&vec![])
-            .iter().filter_map(|x| x.as_str().map(|s| s.to_string())).collect();
-        let tail = v.get("conversation_tail").and_then(|x| x.as_str()).unwrap_or("");
-        let comp = crate::compact::Compactor::new(self.cfg.clone(), self.workspace.clone());
-        let res = comp.manual_compact(focus, includes, tail)?;
-        Ok(serde_json::to_string_pretty(&res)?)
-    }
-}
-
-pub struct AutoCompactToggle { pub cfg: Arc<ConfigManager> }
-#[async_trait::async_trait]
-impl SlashCommand for AutoCompactToggle {
-    fn name(&self) -> &'static str { "autocompact" }
-    async fn run(&self, args: String) -> Result<String> {
-        let mut patch = Config::default();
-        match args.trim() {
-            "on" => { patch.compact.auto_enable = true; }
-            "off" => { patch.compact.auto_enable = false; }
-            _ => return Err(anyhow!("usage: /autocompact on|off")),
+            _ => Ok(format!("builtin:{} {}", name, serde_json::to_string(args)?)),
         }
-        self.cfg.apply_runtime_overlay(patch)?;
-        Ok(format!("auto-compact {}", args.trim()))
     }
 }

src/taskset.rs

@@ -139,7 +139,7 @@ impl<'a> TaskSetRunner<'a> {
                 TaskStep::Exec { cmd, args } => {
                     let (status, out_preview) = (self.do_exec)(cmd, args).await?;
                     let _ = self.ui_tx.send(UiEvent::TaskProgress { set_id: set.set_id.clone(), task_id: t.id.clone(), line: format!("exec {} -> {}", cmd, status) });
-                    self.hooks.emit(&self.ctx, &HookEvent::PostExec{ cmd: cmd.clone(), argv: args.clone(), status }).await.ok();
+                    self.hooks.emit(&self.ctx, &HookEvent::PostExec{ cmd: cmd.clone(), argv: args.clone(), status, stdout_len: out_preview.len(), stderr_len: 0 }).await.ok();
                     if status != 0 { ok = false; }
                 }
                 TaskStep::McpCall { server, method, payload } => {