fix(cli): bare --force refuses when no configured root exists

- the pre-clear gate covers both destructive input shapes: named CLI paths must all exist, and the bare lane refuses when a persisted index exists and not one configured root does — each missing root named, then 'Error: --force would clear the index with nothing to rebuild', exit 1, index untouched
- partial-missing configured roots keep the documented partial-force semantics; fresh workspaces with no persisted index pass ungated
- deliberate wipe stays rm -rf .codanna/index; --force is a rebuild, not a wipe

Author: bartolli

src/main.rs

@@ -414,17 +414,30 @@ async fn main() {
     let index_preexisted = persistence.exists();
 
     // The force and emission-heal lanes clear the persisted index during
-    // facade creation, before CLI paths reach validation downstream; a
-    // mistyped path would destroy the index and rebuild nothing.
-    // Existence is checked here, ahead of any destructive clear.
+    // facade creation, before the rebuild sources are validated; a
+    // mistyped CLI path — or a configured root set with no surviving
+    // entry on the bare lane — would destroy the index and rebuild
+    // nothing. Existence is checked here, ahead of any destructive clear.
     if let Commands::Index { paths, force, .. } = &cli.command {
-        if (*force || emission_heal) && !paths.is_empty() {
-            let mut missing = false;
-            for path in paths.iter().filter(|p| !p.exists()) {
-                missing = true;
-                eprintln!("Error: Path does not exist: {}", path.display());
-            }
-            if missing {
+        if *force || emission_heal {
+            if !paths.is_empty() {
+                let mut missing = false;
+                for path in paths.iter().filter(|p| !p.exists()) {
+                    missing = true;
+                    eprintln!("Error: Path does not exist: {}", path.display());
+                }
+                if missing {
+                    std::process::exit(1);
+                }
+            } else if index_preexisted && !config.indexing.indexed_paths.iter().any(|p| p.exists())
+            {
+                for path in &config.indexing.indexed_paths {
+                    eprintln!(
+                        "Error: Configured path does not exist: {}",
+                        codanna::parsing::paths::render_absolute_path(path).display()
+                    );
+                }
+                eprintln!("Error: --force would clear the index with nothing to rebuild");
                 std::process::exit(1);
             }
         }

tests/cli/test_index_force_invalid_path.rs

@@ -155,6 +155,77 @@ fn force_with_missing_path_refuses_before_clearing_index() {
     );
 }
 
+#[test]
+fn force_bare_with_no_existing_roots_refuses_before_clearing_index() {
+    let temp = TempDir::new().expect("temp workspace");
+    let workspace = temp.path();
+    write_fixture(workspace);
+    write_settings(workspace);
+
+    let (exit, stdout, stderr) = run_cli(workspace, &["index", "src"]);
+    assert_eq!(
+        exit, 0,
+        "seed must succeed\nstdout:{stdout}\nstderr:{stderr}"
+    );
+
+    let meta = workspace.join(".codanna/index/index.meta");
+    assert!(meta.exists(), "seed must persist index.meta");
+    let meta_before = std::fs::read(&meta).expect("read index.meta");
+    let entries_before = index_dir_entries(workspace);
+
+    std::fs::remove_dir_all(workspace.join("src")).expect("remove registered root");
+
+    let (exit, stdout, stderr) = run_cli(workspace, &["index", "--force"]);
+    assert_ne!(
+        exit, 0,
+        "bare force with no existing configured root must fail\nstdout:{stdout}\nstderr:{stderr}"
+    );
+    assert!(
+        stderr.contains("Configured path does not exist"),
+        "refusal must name the missing configured root:\nstderr:{stderr}"
+    );
+    assert!(
+        stderr.contains("nothing to rebuild"),
+        "refusal must state the reason:\nstderr:{stderr}"
+    );
+
+    let meta_after = std::fs::read(&meta).expect("read index.meta");
+    assert_eq!(
+        meta_before, meta_after,
+        "index.meta must be byte-identical after the refused bare-force run"
+    );
+    assert_eq!(
+        entries_before,
+        index_dir_entries(workspace),
+        "index directory contents must be untouched after the refused bare-force run"
+    );
+}
+
+#[test]
+fn force_bare_with_existing_root_still_rebuilds() {
+    let temp = TempDir::new().expect("temp workspace");
+    let workspace = temp.path();
+    write_fixture(workspace);
+    write_settings(workspace);
+
+    let (exit, stdout, stderr) = run_cli(workspace, &["index", "src"]);
+    assert_eq!(
+        exit, 0,
+        "seed must succeed\nstdout:{stdout}\nstderr:{stderr}"
+    );
+
+    let (exit, stdout, stderr) = run_cli(workspace, &["index", "--force"]);
+    assert_eq!(
+        exit, 0,
+        "bare force with an existing configured root must rebuild\nstdout:{stdout}\nstderr:{stderr}"
+    );
+    let combined = format!("{stdout}{stderr}");
+    assert!(
+        combined.contains("Index saved to"),
+        "bare force rebuild must index and save:\nstdout:{stdout}\nstderr:{stderr}"
+    );
+}
+
 #[test]
 fn force_with_existing_path_still_rebuilds() {
     let temp = TempDir::new().expect("temp workspace");