fix(diff_impact): implement the documented default unstaged-diff behavior

get_git_diff's "neither staged nor commits" branch returned a hard error
instead of ever running plain `git diff` — so the tool's own schema
("staged: false or omitted analyzes the unstaged working-tree diff") was
never actually true. Calling diff_impact with no arguments at all (the
most natural shape — "check my current uncommitted changes") always
failed with INVALID_INPUT/FEATURE_UNAVAILABLE.

Implemented the missing branch, and relaxed diff_impact's own input
validation from "exactly one of diff/staged/commits" to "at most one"
so omitting all three reaches it instead of being rejected first.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: Your Name

crates/ci-core/src/analysis/diff_impact.rs

@@ -76,10 +76,12 @@ pub fn get_git_diff(
     } else if let Some(range) = commits {
         vec!["diff".into(), "-M".into(), range.into()]
     } else {
-        return (
-            None,
-            Some("Provide exactly one of staged=true or commits=<range>.".into()),
-        );
+        // Neither staged nor a commit range: the unstaged working-tree diff
+        // (plain `git diff`, no `--cached`) — this is the documented default
+        // for `staged=false`/omitted, but was previously unimplemented here
+        // (this branch returned a hard error instead), contradicting the
+        // tool's own schema description.
+        vec!["diff".into(), "-M".into()]
     };
 
     match run_with_timeout("git", cmd_args, project_root, timeout_secs) {

crates/ci-server/src/tools.rs

@@ -1575,6 +1575,53 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
 
+    /// Regression: `diff_impact` with all three of `diff`/`staged`/`commits`
+    /// omitted must analyze the unstaged working-tree diff (plain `git
+    /// diff`), per the tool's own schema description — `get_git_diff`'s
+    /// "neither staged nor commits" branch used to return a hard error
+    /// instead of ever running plain `git diff`, so this exact case (the
+    /// most natural call shape — "just check my current uncommitted
+    /// changes") always failed.
+    #[test]
+    fn diff_impact_with_no_params_analyzes_unstaged_working_tree_diff() {
+        fn run_git(dir: &std::path::Path, args: &[&str]) {
+            let status = std::process::Command::new("git")
+                .args(args)
+                .current_dir(dir)
+                .status()
+                .unwrap();
+            assert!(status.success(), "git {args:?} failed");
+        }
+
+        let dir =
+            std::env::temp_dir().join(format!("ci_diff_impact_unstaged_{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        run_git(&dir, &["init", "-q"]);
+        run_git(&dir, &["config", "user.email", "test@example.com"]);
+        run_git(&dir, &["config", "user.name", "Test"]);
+
+        std::fs::write(dir.join("foo.rs"), "fn foo() {}\n").unwrap();
+        run_git(&dir, &["add", "."]);
+        run_git(&dir, &["commit", "-q", "-m", "init"]);
+
+        // Uncommitted, unstaged change — not `git add`ed.
+        std::fs::write(dir.join("foo.rs"), "fn foo() {\n    1\n}\n").unwrap();
+
+        let server = CodeIntelligenceServer::new(dir.clone(), dir.join("index.db")).unwrap();
+        let output = server.diff_impact(DiffImpactParams {
+            diff: None,
+            staged: None,
+            commits: None,
+        });
+        let v: serde_json::Value = serde_json::from_str(&output).unwrap();
+
+        assert!(v.get("error").is_none(), "expected success, got error: {v}");
+        assert_eq!(v["files_changed"], serde_json::json!(["foo.rs"]));
+
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
     #[test]
     fn session_context_tracks_tool_calls_and_explored_state() {
         let dir = std::env::temp_dir().join(format!("ci_session_ctx_{}", std::process::id()));

crates/ci-server/src/tools/guardrails.rs

@@ -153,18 +153,18 @@ impl CodeIntelligenceServer {
 
     #[tool(
         name = "diff_impact",
-        description = "CALL THIS after every code change, BEFORE commit or push — never skip. USE WHEN: you have uncommitted changes and want to verify blast radius. NOT FOR: pre-edit analysis (use edit_context). vs edit_context: edit_context=pre-edit; diff_impact=post-edit. Provide exactly one of: diff, staged, commits."
+        description = "CALL THIS after every code change, BEFORE commit or push — never skip. USE WHEN: you have uncommitted changes and want to verify blast radius. NOT FOR: pre-edit analysis (use edit_context). vs edit_context: edit_context=pre-edit; diff_impact=post-edit. Omit all three for the unstaged working-tree diff, or provide at most one of: diff, staged=true, commits=<range>."
     )]
     pub(crate) fn diff_impact(&self, #[tool(aggr)] p: DiffImpactParams) -> String {
         self.timed_tool("diff_impact", || {
             self.clear_written_files();
 
             let input_count =
                 p.diff.is_some() as u8 + p.staged.is_some() as u8 + p.commits.is_some() as u8;
-            if input_count != 1 {
+            if input_count > 1 {
                 return error_json(
                     "INVALID_INPUT",
-                    "Exactly one of diff, staged, or commits must be provided",
+                    "At most one of diff, staged, or commits may be provided (omit all three for the unstaged working-tree diff)",
                     false,
                 );
             }
@@ -537,18 +537,19 @@ pub(crate) struct EditContextOutput {
 #[derive(Deserialize, JsonSchema)]
 pub(crate) struct DiffImpactParams {
     /// A raw unified diff (`git diff` output) to analyze directly, instead
-    /// of having this tool run git itself. Exactly one of `diff`, `staged`,
-    /// `commits` must be set.
+    /// of having this tool run git itself. At most one of `diff`, `staged`,
+    /// `commits` may be set — omitting all three analyzes the unstaged
+    /// working-tree diff (plain `git diff`).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub(crate) diff: Option<String>,
     /// `true` to analyze the staged diff (`git diff --cached`); `false` or
-    /// omitted analyzes the unstaged working-tree diff. Exactly one of
-    /// `diff`, `staged`, `commits` must be set.
+    /// omitted analyzes the unstaged working-tree diff. At most one of
+    /// `diff`, `staged`, `commits` may be set.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub(crate) staged: Option<bool>,
     /// A commit range/rev understood by `git diff`, e.g. `HEAD~3..HEAD` or
-    /// a single commit SHA. Exactly one of `diff`, `staged`, `commits`
-    /// must be set.
+    /// a single commit SHA. At most one of `diff`, `staged`, `commits`
+    /// may be set.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub(crate) commits: Option<String>,
 }