fix(perm): session allowlist matches absolute paths, suggest_pattern covers all tools, better dialog

HIGH fixes:
- checker.rs: resolve absolute path BEFORE is_session_allowed and
  check both raw+absolute forms. Fixes bug where AllowAlways on a
  relative path (src/main.rs) didn't match subsequent absolute-path
  calls (/Users/.../src/main.rs) to the same file.
- ui/mod.rs: add suggest_pattern arms for all 20+ previously-missing
  tools (apply_patch, semantic tools, webfetch, websearch, task,
  glob, repo_overview, etc.). These tools previously got placeholder
  pattern causing AllowAlways to silently degrade to AllowOnce.

MEDIUM fixes:
- ui/mod.rs: show path context in permission dialog. File tools now
  show 'path: src/main.rs (inside project)' instead of generic
  'args: 1'. Bash shows 'command:', MCP shows 'mcp:', etc.
- checker.rs: make resolve_absolute pub(crate) for dialog use.

LOW fix:
- checker.rs: add find_definition/find_callers to is_path_tool_name
  so their rules use path-glob semantics (matches check_perm_path).

Author: Yogthos

src/permission/checker.rs

@@ -84,6 +84,8 @@ pub(crate) fn is_path_tool_name(tool: &str) -> bool {
             // Semantic tools whose primary arg is a file path.
             | "list_symbols"
             | "get_symbol_body"
+            | "find_definition"
+            | "find_callers"
             | "find_callees"
             // #1 fix: repo_overview's arg is a directory path; user
             // rules like `"/etc/**": "deny"` need path-glob semantics
@@ -494,11 +496,17 @@ impl PermissionChecker {
             return CheckResult::Allowed;
         }
 
-        if self.is_session_allowed(tool, path) {
+        // Resolve BEFORE the allowlist check so we can test both the
+        // raw path and the absolute form. Without this, a user who
+        // granted AllowAlways for a relative path (e.g. src/main.rs)
+        // gets re-prompted when the LLM sends an absolute path for
+        // the same file.
+        let abs_path = resolve_absolute(path, &self.working_dir);
+
+        if self.is_session_allowed(tool, path) || self.is_session_allowed(tool, &abs_path) {
             return CheckResult::Allowed;
         }
 
-        let abs_path = resolve_absolute(path, &self.working_dir);
         let mut matched: Vec<(Action, String)> = Vec::new();
         if let Some(rules) = self.rules.get(tool) {
             for (pattern, action) in rules {
@@ -855,7 +863,7 @@ fn install_cwd_allow_rules(
     Some(cwd_glob)
 }
 
-fn resolve_absolute(path: &str, working_dir: &str) -> String {
+pub(crate) fn resolve_absolute(path: &str, working_dir: &str) -> String {
     let p = Path::new(path);
     let joined = if p.is_absolute() {
         p.to_path_buf()

src/ui/mod.rs

@@ -3577,20 +3577,46 @@ pub async fn run_interactive(
                     let safe_input = sanitize_output(&ask_req.input);
                     // Spacer rows are empty strings — the widget
                     // wraps + paints them as a blank row each,
-                    // giving the alert visual breathing room
-                    // between sections. Action keys use theme::perm
-                    // (amber/yellow) so the whole alert reads in
-                    // one cautionary color. The args line uses an
-                    // explicit `\x1F` (Unit Separator) sentinel as
-                    // the hanging-indent boundary so wrapped
-                    // continuations align under the value, not at
-                    // column 0. paint_overlay_box reads the
-                    // sentinel and uses a 6-space wrap indent for
-                    // that line.
+                    // effectively adding breathing room above / below
+                    // the prompt text.
                     let mut overlay: Vec<(String, Color)> = Vec::new();
                     overlay.push(("⚠ PERMISSION REQUIRED".to_string(), theme::perm()));
                     overlay.push((String::new(), theme::perm()));
                     overlay.push((format!("tool: {}", safe_tool), theme::perm()));
+
+                    // Show path context for file-operating tools
+                    // instead of the generic "args:" label.
+                    let arg_label = match ask_req.tool.as_str() {
+                        "read" | "write" | "edit" | "list_dir"
+                        | "apply_patch" | "find_files" | "glob"
+                        | "list_symbols" | "get_symbol_body"
+                        | "find_definition" | "find_callers" | "find_callees" => {
+                            let cwd = session.working_dir.as_str();
+                            let path_hint = if !cwd.is_empty() {
+                                let abs = crate::permission::checker::resolve_absolute(
+                                    &ask_req.input, cwd,
+                                );
+                                if abs.starts_with(cwd) {
+                                    " (inside project)"
+                                } else {
+                                    " (outside project)"
+                                }
+                            } else {
+                                ""
+                            };
+                            format!("path: {}{}", safe_input, path_hint)
+                        }
+                        "bash" => format!("command: {}", safe_input),
+                        "task" | "task_status" => format!("task: {}", safe_input),
+                        "webfetch" | "websearch" => format!("url: {}", safe_input),
+                        _ if ask_req.tool.starts_with("mcp_tool") => {
+                            format!("mcp: {}", safe_input)
+                        }
+                        _ => format!("args: {}", safe_input),
+                    };
+                    overlay.push((arg_label, theme::perm()));
+                    overlay.push((String::new(), theme::perm()));
+                    overlay.push((format!("tool: {}", safe_tool), theme::perm()));
                     overlay.push((format!("args: {}", safe_input), theme::perm()));
                     overlay.push((String::new(), theme::perm()));
                     overlay.push((
@@ -4753,8 +4779,39 @@ fn suggest_pattern(tool: &str, input: &str) -> String {
                 PLACEHOLDER.to_string()
             }
         }
-        // Other unknown tools (semantic, plugin) — return
-        // placeholder so the user explicitly edits before allowing.
+        // Other path-shaped tools: derive parent-dir wildcards.
+        "apply_patch" => {
+            let path = std::path::Path::new(trimmed);
+            let parent = path
+                .parent()
+                .map(|p| p.to_string_lossy())
+                .unwrap_or(std::borrow::Cow::Borrowed(""));
+            if parent.is_empty() {
+                "**".to_string()
+            } else {
+                format!("{}/**", parent)
+            }
+        }
+        // Semantic tools — file-path-shaped arguments.
+        "list_symbols" | "get_symbol_body" | "find_definition" | "find_callers"
+        | "find_callees" => {
+            let path = std::path::Path::new(trimmed);
+            let parent = path
+                .parent()
+                .map(|p| p.to_string_lossy())
+                .unwrap_or(std::borrow::Cow::Borrowed("."));
+            format!("{}/**", parent)
+        }
+        // Network tools — broad wildcard.
+        "webfetch" => "webfetch:*".to_string(),
+        "websearch" => "websearch:*".to_string(),
+        // Task / question / introspection tools — allow them entirely.
+        "task" | "task_status" | "question" => "**".to_string(),
+        "glob" | "repo_overview" | "skill" | "memory" | "write_todo_list" | "lsp" => {
+            "**".to_string()
+        }
+        // Plugin tools — allow by tool name prefix, default to **.
+        _ if tool.starts_with("mcp_tool") => PLACEHOLDER.to_string(),
         _ => PLACEHOLDER.to_string(),
     }
 }