refactor(rename): kb crates → kebab — Cargo packages, folders, Rust modules

프로젝트 이름 `kb` → `kebab` rename 의 첫 단계.

- workspace `Cargo.toml`: members `crates/kb-*` → `crates/kebab-*`,
  repository URL `altair823/kb` → `altair823/kebab`.
- 18 crate 폴더 rename via `git mv` (history 보존).
- 각 crate `Cargo.toml`: `name = "kb-*"` → `"kebab-*"`, path deps
  `../kb-*` → `../kebab-*`.
- 모든 `.rs`: `kb_<id>` snake-case 모듈 path 18 개 (`kb_core`,
  `kb_config`, `kb_app`, `kb_cli`, `kb_eval`, `kb_search`, `kb_chunk`,
  `kb_normalize`, `kb_source_fs`, `kb_parse_md`, `kb_parse_types`,
  `kb_store_sqlite`, `kb_store_vector`, `kb_embed`, `kb_embed_local`,
  `kb_llm`, `kb_llm_local`, `kb_rag`) → `kebab_<id>` 일괄 sed (단어
  경계 \\b 사용해 영어 문장 안의 "kb" 약어 미오염).

CLI binary 이름 (`[[bin]] name = "kb"`), 환경변수 `KB_*`, XDG paths,
tracing target, 그리고 docs sweep 은 다음 commit 에서.

## 검증

- `cargo check --workspace` clean — 모든 crate 빌드 통과 후 commit.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

crates/kebab-source-fs/tests/snapshot_tree1.rs

@@ -0,0 +1,139 @@
+//! Snapshot + determinism tests against `fixtures/source-fs/tree-1`.
+//!
+//! Layout (committed under `<repo>/fixtures/source-fs/tree-1/`):
+//!
+//! ```
+//! tree-1/
+//! ├── README.md
+//! ├── notes/
+//! │   ├── alpha.md
+//! │   └── beta.md
+//! ├── ignored/
+//! │   └── skip.tmp           # excluded by .kbignore
+//! ├── .kbignore              # contains: *.tmp
+//! └── .DS_Store              # implicitly excluded
+//! ```
+//!
+//! Two assertions:
+//!   1. Snapshot stability — `scan` output (with `discovered_at` stripped)
+//!      matches the committed baseline JSON byte-for-byte.
+//!   2. Determinism — running `scan` twice produces byte-identical JSON
+//!      after stripping `discovered_at`.
+//!
+//! `discovered_at` is wall-clock and intentionally NOT part of the
+//! contract: the task spec says strip it before comparison.
+
+use std::path::PathBuf;
+
+use kebab_config::Config;
+use kebab_core::{SourceConnector, SourceScope};
+use kebab_source_fs::FsSourceConnector;
+use serde_json::Value;
+
+/// Repo root, derived from `CARGO_MANIFEST_DIR` (= `crates/kb-source-fs`).
+fn repo_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .to_path_buf()
+}
+
+fn fixture_root() -> PathBuf {
+    repo_root().join("fixtures/source-fs/tree-1")
+}
+
+fn baseline_path() -> PathBuf {
+    repo_root().join("fixtures/source-fs/tree-1.snapshot.json")
+}
+
+fn cfg_for_fixture(root: &str) -> Config {
+    let mut c = Config::defaults();
+    c.workspace.root = root.to_string();
+    // Clear default excludes (`.git/**`, `node_modules/**`, `.obsidian/**`)
+    // so the snapshot is purely a function of the fixture + .kbignore +
+    // baked-in default-excludes.
+    c.workspace.exclude.clear();
+    c
+}
+
+/// Run `scan` against the fixture and return the JSON value with every
+/// `discovered_at` field replaced by the literal string "<stripped>".
+/// Also strip `source_uri.value` and `stored.path` because they contain
+/// absolute paths that vary by checkout location — the snapshot must be
+/// portable across machines and CI checkout dirs.
+fn scan_and_strip() -> Value {
+    let root = fixture_root();
+    let cfg = cfg_for_fixture(root.to_str().unwrap());
+    let conn = FsSourceConnector::new(&cfg).expect("connector init");
+    let assets = conn
+        .scan(&SourceScope::default())
+        .expect("scan must succeed against committed fixture");
+
+    let mut v = serde_json::to_value(&assets).expect("serialize");
+    if let Value::Array(items) = &mut v {
+        for item in items {
+            if let Value::Object(map) = item {
+                map.insert(
+                    "discovered_at".to_string(),
+                    Value::String("<stripped>".to_string()),
+                );
+                // source_uri = { kind: "file", value: "<abs>" } — strip value.
+                if let Some(Value::Object(s)) = map.get_mut("source_uri") {
+                    if s.contains_key("value") {
+                        s.insert("value".to_string(), Value::String("<stripped>".to_string()));
+                    }
+                }
+                // stored = { kind: "copied"|"reference", path: "<abs>", ... } — strip path.
+                if let Some(Value::Object(s)) = map.get_mut("stored") {
+                    if s.contains_key("path") {
+                        s.insert("path".to_string(), Value::String("<stripped>".to_string()));
+                    }
+                }
+            }
+        }
+    }
+    v
+}
+
+#[test]
+fn tree_1_snapshot_matches_baseline() {
+    let actual = scan_and_strip();
+
+    // If KB_REGEN_SNAPSHOT is set, (re)write the baseline and exit
+    // *before* attempting to read it. This is the only path that may
+    // create the file from scratch.
+    if std::env::var_os("KB_REGEN_SNAPSHOT").is_some() {
+        let pretty = serde_json::to_string_pretty(&actual).unwrap() + "\n";
+        std::fs::write(baseline_path(), pretty).expect("write baseline");
+        panic!("regenerated baseline; rerun without KB_REGEN_SNAPSHOT to verify");
+    }
+
+    let baseline_text = std::fs::read_to_string(baseline_path()).unwrap_or_else(|_| {
+        panic!(
+            "missing baseline at {} — regenerate via `KB_REGEN_SNAPSHOT=1 cargo test \
+             -p kb-source-fs --test snapshot_tree1 -- tree_1_snapshot_matches_baseline`",
+            baseline_path().display()
+        )
+    });
+    let expected: Value = serde_json::from_str(&baseline_text)
+        .expect("baseline JSON must parse");
+
+    if actual != expected {
+        let actual_pretty = serde_json::to_string_pretty(&actual).unwrap();
+        let expected_pretty = serde_json::to_string_pretty(&expected).unwrap();
+        panic!(
+            "snapshot drift.\n--- expected ---\n{expected_pretty}\n--- actual ---\n{actual_pretty}\n"
+        );
+    }
+}
+
+#[test]
+fn tree_1_scan_is_deterministic() {
+    let v1 = scan_and_strip();
+    let v2 = scan_and_strip();
+    let s1 = serde_json::to_string(&v1).unwrap();
+    let s2 = serde_json::to_string(&v2).unwrap();
+    assert_eq!(s1, s2, "two consecutive scans diverged");
+}