feat(ck-core): add CK_INDEX_DIR to relocate index directories out of the source tree

By default ck stores each search root's index in an in-tree `.ck/` directory.
That is convenient but not always wanted: it clutters repositories, can't be
shared between multiple checkouts of the same tree, and is awkward to cache in
CI. When `CK_INDEX_DIR` is set, the index for a search root instead lives at
`$CK_INDEX_DIR/<basename>-<hash>`, where `<hash>` is the first 8 hex characters
of the blake3 hash of the root's absolute path so two roots that share a
basename never collide. Unset preserves the existing `<root>/.ck` behavior
exactly.

Introduce two documented helpers in ck-core: `index_dir(root)` returns the
index/sidecar directory for a search root and `index_exists(root)` reports
whether it exists. Both the relocation base and the root are absolutized, so the
returned path is independent of the current directory (a relative CK_INDEX_DIR
is anchored at the launch directory rather than resolved per-process). The
environment variable is read on every call (an empty value is treated as unset)
and never panics. Every call site that computed `<root>/.ck` — across ck-index,
ck-engine, ck-cli, ck-tui, and ck-core's own sidecar and PDF content-cache
paths, including the walk-ups that probe for a nearby index — now routes through
these helpers. The `.ck` default-exclude pattern and sidecar file extensions are
unchanged.

Because an 8-hex hash can in principle collide, a relocated index directory
records its search root in a `root_path` marker file; indexing refuses to write
into a directory claimed by a different root, and searches refuse to serve one,
surfacing a clear error instead of silently returning another root's results.

Tests covering env-dependent paths are serialized with serial_test (already used
elsewhere in ck) and clear the variable so they exercise default behavior
deterministically.

Documented under "Index Storage" in the README.

Author: ak2k

Cargo.lock

@@ -420,6 +420,23 @@ project/
 
 The `.ck/` directory is a cache — safe to delete and rebuild anytime.
 
+#### Relocating the index (`CK_INDEX_DIR`)
+
+Set the `CK_INDEX_DIR` environment variable to keep indexes out of your source
+tree entirely. Each search root is then indexed under
+`$CK_INDEX_DIR/<basename>-<hash>`, where `<hash>` is derived from the root's
+absolute path so roots that share a name don't collide:
+
+```bash
+export CK_INDEX_DIR="$HOME/.cache/ck"
+ck --index ~/code/project     # index lives in ~/.cache/ck/project-<hash>/
+```
+
+This is handy for keeping repositories free of in-tree `.ck/` directories,
+caching indexes in CI, or sharing one index location across multiple checkouts
+of the same tree. When `CK_INDEX_DIR` is unset, indexes are stored in `.ck/` as
+above.
+
 ## 🧪 Testing
 
 ```bash

README.md

@@ -513,7 +513,7 @@ async fn run_index_workflow(
     let exclude_patterns = build_exclude_patterns(cli);
 
     if clean_first {
-        let index_dir = path.join(".ck");
+        let index_dir = ck_core::index_dir(path);
         if index_dir.exists() {
             let spinner = status.create_spinner("Removing existing index...");
             ck_index::clean_index(path)?;
@@ -978,7 +978,7 @@ async fn run_cli_mode(cli: Cli) -> Result<()> {
             .map_err(|e| anyhow::anyhow!(e.to_string()))?;
 
         if !cli.force {
-            let manifest_path = path.join(".ck").join("manifest.json");
+            let manifest_path = ck_core::index_dir(&path).join("manifest.json");
             if manifest_path.exists()
                 && let Ok(data) = std::fs::read(&manifest_path)
                 && let Ok(manifest) = serde_json::from_slice::<ck_index::IndexManifest>(&data)
@@ -1143,7 +1143,7 @@ async fn run_cli_mode(cli: Cli) -> Result<()> {
             });
 
             // Add model information if available
-            let manifest_path = status_path.join(".ck").join("manifest.json");
+            let manifest_path = ck_core::index_dir(&status_path).join("manifest.json");
             if let Ok(data) = std::fs::read(&manifest_path)
                 && let Ok(manifest) = serde_json::from_slice::<ck_index::IndexManifest>(&data)
                 && let Some(model_name) = manifest.embedding_model
@@ -1183,7 +1183,7 @@ async fn run_cli_mode(cli: Cli) -> Result<()> {
             status.info(&format!("  Total chunks: {}", stats.total_chunks));
             status.info(&format!("  Embedded chunks: {}", stats.embedded_chunks));
 
-            let manifest_path = status_path.join(".ck").join("manifest.json");
+            let manifest_path = ck_core::index_dir(&status_path).join("manifest.json");
             if let Ok(data) = std::fs::read(&manifest_path)
                 && let Ok(manifest) = serde_json::from_slice::<ck_index::IndexManifest>(&data)
                 && let Some(model_name) = manifest.embedding_model

ck-cli/src/main.rs

@@ -1650,7 +1650,7 @@ impl CkMcpServer {
         let _guard = lock.lock().await;
 
         // Check if index exists and get stats
-        let index_path = path_buf.join(".ck");
+        let index_path = ck_core::index_dir(&path_buf);
         let index_exists = index_path.exists();
 
         let mut index_info = json!({
@@ -1703,7 +1703,7 @@ impl CkMcpServer {
                 index_info["index_size_bytes"] = json!(stats.index_size_bytes);
 
                 // Add model information if available
-                let manifest_path = path_buf.join(".ck").join("manifest.json");
+                let manifest_path = ck_core::index_dir(&path_buf).join("manifest.json");
                 if let Ok(data) = std::fs::read(&manifest_path)
                     && let Ok(manifest) = serde_json::from_slice::<ck_index::IndexManifest>(&data)
                     && let Some(model_name) = manifest.embedding_model