feat(kebab-tui): P9-4 Inspect pane — doc/chunk detail with collapsible sections

Library Enter / Search 'i' 가 Inspect 진입. Doc 또는 Chunk 단일 view 로
metadata / provenance / blocks (doc) 또는 spans / text / embeddings (chunk)
6 section 을 collapsible 로 표시. Esc/q 로 originating pane 으로 복귀.

핵심:
- InspectTarget enum (`Doc(DocumentId) | Chunk(ChunkId)`).
- InspectState 본체 (`app.rs`) — target / doc / chunk / collapsed
  HashSet / scroll / return_to / needs_fetch / loading.
- `src/inspect.rs`:
  - `render_inspect` — target 종류별 render_doc / render_chunk 분기,
    section header 가 collapse marker (▾/▸) 표시. metadata.user JSON
    pretty-printed.
  - `handle_key_inspect`: j/k / Down/Up scroll. PageDown/PageUp 10 row.
    c = toggle all sections (v1 simplification). Esc/q = SwitchPane(return_to).
  - `enter_inspect(state, target, return_to)` helper — Library 와 Search
    공통 entry point.
  - run-loop hook `refresh_inspect` — needs_fetch 면 lazy
    inspect_doc_with_config / inspect_chunk_with_config.
- run.rs: Pane::Inspect arm 이 handle_key_inspect + render_inspect.
  Idle tick 마다 refresh_inspect. SwitchPane(Inspect) lazy init.
- Library: Enter 가 enter_inspect(Doc(selected)) 호출 후 SwitchPane.
- Search: 'i' (plain modifier) 가 enter_inspect(Chunk(selected_hit))
  호출 후 SwitchPane. typing 'i' (\"instance\") 와 충돌 가드.

테스트 12개 (`tests/inspect.rs`, TestBackend) — Esc 가 return_to 사용
/ q 도 동작 / j/k scroll bounds / PgUp PgDn ±10 / c 일괄 toggle / no
target hint / loading / doc view header+metadata+provenance+blocks /
collapse hides body / chunk view text+block_ids / no slot →
SwitchPane(Library) / enter_inspect helper sets fields.

Spec deviation (HOTFIXES `2026-05-02 P9-4`):
- `render_inspect<B: Backend>` generic 제거 (P9-1/2/3 와 동일).
- Search `i` 키 추가 (P9-2 spec 에 없었음, P9-4 retroactive 추가).
- `c` 일괄 collapse — spec 의 \"focus 기반 selective collapse\" 는 P+.

Docs (sync rule):
- README: TUI 행 \"4 패널\" + Quick start 코멘트.
- HANDOFF: 한 줄 요약 + Phase status (P9 3/5 → 4/5) + deviation 한 줄.
- HOTFIXES: P9-4 entry.
- tasks/p9/p9-4 status: completed.

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

crates/kebab-tui/tests/inspect.rs

@@ -0,0 +1,326 @@
+//! Unit + snapshot tests for the Inspect pane (P9-4).
+//!
+//! Tests bypass the facade fetch by hand-populating `InspectState.doc`
+//! / `state.chunk`. The fetch path itself is exercised end-to-end by
+//! manual smoke (TempDir KB).
+
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+use kebab_config::Config;
+use kebab_core::{
+    AssetId, Block, BlockId, CanonicalDocument, Chunk, ChunkId, ChunkerVersion, CommonBlock,
+    DocumentId, HeadingBlock, Inline, Lang, Metadata, ParserVersion, Provenance,
+    ProvenanceEvent, ProvenanceKind, SourceSpan, SourceType, TextBlock, TrustLevel,
+    WorkspacePath,
+};
+use kebab_tui::{
+    App, InspectState, InspectTarget, KeyOutcome, Pane, handle_key_inspect, render_inspect,
+};
+use ratatui::Terminal;
+use ratatui::backend::TestBackend;
+use ratatui::layout::Rect;
+use std::path::PathBuf;
+use time::OffsetDateTime;
+
+fn fresh_app() -> App {
+    let mut config = Config::defaults();
+    config.storage.data_dir = "/tmp/kebab-tui-inspect-tests-noop".to_string();
+    config.workspace.root = "/tmp/kebab-tui-inspect-tests-noop/workspace".to_string();
+    let mut app = App::new(config).expect("App::new");
+    app.focus = Pane::Inspect;
+    app.inspect = Some(InspectState::default());
+    app
+}
+
+fn make_doc() -> CanonicalDocument {
+    let doc_id = DocumentId("d".repeat(32));
+    let asset_id = AssetId("a".repeat(32));
+    let span1 = SourceSpan::Line { start: 1, end: 1 };
+    let span2 = SourceSpan::Line { start: 2, end: 5 };
+    let common1 = CommonBlock {
+        block_id: BlockId("b".repeat(32)),
+        heading_path: vec![],
+        source_span: span1,
+    };
+    let common2 = CommonBlock {
+        block_id: BlockId("c".repeat(32)),
+        heading_path: vec!["Top".into()],
+        source_span: span2,
+    };
+    let blocks = vec![
+        Block::Heading(HeadingBlock {
+            common: common1,
+            level: 1,
+            text: "Top".into(),
+        }),
+        Block::Paragraph(TextBlock {
+            common: common2,
+            text: "first paragraph body line.".into(),
+            inlines: vec![Inline::Text {
+                text: "first paragraph body line.".into(),
+            }],
+        }),
+    ];
+    let mut user = serde_json::Map::new();
+    user.insert("custom_key".into(), serde_json::Value::String("custom_val".into()));
+
+    CanonicalDocument {
+        doc_id,
+        source_asset_id: asset_id,
+        workspace_path: WorkspacePath::new("notes/test.md".into()).unwrap(),
+        title: "Test Doc".into(),
+        lang: Lang("en".into()),
+        blocks,
+        metadata: Metadata {
+            aliases: vec!["alias1".into()],
+            tags: vec!["tag-a".into(), "tag-b".into()],
+            created_at: OffsetDateTime::from_unix_timestamp(1_700_000_000).unwrap(),
+            updated_at: OffsetDateTime::from_unix_timestamp(1_700_000_500).unwrap(),
+            source_type: SourceType::Note,
+            trust_level: TrustLevel::Primary,
+            user_id_alias: None,
+            user,
+        },
+        provenance: Provenance {
+            events: vec![ProvenanceEvent {
+                at: OffsetDateTime::from_unix_timestamp(1_700_000_000).unwrap(),
+                agent: "kb-source-fs".into(),
+                kind: ProvenanceKind::Discovered,
+                note: None,
+            }],
+        },
+        parser_version: ParserVersion("test-parser".into()),
+        schema_version: 1,
+        doc_version: 1,
+    }
+}
+
+fn make_chunk() -> Chunk {
+    Chunk {
+        chunk_id: ChunkId("e".repeat(32)),
+        doc_id: DocumentId("d".repeat(32)),
+        block_ids: vec![BlockId("b".repeat(32)), BlockId("c".repeat(32))],
+        text: "chunk body line one.\nchunk body line two.".into(),
+        heading_path: vec!["Top".into(), "Sub".into()],
+        source_spans: vec![SourceSpan::Line { start: 1, end: 5 }],
+        token_estimate: 12,
+        chunker_version: ChunkerVersion("md-heading-v1".into()),
+        policy_hash: "deadbeefdeadbeef".into(),
+    }
+}
+
+fn render_to_string(app: &App, w: u16, h: u16) -> String {
+    let backend = TestBackend::new(w, h);
+    let mut terminal = Terminal::new(backend).unwrap();
+    terminal
+        .draw(|f| {
+            let area = Rect::new(0, 0, w, h);
+            render_inspect(f, area, app);
+        })
+        .unwrap();
+    let buffer = terminal.backend().buffer().clone();
+    (0..buffer.area.height)
+        .map(|y| {
+            (0..buffer.area.width)
+                .map(|x| buffer[(x, y)].symbol())
+                .collect::<String>()
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+#[test]
+fn esc_returns_to_recorded_pane() {
+    let mut app = fresh_app();
+    {
+        let s = app.inspect.as_mut().unwrap();
+        s.return_to = Pane::Search;
+    }
+    let outcome = handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE),
+    );
+    assert_eq!(outcome, KeyOutcome::SwitchPane(Pane::Search));
+}
+
+#[test]
+fn q_also_returns() {
+    let mut app = fresh_app();
+    let outcome = handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE),
+    );
+    assert_eq!(outcome, KeyOutcome::SwitchPane(Pane::Library));
+}
+
+#[test]
+fn j_k_scroll_within_bounds_no_panic() {
+    let mut app = fresh_app();
+    handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE),
+    );
+    assert_eq!(app.inspect.as_ref().unwrap().scroll, 1);
+    handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::Char('k'), KeyModifiers::NONE),
+    );
+    assert_eq!(app.inspect.as_ref().unwrap().scroll, 0);
+    // Underflow saturates at 0
+    handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::Char('k'), KeyModifiers::NONE),
+    );
+    assert_eq!(app.inspect.as_ref().unwrap().scroll, 0);
+}
+
+#[test]
+fn page_keys_scroll_by_ten() {
+    let mut app = fresh_app();
+    handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::PageDown, KeyModifiers::NONE),
+    );
+    assert_eq!(app.inspect.as_ref().unwrap().scroll, 10);
+    handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::PageUp, KeyModifiers::NONE),
+    );
+    assert_eq!(app.inspect.as_ref().unwrap().scroll, 0);
+}
+
+#[test]
+fn c_toggles_collapse_state() {
+    let mut app = fresh_app();
+    // First press: nothing collapsed → collapse all.
+    handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE),
+    );
+    let s = app.inspect.as_ref().unwrap();
+    assert!(!s.collapsed.is_empty(), "first c collapses all");
+    // Second press: some collapsed → expand all.
+    handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE),
+    );
+    let s = app.inspect.as_ref().unwrap();
+    assert!(s.collapsed.is_empty(), "second c expands all");
+}
+
+#[test]
+fn no_target_renders_hint_without_panic() {
+    let app = fresh_app();
+    let rendered = render_to_string(&app, 80, 20);
+    assert!(rendered.contains("Inspect"), "header visible");
+    assert!(
+        rendered.contains("no target") || rendered.contains("press Enter"),
+        "hint visible: {rendered}"
+    );
+}
+
+#[test]
+fn loading_state_renders_loading_message() {
+    let mut app = fresh_app();
+    {
+        let s = app.inspect.as_mut().unwrap();
+        s.target = Some(InspectTarget::Doc(DocumentId("d".repeat(32))));
+        s.loading = true;
+    }
+    let rendered = render_to_string(&app, 80, 10);
+    assert!(rendered.contains("loading"), "loading hint: {rendered}");
+}
+
+#[test]
+fn doc_view_renders_header_and_metadata() {
+    let mut app = fresh_app();
+    {
+        let s = app.inspect.as_mut().unwrap();
+        s.target = Some(InspectTarget::Doc(DocumentId("d".repeat(32))));
+        s.doc = Some(make_doc());
+    }
+    let rendered = render_to_string(&app, 100, 40);
+    assert!(rendered.contains("Test Doc"), "title rendered");
+    assert!(rendered.contains("notes/test.md"), "doc_path rendered");
+    assert!(rendered.contains("test-parser"), "parser_version rendered");
+    assert!(rendered.contains("metadata"), "metadata section visible");
+    assert!(rendered.contains("tag-a"), "tags rendered");
+    assert!(
+        rendered.contains("custom_key") || rendered.contains("custom_val"),
+        "user metadata pretty-printed"
+    );
+    assert!(rendered.contains("provenance"), "provenance section visible");
+    assert!(rendered.contains("kb-source-fs"), "agent rendered");
+    assert!(rendered.contains("blocks"), "blocks section visible");
+    assert!(rendered.contains("Heading L1"), "block describe rendered");
+}
+
+#[test]
+fn doc_view_collapse_hides_section_body() {
+    let mut app = fresh_app();
+    {
+        let s = app.inspect.as_mut().unwrap();
+        s.target = Some(InspectTarget::Doc(DocumentId("d".repeat(32))));
+        s.doc = Some(make_doc());
+    }
+    let pre = render_to_string(&app, 100, 30);
+    assert!(pre.contains("kb-source-fs"), "before collapse");
+    handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE),
+    );
+    let post = render_to_string(&app, 100, 30);
+    assert!(post.contains("metadata"), "section header still visible");
+    assert!(
+        !post.contains("kb-source-fs"),
+        "provenance body hidden after collapse: {post}"
+    );
+}
+
+#[test]
+fn chunk_view_renders_text_and_block_ids() {
+    let mut app = fresh_app();
+    {
+        let s = app.inspect.as_mut().unwrap();
+        s.target = Some(InspectTarget::Chunk(ChunkId("e".repeat(32))));
+        s.chunk = Some(make_chunk());
+    }
+    let rendered = render_to_string(&app, 100, 40);
+    assert!(rendered.contains("md-heading-v1"), "chunker_version rendered");
+    assert!(rendered.contains("Top / Sub"), "heading_path joined");
+    assert!(rendered.contains("Line 1-5"), "source span described");
+    assert!(rendered.contains("chunk body line one"), "text body rendered");
+    assert!(
+        rendered.contains("block_ids = 2"),
+        "block_id count rendered"
+    );
+}
+
+#[test]
+fn no_inspect_state_returns_to_library() {
+    let mut config = Config::defaults();
+    config.storage.data_dir = "/tmp/kebab-tui-inspect-tests-noop".into();
+    let mut app = App::new(config).unwrap();
+    app.focus = Pane::Inspect;
+    let outcome = handle_key_inspect(
+        &mut app,
+        KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE),
+    );
+    assert_eq!(outcome, KeyOutcome::SwitchPane(Pane::Library));
+}
+
+#[test]
+fn enter_inspect_helper_sets_target_and_marks_fetch() {
+    let mut app = fresh_app();
+    app.inspect = None; // simulate cold state
+    kebab_tui::enter_inspect(
+        &mut app,
+        InspectTarget::Doc(DocumentId("d".repeat(32))),
+        Pane::Library,
+    );
+    let s = app.inspect.as_ref().unwrap();
+    assert!(matches!(s.target, Some(InspectTarget::Doc(_))));
+    assert_eq!(s.return_to, Pane::Library);
+    assert!(s.needs_fetch);
+    assert!(s.doc.is_none());
+    let _ = PathBuf::from(""); // silence unused-import in some configs
+}