Merge pull request 'docs(skill): MCP-first guidance + CLI as fallback' (#121) from docs/skill-mcp-first into main

Reviewed-on: #121

CLAUDE.md

@@ -60,7 +60,7 @@ Read the relevant task spec's deps section before adding an import. New crates i
 
 ## Wire schema v1
 
-All `--json` output carries a `schema_version` field. Current schemas: `ingest_report.v1`, `ingest_progress.v1`, `search_hit.v1`, `answer.v1`, `doctor.v1`, `reset_report.v1`, `eval_run.v1`, `eval_compare.v1`, `list_docs.v1`, `schema.v1`, `error.v1`. Schemas live in `docs/wire-schema/v1/`. The wire shape is the contract for external integrations (Claude Code skills, MCP, etc.); breaking it requires a `*.v2` major bump and parallel-running both for one phase. In `--json` mode, fatal errors emit `error.v1` to stderr as ndjson (non-`--json` mode keeps plain stderr text); exit codes 0/1/2/3 are unchanged — `error.v1.code` provides fine-grained agent branching.
+All `--json` output carries a `schema_version` field. Current schemas: `ingest_report.v1`, `ingest_progress.v1`, `search_hit.v1`, `answer.v1`, `doctor.v1`, `reset_report.v1`, `schema.v1`, `error.v1`, `chunk_inspection.v1`, `citation.v1`, `doc_summary.v1`. Schemas live in `docs/wire-schema/v1/`. The wire shape is the contract for external integrations (Claude Code skills, MCP, etc.); breaking it requires a `*.v2` major bump and parallel-running both for one phase. In `--json` mode, fatal errors emit `error.v1` to stderr as ndjson (non-`--json` mode keeps plain stderr text); exit codes 0/1/2/3 are unchanged — `error.v1.code` provides fine-grained agent branching.
 
 In-tree integration packages live under `integrations/<host>/` — currently `integrations/claude-code/kebab/` (a Claude Code skill that calls `kebab search --json` / `kebab ask --json`). Any wire schema major bump (v1→v2) MUST update each shipped integration in the same PR, same as the version-cascade rule below. Per-user trigger keywords (team / system / acronym) belong in the user's local copy of the skill, not in the repo-shipped frontmatter — keep `integrations/claude-code/kebab/SKILL.md`'s `description` generic.
 

Cargo.lock

@@ -3525,7 +3525,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-app"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "blake3",
@@ -3568,7 +3568,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-chunk"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "blake3",
@@ -3583,7 +3583,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-cli"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "clap",
@@ -3603,7 +3603,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-config"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "dirs 5.0.1",
@@ -3618,7 +3618,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-core"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "blake3",
@@ -3632,7 +3632,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-embed"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "blake3",
@@ -3646,7 +3646,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-embed-local"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "fastembed",
@@ -3659,7 +3659,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-eval"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "kebab-app",
@@ -3678,7 +3678,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-llm"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "kebab-core",
@@ -3687,7 +3687,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-llm-local"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "kebab-config",
@@ -3704,7 +3704,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-mcp"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "kebab-app",
@@ -3721,7 +3721,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-normalize"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "kebab-core",
@@ -3736,7 +3736,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-parse-image"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "ab_glyph",
  "anyhow",
@@ -3760,7 +3760,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-parse-md"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "kebab-core",
@@ -3777,7 +3777,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-parse-pdf"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "blake3",
@@ -3790,7 +3790,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-parse-types"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "kebab-core",
  "serde",
@@ -3798,7 +3798,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-rag"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "blake3",
@@ -3819,7 +3819,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-search"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "globset",
@@ -3837,7 +3837,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-source-fs"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "blake3",
@@ -3854,7 +3854,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-store-sqlite"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "blake3",
@@ -3875,7 +3875,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-store-vector"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "arrow",
@@ -3899,7 +3899,7 @@ dependencies = [
 
 [[package]]
 name = "kebab-tui"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "crossterm",

Cargo.toml

@@ -30,7 +30,7 @@ edition       = "2024"
 rust-version  = "1.85"
 license       = "MIT OR Apache-2.0"
 repository    = "https://github.com/altair823/kebab"
-version       = "0.3.2"
+version       = "0.3.3"
 
 [workspace.dependencies]
 anyhow       = "1"

HANDOFF.md

@@ -31,6 +31,10 @@ P0~P5 직렬. P6~P9 P5 이후 병렬 가능.
 
 머지 후 발견된 모든 deviation / hotfix 의 dated 로그는 [tasks/HOTFIXES.md](tasks/HOTFIXES.md). 본 요약은 \"누군가가 인수받을 때 알아두면 시간을 많이 절약하는\" 항목만:
 
+- **2026-05-07 fb-26 (progress.rs)** — `Aborted` unconditional writeln (TTY duplicate) + `Completed` TTY no summary fixed; `KEBAB_PROGRESS=plain` env + quiet suppression added
+- **2026-05-07 fb-28 (main.rs)** — `--readonly` (KEBAB_READONLY) blocks Ingest/IngestFile/IngestStdin/Reset; `--quiet` suppresses progress stderr; error.v1 code: "readonly_mode"
+
+- **2026-05-07 macOS XDG path collision (config 사라지는 버그)** — `dirs` crate 가 macOS 에서 `config_dir()` 과 `data_dir()` 둘 다 `~/Library/Application Support/` 반환 → `reset --data-only` 가 config 파일까지 삭제. Fix: `~/.config`, `~/.local/share`, `~/.cache` 직접 사용. 새 경로: config `~/.config/kebab/`, data `~/.local/share/kebab/`, cache `~/.cache/kebab/`. `Config::load(None)` 이 macOS legacy path 에서 자동 마이그레이션. 자세한 내용: `tasks/HOTFIXES.md`.
 - **2026-05-07 P9 post-도그푸딩 (p9-fb-31)** — `kebab ingest-file <path>` + `kebab ingest-stdin --title <T>` 두 신규 subcommand + MCP tool `ingest_file` / `ingest_stdin` (4 → 6 tool). agent 가 fetch 한 web markdown / 외부 file 을 KB 에 즉시 저장. workspace 외부 file 은 `<workspace.root>/_external/<blake3-12>.<ext>` 로 copy (deterministic 명명 → idempotent). `_external/` 디렉토리 첫 생성 시 `.kebabignore` 자동 append (walk 무한 루프 방지). stdin 은 markdown 전용 + flag (`--title`, `--source-uri`) → frontmatter 자동 prepend. .kebabignore 매치 시 stderr warn 후 진행 (explicit ingest = bypass intent). fb-30 의 v1 read-only MCP 정책 변경 — 첫 mutation tool 도입. spec: `tasks/p9/p9-fb-31-single-file-stdin-ingest.md`. design: `docs/superpowers/specs/2026-05-07-p9-fb-31-single-file-stdin-ingest-design.md`.
 - **2026-05-07 P9 post-도그푸딩 (p9-fb-30)** — `kebab mcp` 신규 subcommand + new crate `kebab-mcp` (lib only) — stdio JSON-RPC server. 4 read-only tool (`search` / `ask` / `schema` / `doctor`) 가 `kebab-app` facade 위에 build. rmcp 1.6 SDK 채택, manual `tools/list` + `tools/call` dispatch (rmcp 의 `#[tool_router]` 매크로 대신). `error_classify` 모듈을 `kebab-cli` → `kebab-app::error_wire` 로 promotion (UI crate 끼리 import 회피, facade 룰 준수). `ErrorV1` 에 `schema_version: String` 필드 추가 — kebab-mcp 의 직접 serialize 경로에서도 wire 정합. `KebabAppState` 가 `(Config, Option<PathBuf>)` carry — doctor tool 의 path-aware behavior 위해. ask + search arm 의 `tokio::task::spawn_blocking` wrap — `OllamaLanguageModel` 의 reqwest blocking client 가 async 안에서 panic 회피. capability flag `mcp_server` `false` → `true`. agent integration MVP 완성 — Claude Code / Cursor / OpenAI Agents 등 host-agnostic 사용 가능. spec: `tasks/p9/p9-fb-30-mcp-server.md`. design: `docs/superpowers/specs/2026-05-07-p9-fb-30-mcp-server-design.md`.
 - **P3-5 / P4-3 `--config` 누락** — `kebab-cli` 가 `--config <path>` 를 honor 하려면 `kebab_app::*_with_config` companion 을 호출해야 함. 두 번 같은 모양으로 회귀했음.

README.md

@@ -86,6 +86,8 @@ kebab doctor
 
 모든 명령에 `--json` 플래그. 출력은 frozen wire schema v1 (`schema_version` 항상 포함, 예: `ingest_report.v1`, `ingest_progress.v1`, `search_hit.v1`, `answer.v1`, `doctor.v1`, `reset_report.v1`, `schema.v1`). `--json` 모드에서 fatal error 는 stderr 에 `error.v1` ndjson 으로 emit (exit code 0/1/2/3 unchanged).
 
+글로벌 플래그: `--readonly` (또는 `KEBAB_READONLY=1`) — 모든 write-path 명령 (`ingest` / `ingest-file` / `ingest-stdin` / `reset`) 을 비활성화, exit 1. `--quiet` — 진행 바 / hint 등 human-readable stderr 억제 (exit code / stdout 출력은 그대로). `KEBAB_PROGRESS=plain` — TTY 가 없는 환경에서도 진행 상황을 plain-text 한 줄씩 stderr 로 출력 (spinner 대신).
+
 ## 논리 아키텍처
 
 ```mermaid

crates/kebab-cli/Cargo.toml

@@ -32,7 +32,7 @@ kebab-mcp    = { path = "../kebab-mcp" }
 anyhow       = { workspace = true }
 serde        = { workspace = true }
 serde_json   = { workspace = true }
-clap         = { version = "4", features = ["derive"] }
+clap         = { version = "4", features = ["derive", "env"] }
 # p9-fb-02: ingest progress UI.
 # - TTY 사람 모드: indicatif spinner + bar (stderr).
 # - --json 모드 / non-TTY: indicatif 끄고 raw line emit.

crates/kebab-cli/src/main.rs

@@ -1,4 +1,4 @@
-//! `kb` — command-line interface. Each subcommand maps 1:1 to a `kb-app`
+//! `kebab` — command-line interface. Each subcommand maps 1:1 to a `kebab-app`
 //! function. Exit codes per design §10.
 
 use std::path::PathBuf;
@@ -32,6 +32,16 @@ struct Cli {
     #[arg(long, global = true)]
     json: bool,
 
+    /// Disable all write-path subcommands (also: KEBAB_READONLY=1 env var).
+    #[arg(long, global = true, env = "KEBAB_READONLY",
+          value_parser = parse_bool_env)]
+    readonly: bool,
+
+    /// Suppress all human-readable stderr output: progress lines, hints.
+    /// Implied by `--json`.
+    #[arg(long, global = true)]
+    quiet: bool,
+
     #[command(subcommand)]
     command: Cmd,
 }
@@ -140,7 +150,7 @@ enum Cmd {
         /// history and appends the new Q/A. Without this flag, ask
         /// is single-shot (no persistence). The session id is
         /// caller-supplied — pick anything stable per conversation
-        /// (e.g. `kb-rust-async-2026-05`).
+        /// (e.g. `kebab-rust-async-2026-05`).
         #[arg(long, value_name = "ID")]
         session: Option<String>,
     },
@@ -285,6 +295,16 @@ impl From<ModeFlag> for kebab_core::SearchMode {
     }
 }
 
+/// Parse boolean env var accepting "1", "true", "yes", "on" (case-insensitive)
+/// as truthy; "0", "false", "no", "off" as falsy. Used for `KEBAB_READONLY`.
+fn parse_bool_env(s: &str) -> Result<bool, String> {
+    match s.to_ascii_lowercase().as_str() {
+        "1" | "true" | "yes" | "on" => Ok(true),
+        "0" | "false" | "no" | "off" => Ok(false),
+        other => Err(format!("expected 1/0/true/false/yes/no/on/off, got {other:?}")),
+    }
+}
+
 fn main() -> ExitCode {
     let cli = Cli::parse();
     let level = if cli.debug {
@@ -295,8 +315,30 @@ fn main() -> ExitCode {
         kebab_app::logging::LogLevel::Default
     };
     // Fail-soft: if logging init errors (e.g. XDG state dir is read-only),
-    // proceed without a guard rather than crashing — `kb` is still usable.
+    // proceed without a guard rather than crashing — `kebab` is still usable.
     let _log_guard = kebab_app::logging::init(level).ok();
+    if cli.readonly && is_mutating(&cli.command) {
+        let msg = "kebab: readonly mode — mutating commands are disabled";
+        if cli.json {
+            let v1 = kebab_app::ErrorV1 {
+                schema_version: kebab_app::ERROR_V1_ID.to_string(),
+                code: "readonly_mode".to_string(),
+                message: msg.to_string(),
+                details: serde_json::json!({}),
+                hint: Some(
+                    "remove --readonly (or unset KEBAB_READONLY) to allow writes".to_string(),
+                ),
+            };
+            let v = wire::wire_error_v1(&v1);
+            eprintln!(
+                "{}",
+                serde_json::to_string(&v).unwrap_or_else(|_| msg.to_string())
+            );
+        } else {
+            eprintln!("{msg}");
+        }
+        return ExitCode::from(1);
+    }
     match run(&cli) {
         Ok(()) => ExitCode::from(0),
         Err(e) => {
@@ -348,7 +390,7 @@ fn run(cli: &Cli) -> anyhow::Result<()> {
                 );
                 println!("created  {}", kebab_config::Config::xdg_data_dir().display());
                 println!("created  {}", kebab_config::Config::xdg_state_dir().display());
-                println!("hint     edit the config above, then `kb ingest`");
+                println!("hint     edit the config above, then `kebab ingest`");
             }
             Ok(())
         }
@@ -370,7 +412,10 @@ fn run(cli: &Cli) -> anyhow::Result<()> {
             // the channel and emits per-step events into it. When the
             // call returns, the `Sender` drops and the display thread
             // sees `recv()` return Err — exits cleanly.
-            let mode = progress::ProgressMode::from_flags(cli.json);
+            let plain_env = std::env::var("KEBAB_PROGRESS")
+                .map(|v| v.eq_ignore_ascii_case("plain"))
+                .unwrap_or(false);
+            let mode = progress::ProgressMode::from_flags(cli.json, cli.quiet, plain_env);
             let (tx, rx) = std::sync::mpsc::channel::<kebab_app::IngestEvent>();
             let display_handle = std::thread::spawn(move || {
                 progress::ProgressDisplay::new(mode).run(rx)
@@ -614,7 +659,9 @@ fn run(cli: &Cli) -> anyhow::Result<()> {
                     );
                 }
                 if !confirm_destructive(scope, &paths, bytes)? {
-                    eprintln!("aborted.");
+                    if !cli.quiet {
+                        eprintln!("aborted.");
+                    }
                     return Ok(());
                 }
             }
@@ -857,6 +904,13 @@ fn print_schema_text(s: &kebab_app::SchemaV1) {
     println!("  last_ingest_at          {last}");
 }
 
+fn is_mutating(cmd: &Cmd) -> bool {
+    matches!(
+        cmd,
+        Cmd::Ingest { .. } | Cmd::IngestFile { .. } | Cmd::IngestStdin { .. } | Cmd::Reset { .. }
+    )
+}
+
 /// Minimal stdin/stdout confirm prompt for destructive ops. No new dep —
 /// uses stdlib `IsTerminal` (the caller is expected to have already
 /// short-circuited the non-TTY case). Returns `Ok(true)` only when the

crates/kebab-cli/src/progress.rs

@@ -39,18 +39,22 @@ pub enum ProgressMode {
     Json,
     /// stdout reserved for the final report; stderr gets an indicatif
     /// `ProgressBar` (TTY) or one short line per event (non-TTY).
-    Human { tty: bool },
+    Human { tty: bool, quiet: bool },
 }
 
 impl ProgressMode {
     /// Pick the right mode from caller flags.
-    pub fn from_flags(json: bool) -> Self {
+    ///
+    /// - `json`: `--json` flag — takes priority, returns `Json`.
+    /// - `quiet`: `--quiet` flag — suppresses human-readable stderr when `Human`.
+    /// - `plain_env`: `KEBAB_PROGRESS=plain` — forces `tty=false` even in a TTY,
+    ///   for CI environments that emulate a TTY with a pty wrapper.
+    pub fn from_flags(json: bool, quiet: bool, plain_env: bool) -> Self {
         if json {
             Self::Json
         } else {
-            Self::Human {
-                tty: std::io::stderr().is_terminal(),
-            }
+            let tty = !plain_env && std::io::stderr().is_terminal();
+            Self::Human { tty, quiet }
         }
     }
 }
@@ -83,7 +87,7 @@ impl ProgressDisplay {
     fn handle(&mut self, event: &IngestEvent) -> anyhow::Result<()> {
         match self.mode {
             ProgressMode::Json => emit_json(event),
-            ProgressMode::Human { tty } => self.handle_human(event, tty),
+            ProgressMode::Human { tty, quiet } => self.handle_human(event, tty, quiet),
         }
     }
 
@@ -96,18 +100,20 @@ impl ProgressDisplay {
     /// `ScanStarted` arm and §2.4a's ordering invariant
     /// (`ScanStarted` < everything else) guarantees it is `Some` by
     /// the time later events arrive.
-    fn handle_human(&mut self, event: &IngestEvent, tty: bool) -> anyhow::Result<()> {
+    fn handle_human(&mut self, event: &IngestEvent, tty: bool, quiet: bool) -> anyhow::Result<()> {
         match event {
             IngestEvent::ScanStarted { root } => {
                 let bar = ProgressBar::new_spinner().with_message(format!("scanning {root}"));
-                bar.set_draw_target(if tty {
+                bar.set_draw_target(if tty && !quiet {
                     ProgressDrawTarget::stderr()
                 } else {
                     ProgressDrawTarget::hidden()
                 });
-                bar.enable_steady_tick(std::time::Duration::from_millis(100));
+                if tty && !quiet {
+                    bar.enable_steady_tick(std::time::Duration::from_millis(100));
+                }
                 self.bar = Some(bar);
-                if !tty {
+                if !tty && !quiet {
                     let mut err = std::io::stderr().lock();
                     let _ = writeln!(err, "ingest: scanning {root}…");
                 }
@@ -126,7 +132,7 @@ impl ProgressDisplay {
                     );
                     bar.set_message("");
                 }
-                if !tty {
+                if !tty && !quiet {
                     let mut err = std::io::stderr().lock();
                     let _ = writeln!(err, "ingest: scan complete ({total} assets)");
                 }
@@ -138,23 +144,28 @@ impl ProgressDisplay {
                 media,
             } => {
                 if let Some(bar) = self.bar.as_ref() {
-                    bar.set_message(format!("{media} {path}"));
+                    // One draw per file: position only. set_message() would
+                    // trigger a second independent draw and pollute TTY scrollback.
+                    // Filename is visible in the non-TTY plain-line path below.
+                    bar.set_position(u64::from(idx.saturating_sub(1)));
                 }
-                if !tty {
+                if !tty && !quiet {
                     let mut err = std::io::stderr().lock();
                     let _ = writeln!(err, "ingest: {idx}/{total} {media} {path}");
                 }
             }
-            IngestEvent::AssetFinished { idx, .. } => {
-                if let Some(bar) = self.bar.as_ref() {
-                    bar.set_position(u64::from(*idx));
-                }
+            IngestEvent::AssetFinished { .. } => {
+                // Position is advanced in AssetStarted; bar.finish_and_clear()
+                // in Completed handles the final state. No per-asset bar update
+                // here avoids the duplicate-frame artifact in TTY scrollback.
             }
             IngestEvent::Completed { counts } => {
                 if let Some(bar) = self.bar.take() {
                     bar.finish_and_clear();
                 }
-                if !tty {
+                // Always emit summary in both TTY and non-TTY (unless quiet).
+                // Bug fix: previously TTY had no summary line after bar.finish_and_clear().
+                if !quiet {
                     let mut err = std::io::stderr().lock();
                     let _ = writeln!(
                         err,
@@ -175,16 +186,20 @@ impl ProgressDisplay {
                         counts.scanned
                     ));
                 }
-                let mut err = std::io::stderr().lock();
-                let _ = writeln!(
-                    err,
-                    "ingest: aborted (scanned={} new={} updated={} skipped={} errors={})",
-                    counts.scanned,
-                    counts.new,
-                    counts.updated,
-                    counts.skipped,
-                    counts.errors,
-                );
+                // Bug fix: was unconditional (fired in TTY too).
+                // In TTY, bar.abandon_with_message already prints the final state.
+                if !tty && !quiet {
+                    let mut err = std::io::stderr().lock();
+                    let _ = writeln!(
+                        err,
+                        "ingest: aborted (scanned={} new={} updated={} skipped={} errors={})",
+                        counts.scanned,
+                        counts.new,
+                        counts.updated,
+                        counts.skipped,
+                        counts.errors,
+                    );
+                }
             }
         }
         Ok(())
@@ -216,20 +231,35 @@ mod tests {
 
     #[test]
     fn from_flags_json_takes_priority_over_tty() {
-        // --json forces Json regardless of TTY state.
-        assert_eq!(ProgressMode::from_flags(true), ProgressMode::Json);
+        assert_eq!(ProgressMode::from_flags(true, false, false), ProgressMode::Json);
     }
 
     #[test]
     fn from_flags_human_reflects_stderr_tty() {
         // We can't synthesize a TTY in tests, but we can assert the
         // shape — mode is Human { tty: <something> } when --json=false.
-        match ProgressMode::from_flags(false) {
+        match ProgressMode::from_flags(false, false, false) {
             ProgressMode::Human { .. } => {}
             other => panic!("expected Human mode, got {other:?}"),
         }
     }
 
+    #[test]
+    fn from_flags_quiet_sets_quiet_field() {
+        match ProgressMode::from_flags(false, true, false) {
+            ProgressMode::Human { quiet: true, .. } => {}
+            other => panic!("expected Human{{quiet:true}}, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn from_flags_plain_env_forces_tty_false() {
+        match ProgressMode::from_flags(false, false, true) {
+            ProgressMode::Human { tty: false, .. } => {}
+            other => panic!("expected Human{{tty:false}}, got {other:?}"),
+        }
+    }
+
     #[test]
     fn now_rfc3339_parses_back() {
         let s = now_rfc3339().unwrap();

crates/kebab-cli/tests/cli_readonly_quiet.rs

@@ -0,0 +1,183 @@
+//! Integration tests for `--readonly` and `--quiet` global flags (fb-28).
+
+use std::io::Write;
+use std::process::Command;
+
+fn kebab_bin() -> std::path::PathBuf {
+    let manifest = env!("CARGO_MANIFEST_DIR");
+    std::path::PathBuf::from(manifest)
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .join("target/debug/kebab")
+}
+
+fn fixture_workspace() -> (tempfile::TempDir, std::path::PathBuf) {
+    let tmp = tempfile::tempdir().unwrap();
+    let ws = tmp.path().join("workspace");
+    std::fs::create_dir_all(&ws).unwrap();
+    let mut a = std::fs::File::create(ws.join("a.md")).unwrap();
+    writeln!(a, "# Alpha\n\nfirst doc").unwrap();
+    (tmp, ws)
+}
+
+fn xdg_envs(tmp_path: &std::path::Path) -> [(&'static str, std::path::PathBuf); 4] {
+    [
+        ("XDG_CONFIG_HOME", tmp_path.join("cfg")),
+        ("XDG_DATA_HOME", tmp_path.join("data")),
+        ("XDG_CACHE_HOME", tmp_path.join("cache")),
+        ("XDG_STATE_HOME", tmp_path.join("state")),
+    ]
+}
+
+#[test]
+fn readonly_flag_blocks_ingest() {
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--readonly", "ingest", "--root", ws.to_str().unwrap()])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        stderr.contains("readonly mode"),
+        "expected 'readonly mode' in stderr, got: {stderr}"
+    );
+}
+
+#[test]
+fn readonly_flag_blocks_ingest_file() {
+    let (tmp, ws) = fixture_workspace();
+    let file = ws.join("a.md");
+    let out = Command::new(kebab_bin())
+        .args(["--readonly", "ingest-file", file.to_str().unwrap()])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.contains("readonly mode"), "stderr: {stderr}");
+}
+
+#[test]
+fn readonly_flag_blocks_ingest_stdin() {
+    let (tmp, _ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--readonly", "ingest-stdin", "--title", "test"])
+        .env("KEBAB_READONLY", "1")
+        .envs(xdg_envs(tmp.path()))
+        .stdin(std::process::Stdio::null())
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.contains("readonly mode"), "stderr: {stderr}");
+}
+
+#[test]
+fn readonly_flag_blocks_reset() {
+    let (tmp, _ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--readonly", "reset", "--data-only", "--yes"])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.contains("readonly mode"), "stderr: {stderr}");
+}
+
+#[test]
+fn kebab_readonly_env_blocks_ingest() {
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["ingest", "--root", ws.to_str().unwrap()])
+        .env("KEBAB_READONLY", "1")
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.contains("readonly mode"), "stderr: {stderr}");
+}
+
+#[test]
+fn readonly_json_mode_emits_error_v1() {
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--readonly", "--json", "ingest", "--root", ws.to_str().unwrap()])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    let v: serde_json::Value = serde_json::from_str(stderr.trim())
+        .unwrap_or_else(|e| panic!("expected error.v1 JSON on stderr, got {stderr:?}: {e}"));
+    assert_eq!(
+        v.get("schema_version").and_then(|s| s.as_str()),
+        Some("error.v1"),
+        "expected schema_version=error.v1"
+    );
+    assert_eq!(
+        v.get("code").and_then(|s| s.as_str()),
+        Some("readonly_mode"),
+        "expected code=readonly_mode"
+    );
+}
+
+#[test]
+fn quiet_flag_suppresses_progress_stderr() {
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--quiet", "ingest", "--root", ws.to_str().unwrap()])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert!(
+        out.status.success(),
+        "exit: {:?}, stderr: {}",
+        out.status.code(),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        stderr.is_empty(),
+        "expected empty stderr with --quiet, got: {stderr}"
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("scanned"),
+        "expected report summary on stdout, got: {stdout}"
+    );
+}
+
+#[test]
+fn quiet_with_json_stdout_has_report_stderr_is_empty() {
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--quiet", "--json", "ingest", "--root", ws.to_str().unwrap()])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.is_empty(), "expected empty stderr, got: {stderr}");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let last_line = stdout.lines().last().unwrap_or("");
+    let v: serde_json::Value = serde_json::from_str(last_line)
+        .unwrap_or_else(|e| panic!("expected JSON on stdout last line, got {last_line:?}: {e}"));
+    assert_eq!(
+        v.get("schema_version").and_then(|s| s.as_str()),
+        Some("ingest_report.v1")
+    );
+}

crates/kebab-cli/tests/ingest_progress_cli.rs

@@ -162,3 +162,32 @@ fn ingest_json_progress_lines_carry_kind_and_ts() {
     assert!(saw_scan_started, "missing scan_started event");
     assert!(saw_completed, "missing completed event");
 }
+
+#[test]
+fn kebab_progress_plain_env_emits_append_lines() {
+    // KEBAB_PROGRESS=plain forces non-TTY branch even in TTY-emulated envs.
+    // In subprocess tests there's no TTY anyway, so this primarily verifies
+    // the env var is accepted and the non-TTY path still works.
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["ingest", "--root", ws.to_str().unwrap()])
+        .env("KEBAB_PROGRESS", "plain")
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert!(
+        out.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        stderr.contains("ingest: scanning"),
+        "expected 'ingest: scanning' in stderr, got: {stderr}"
+    );
+    assert!(
+        stderr.contains("ingest: complete"),
+        "expected 'ingest: complete' in stderr, got: {stderr}"
+    );
+}

crates/kebab-config/src/lib.rs

@@ -393,6 +393,25 @@ impl Config {
                 if p.exists() {
                     Self::from_file(&p)?
                 } else {
+                    // macOS migration: if the new XDG path is absent but the
+                    // old ~/Library/Application Support/kebab/config.toml exists,
+                    // copy it to the new location so the user doesn't lose settings.
+                    if let Some(legacy) = Self::macos_legacy_config_path() {
+                        if legacy.exists() && !p.exists() {
+                            if let Some(parent) = p.parent() {
+                                let _ = std::fs::create_dir_all(parent);
+                            }
+                            if std::fs::copy(&legacy, &p).is_ok() {
+                                eprintln!(
+                                    "kebab: migrated config {} → {}",
+                                    legacy.display(),
+                                    p.display()
+                                );
+                                return Self::from_file(&p)
+                                    .map(|c| c.apply_env(&std::env::vars().collect()));
+                            }
+                        }
+                    }
                     Self::defaults()
                 }
             }
@@ -634,8 +653,11 @@ impl Config {
                 return PathBuf::from(custom).join("kebab").join("config.toml");
             }
         }
-        match dirs::config_dir() {
-            Some(d) => d.join("kebab").join("config.toml"),
+        // Always use XDG-standard ~/.config regardless of platform.
+        // macOS dirs::config_dir() returns ~/Library/Application Support which
+        // collides with data_dir() — DataOnly reset would delete config too.
+        match dirs::home_dir() {
+            Some(h) => h.join(".config").join("kebab").join("config.toml"),
             None => PathBuf::from("./kebab/config.toml"),
         }
     }
@@ -647,8 +669,9 @@ impl Config {
                 return PathBuf::from(custom).join("kebab");
             }
         }
-        match dirs::data_dir() {
-            Some(d) => d.join("kebab"),
+        // Always use XDG-standard ~/.local/share regardless of platform.
+        match dirs::home_dir() {
+            Some(h) => h.join(".local").join("share").join("kebab"),
             None => PathBuf::from("./kebab-data"),
         }
     }
@@ -660,8 +683,9 @@ impl Config {
                 return PathBuf::from(custom).join("kebab");
             }
         }
-        match dirs::cache_dir() {
-            Some(d) => d.join("kebab"),
+        // Always use XDG-standard ~/.cache regardless of platform.
+        match dirs::home_dir() {
+            Some(h) => h.join(".cache").join("kebab"),
             None => PathBuf::from("./kebab-cache"),
         }
     }
@@ -680,6 +704,25 @@ impl Config {
         }
         PathBuf::from("./kebab-state")
     }
+
+    /// macOS legacy config path: `~/Library/Application Support/kebab/config.toml`.
+    /// Returns `None` on non-macOS or when home dir is unavailable.
+    /// Used for one-time migration to the XDG-standard location.
+    fn macos_legacy_config_path() -> Option<PathBuf> {
+        #[cfg(target_os = "macos")]
+        {
+            dirs::home_dir().map(|h| {
+                h.join("Library")
+                    .join("Application Support")
+                    .join("kebab")
+                    .join("config.toml")
+            })
+        }
+        #[cfg(not(target_os = "macos"))]
+        {
+            None
+        }
+    }
 }
 
 /// Parse a permissive boolean — `1` / `true` / `yes` (case-insensitive)

docs/SMOKE.md

@@ -114,7 +114,7 @@ max_context_tokens = 6000
 theme = "dark"                       # p9-fb-14 — TUI palette ("dark" / "light", default "dark")
 ```
 
-`KEBAB_*` 환경변수로 override 가능 (`KEBAB_MODELS_LLM_MODEL=gemma4:26b kebab …` 등). 자세한 키 목록은 `crates/kebab-config/src/lib.rs` 의 `apply_env` 매치 암.
+`KEBAB_*` 환경변수로 override 가능 (`KEBAB_MODELS_LLM_MODEL=gemma4:26b kebab …` 등). 자세한 키 목록은 `crates/kebab-config/src/lib.rs` 의 `apply_env` 매치 암. `KEBAB_READONLY=1` — write-path 비활성화 (CI 안전망). `KEBAB_PROGRESS=plain` — non-TTY 환경에서 진행 상황을 plain 한 줄씩 stderr 출력 (spinner 대신).
 
 ## 명령 시퀀스
 

docs/superpowers/plans/2026-05-07-fb-26-fb-28-agent-ux.md

@@ -0,0 +1,796 @@
+# Agent UX Improvements: Ingest Log Consistency + Invocation Flags Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Fix ingest progress log inconsistency (fb-26), add `--readonly`/`--quiet` global CLI flags (fb-28), and sync CLAUDE.md wire schema list.
+
+**Architecture:** Three independent changes bundled in one branch. `progress.rs` gets a `quiet` field on `ProgressMode::Human` and two bug fixes in `handle_human`. `main.rs` gets two new global flags on `Cli` plus a readonly guard block before subcommand dispatch. CLAUDE.md gets a corrected schema list.
+
+**Tech Stack:** Rust 2024, clap (already in use), indicatif (already in use), tempfile (already in use for tests)
+
+---
+
+## File Map
+
+| File | Change |
+|---|---|
+| `CLAUDE.md` | schema list: remove 3 phantom, add 3 missing |
+| `crates/kebab-cli/src/progress.rs` | `ProgressMode::Human { quiet }` + `from_flags` signature + `handle_human` bug fixes |
+| `crates/kebab-cli/src/main.rs` | `Cli` `--readonly`/`--quiet` flags + `is_mutating()` + readonly guard + update `from_flags` call |
+| `crates/kebab-cli/tests/ingest_progress_cli.rs` | Add `KEBAB_PROGRESS=plain` test + `--quiet` suppression test |
+| `crates/kebab-cli/tests/cli_readonly_quiet.rs` | New: readonly/quiet integration tests |
+| `tasks/HOTFIXES.md` | `readonly_mode` error code entry |
+| `tasks/p9/p9-fb-26-ingest-log-consistency.md` | `status: open` → `status: merged` |
+| `tasks/p9/p9-fb-28-agent-invocation-flags.md` | `status: open` → `status: merged` |
+| `tasks/INDEX.md` | mark fb-26 + fb-28 done |
+| `HANDOFF.md` | one-line entry |
+
+---
+
+## Task 1: CLAUDE.md wire schema list sync
+
+**Files:**
+- Modify: `CLAUDE.md:63`
+
+- [ ] **Step 1: Edit CLAUDE.md**
+
+Find the line (currently line 63):
+
+```
+All `--json` output carries a `schema_version` field. Current schemas: `ingest_report.v1`, `ingest_progress.v1`, `search_hit.v1`, `answer.v1`, `doctor.v1`, `reset_report.v1`, `eval_run.v1`, `eval_compare.v1`, `list_docs.v1`, `schema.v1`, `error.v1`.
+```
+
+Replace with:
+
+```
+All `--json` output carries a `schema_version` field. Current schemas: `ingest_report.v1`, `ingest_progress.v1`, `search_hit.v1`, `answer.v1`, `doctor.v1`, `reset_report.v1`, `schema.v1`, `error.v1`, `chunk_inspection.v1`, `citation.v1`, `doc_summary.v1`.
+```
+
+- [ ] **Step 2: Verify**
+
+```bash
+ls docs/wire-schema/v1/ | sed 's/\.schema\.json$/\.v1/' | sort
+```
+
+Confirm output matches the 11 schemas listed (answer, chunk_inspection, citation, doc_summary, doctor, error, ingest_progress, ingest_report, reset_report, schema, search_hit).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add CLAUDE.md
+git commit -m "docs: sync wire schema list in CLAUDE.md (remove phantom eval_run/eval_compare/list_docs, add chunk_inspection/citation/doc_summary)"
+```
+
+---
+
+## Task 2: progress.rs — ProgressMode quiet field + from_flags update
+
+**Files:**
+- Modify: `crates/kebab-cli/src/progress.rs`
+
+- [ ] **Step 1: Update the existing unit tests to expect new from_flags signature**
+
+In `crates/kebab-cli/src/progress.rs`, the `#[cfg(test)]` block has two tests that call `from_flags`. Update them:
+
+```rust
+#[test]
+fn from_flags_json_takes_priority_over_tty() {
+    assert_eq!(ProgressMode::from_flags(true, false, false), ProgressMode::Json);
+}
+
+#[test]
+fn from_flags_human_reflects_stderr_tty() {
+    match ProgressMode::from_flags(false, false, false) {
+        ProgressMode::Human { .. } => {}
+        other => panic!("expected Human mode, got {other:?}"),
+    }
+}
+```
+
+Also add a new test for quiet and plain_env:
+
+```rust
+#[test]
+fn from_flags_quiet_sets_quiet_field() {
+    match ProgressMode::from_flags(false, true, false) {
+        ProgressMode::Human { quiet: true, .. } => {}
+        other => panic!("expected Human{{quiet:true}}, got {other:?}"),
+    }
+}
+
+#[test]
+fn from_flags_plain_env_forces_tty_false() {
+    // plain_env=true must set tty=false regardless of terminal state.
+    match ProgressMode::from_flags(false, false, true) {
+        ProgressMode::Human { tty: false, .. } => {}
+        other => panic!("expected Human{{tty:false}}, got {other:?}"),
+    }
+}
+```
+
+- [ ] **Step 2: Run tests to verify they fail (compilation error)**
+
+```bash
+cargo test -p kebab-cli --lib 2>&1 | tail -20
+```
+
+Expected: compile error — `from_flags` called with 1 argument but expects more.
+
+- [ ] **Step 3: Implement ProgressMode changes**
+
+In `crates/kebab-cli/src/progress.rs`, replace the enum and impl:
+
+```rust
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ProgressMode {
+    /// stdout = line-delimited `ingest_progress.v1`. stderr stays
+    /// silent for events (errors / log frames still go to stderr).
+    Json,
+    /// stdout reserved for the final report; stderr gets an indicatif
+    /// `ProgressBar` (TTY) or one short line per event (non-TTY).
+    Human { tty: bool, quiet: bool },
+}
+
+impl ProgressMode {
+    /// Pick the right mode from caller flags.
+    ///
+    /// - `json`: `--json` flag — takes priority, returns `Json`.
+    /// - `quiet`: `--quiet` flag — suppresses human-readable stderr when `Human`.
+    /// - `plain_env`: `KEBAB_PROGRESS=plain` — forces `tty=false` even in a TTY,
+    ///   for CI environments that emulate a TTY with a pty wrapper.
+    pub fn from_flags(json: bool, quiet: bool, plain_env: bool) -> Self {
+        if json {
+            Self::Json
+        } else {
+            let tty = !plain_env && std::io::stderr().is_terminal();
+            Self::Human { tty, quiet }
+        }
+    }
+}
+```
+
+Also update `handle()` in `impl ProgressDisplay` to pass `quiet` through, and update `handle_human`'s signature to accept `quiet` (body unchanged yet — Task 3 implements the suppression):
+
+```rust
+fn handle(&mut self, event: &IngestEvent) -> anyhow::Result<()> {
+    match self.mode {
+        ProgressMode::Json => emit_json(event),
+        ProgressMode::Human { tty, quiet } => self.handle_human(event, tty, quiet),
+    }
+}
+```
+
+And update the `handle_human` signature (keep body as-is, just add the param):
+
+```rust
+fn handle_human(&mut self, event: &IngestEvent, tty: bool, quiet: bool) -> anyhow::Result<()> {
+    let _ = quiet; // used in Task 3; suppress unused warning for now
+    // ... rest of existing body unchanged ...
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+```bash
+cargo test -p kebab-cli --lib 2>&1 | tail -10
+```
+
+Expected: all 5 unit tests in progress.rs pass.
+
+- [ ] **Step 5: Fix the compile error in main.rs (from_flags call)**
+
+At line ~373 in `crates/kebab-cli/src/main.rs`, find:
+
+```rust
+let mode = progress::ProgressMode::from_flags(cli.json);
+```
+
+Replace with a temporary stub that compiles (full implementation in Task 4):
+
+```rust
+let mode = progress::ProgressMode::from_flags(cli.json, false, false);
+```
+
+- [ ] **Step 6: Verify workspace compiles**
+
+```bash
+cargo build -p kebab-cli 2>&1 | tail -5
+```
+
+Expected: `Finished dev` with no errors.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add crates/kebab-cli/src/progress.rs crates/kebab-cli/src/main.rs
+git commit -m "feat(fb-26): extend ProgressMode with quiet field, update from_flags signature"
+```
+
+---
+
+## Task 3: progress.rs — handle_human bug fixes + quiet suppression
+
+**Files:**
+- Modify: `crates/kebab-cli/src/progress.rs`
+
+The current `handle_human` signature is `fn handle_human(&mut self, event: &IngestEvent, tty: bool)`. It has two bugs:
+1. `Aborted` — `writeln!` fires unconditionally (even in TTY mode)
+2. `Completed` TTY path — no final summary line after `bar.finish_and_clear()`
+
+- [ ] **Step 1: Replace handle_human entirely**
+
+Replace the full `handle_human` method (lines 99–191 in progress.rs) with:
+
+```rust
+fn handle_human(&mut self, event: &IngestEvent, tty: bool, quiet: bool) -> anyhow::Result<()> {
+    match event {
+        IngestEvent::ScanStarted { root } => {
+            let bar = ProgressBar::new_spinner().with_message(format!("scanning {root}"));
+            bar.set_draw_target(if tty && !quiet {
+                ProgressDrawTarget::stderr()
+            } else {
+                ProgressDrawTarget::hidden()
+            });
+            if tty && !quiet {
+                bar.enable_steady_tick(std::time::Duration::from_millis(100));
+            }
+            self.bar = Some(bar);
+            if !tty && !quiet {
+                let mut err = std::io::stderr().lock();
+                let _ = writeln!(err, "ingest: scanning {root}…");
+            }
+        }
+        IngestEvent::ScanCompleted { total } => {
+            if let Some(bar) = self.bar.as_mut() {
+                bar.disable_steady_tick();
+                bar.set_length(u64::from(*total));
+                bar.set_position(0);
+                bar.set_style(
+                    ProgressStyle::with_template(
+                        "ingest [{bar:30}] {pos}/{len} {wide_msg}",
+                    )
+                    .unwrap()
+                    .progress_chars("=> "),
+                );
+                bar.set_message("");
+            }
+            if !tty && !quiet {
+                let mut err = std::io::stderr().lock();
+                let _ = writeln!(err, "ingest: scan complete ({total} assets)");
+            }
+        }
+        IngestEvent::AssetStarted {
+            idx,
+            total,
+            path,
+            media,
+        } => {
+            if let Some(bar) = self.bar.as_ref() {
+                bar.set_message(format!("{media} {path}"));
+            }
+            if !tty && !quiet {
+                let mut err = std::io::stderr().lock();
+                let _ = writeln!(err, "ingest: {idx}/{total} {media} {path}");
+            }
+        }
+        IngestEvent::AssetFinished { idx, .. } => {
+            if let Some(bar) = self.bar.as_ref() {
+                bar.set_position(u64::from(*idx));
+            }
+        }
+        IngestEvent::Completed { counts } => {
+            if let Some(bar) = self.bar.take() {
+                bar.finish_and_clear();
+            }
+            // Always emit the summary in both TTY and non-TTY (unless quiet).
+            // Bug fix: previously TTY had no summary line after bar.finish_and_clear().
+            if !quiet {
+                let mut err = std::io::stderr().lock();
+                let _ = writeln!(
+                    err,
+                    "ingest: complete (scanned={} new={} updated={} skipped={} errors={})",
+                    counts.scanned,
+                    counts.new,
+                    counts.updated,
+                    counts.skipped,
+                    counts.errors,
+                );
+            }
+        }
+        IngestEvent::Aborted { counts } => {
+            if let Some(bar) = self.bar.take() {
+                bar.abandon_with_message(format!(
+                    "aborted at {}/{}",
+                    counts.scanned.saturating_sub(counts.errors),
+                    counts.scanned
+                ));
+            }
+            // Bug fix: was unconditional (fired in TTY too).
+            // In TTY, bar.abandon_with_message already prints the final state.
+            if !tty && !quiet {
+                let mut err = std::io::stderr().lock();
+                let _ = writeln!(
+                    err,
+                    "ingest: aborted (scanned={} new={} updated={} skipped={} errors={})",
+                    counts.scanned,
+                    counts.new,
+                    counts.updated,
+                    counts.skipped,
+                    counts.errors,
+                );
+            }
+        }
+    }
+    Ok(())
+}
+```
+
+- [ ] **Step 2: Run unit tests**
+
+```bash
+cargo test -p kebab-cli --lib 2>&1 | tail -10
+```
+
+Expected: all pass.
+
+- [ ] **Step 3: Run integration tests that cover progress**
+
+```bash
+cargo test -p kebab-cli --test ingest_progress_cli 2>&1 | tail -15
+```
+
+Expected: all pass (non-TTY tests verify stderr still contains `ingest:` lines).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add crates/kebab-cli/src/progress.rs
+git commit -m "fix(fb-26): Completed TTY missing summary + Aborted unconditional writeln + quiet suppression in handle_human"
+```
+
+---
+
+## Task 4: main.rs — --readonly/--quiet flags + is_mutating + readonly guard
+
+**Files:**
+- Modify: `crates/kebab-cli/src/main.rs`
+
+- [ ] **Step 1: Add `readonly` and `quiet` to `Cli` struct**
+
+In `crates/kebab-cli/src/main.rs`, find the `struct Cli` definition (around line 16). Add two fields after the `json` field:
+
+```rust
+/// Disable all write-path subcommands (also: KEBAB_READONLY=1 env var).
+#[arg(long, global = true, env = "KEBAB_READONLY")]
+readonly: bool,
+
+/// Suppress all human-readable stderr output: progress lines, hints.
+/// Implied by `--json`.
+#[arg(long, global = true)]
+quiet: bool,
+```
+
+- [ ] **Step 2: Add `is_mutating` function**
+
+Add this free function near the bottom of `main.rs`, before `confirm_destructive`:
+
+```rust
+/// Returns `true` for subcommands that write to the KB. Used by the
+/// `--readonly` guard to reject mutating invocations.
+fn is_mutating(cmd: &Cmd) -> bool {
+    matches!(
+        cmd,
+        Cmd::Ingest { .. } | Cmd::IngestFile { .. } | Cmd::IngestStdin { .. } | Cmd::Reset { .. }
+    )
+}
+```
+
+- [ ] **Step 3: Add readonly guard in main()**
+
+In `main()`, after the logging init block (after line ~299) and before the `match run(&cli)` call, insert:
+
+```rust
+if cli.readonly && is_mutating(&cli.command) {
+    let msg = "kebab: readonly mode — mutating commands are disabled";
+    if cli.json {
+        let v1 = kebab_app::ErrorV1 {
+            schema_version: kebab_app::ERROR_V1_ID.to_string(),
+            code: "readonly_mode".to_string(),
+            message: msg.to_string(),
+            details: serde_json::json!({}),
+            hint: Some(
+                "remove --readonly (or unset KEBAB_READONLY) to allow writes".to_string(),
+            ),
+        };
+        let v = wire::wire_error_v1(&v1);
+        eprintln!(
+            "{}",
+            serde_json::to_string(&v).unwrap_or_else(|_| msg.to_string())
+        );
+    } else {
+        eprintln!("{msg}");
+    }
+    return ExitCode::from(1);
+}
+```
+
+- [ ] **Step 4: Update from_flags call to pass quiet and KEBAB_PROGRESS env**
+
+Find the temporary stub from Task 2 Step 5 (inside `Cmd::Ingest` arm, line ~373):
+
+```rust
+let mode = progress::ProgressMode::from_flags(cli.json, false, false);
+```
+
+Replace with:
+
+```rust
+let plain_env = std::env::var("KEBAB_PROGRESS")
+    .map(|v| v.eq_ignore_ascii_case("plain"))
+    .unwrap_or(false);
+let mode = progress::ProgressMode::from_flags(cli.json, cli.quiet, plain_env);
+```
+
+- [ ] **Step 5: Build to verify no compile errors**
+
+```bash
+cargo build -p kebab-cli 2>&1 | tail -5
+```
+
+Expected: `Finished dev` with no errors.
+
+- [ ] **Step 6: Quick smoke — readonly blocks ingest**
+
+```bash
+# Build debug binary first if needed
+cargo build -p kebab-cli
+
+# Test: readonly should block ingest
+./target/debug/kebab --readonly ingest --root /tmp 2>&1; echo "exit: $?"
+```
+
+Expected: stderr shows `kebab: readonly mode — mutating commands are disabled`, exit code 1.
+
+```bash
+# Test: readonly allows search (no KB needed — just check it doesn't block early)
+./target/debug/kebab --readonly search "test" 2>&1 | head -3
+```
+
+Expected: error about not being initialized or similar — NOT a readonly error.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add crates/kebab-cli/src/main.rs
+git commit -m "feat(fb-28): --readonly/--quiet global flags + KEBAB_READONLY env + is_mutating guard"
+```
+
+---
+
+## Task 5: Integration tests
+
+**Files:**
+- Create: `crates/kebab-cli/tests/cli_readonly_quiet.rs`
+- Modify: `crates/kebab-cli/tests/ingest_progress_cli.rs`
+
+- [ ] **Step 1: Create cli_readonly_quiet.rs**
+
+Create `crates/kebab-cli/tests/cli_readonly_quiet.rs`:
+
+```rust
+//! Integration tests for `--readonly` and `--quiet` global flags (fb-28).
+
+use std::io::Write;
+use std::process::Command;
+
+fn kebab_bin() -> std::path::PathBuf {
+    let manifest = env!("CARGO_MANIFEST_DIR");
+    std::path::PathBuf::from(manifest)
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .join("target/debug/kebab")
+}
+
+fn fixture_workspace() -> (tempfile::TempDir, std::path::PathBuf) {
+    let tmp = tempfile::tempdir().unwrap();
+    let ws = tmp.path().join("workspace");
+    std::fs::create_dir_all(&ws).unwrap();
+    let mut a = std::fs::File::create(ws.join("a.md")).unwrap();
+    writeln!(a, "# Alpha\n\nfirst doc").unwrap();
+    (tmp, ws)
+}
+
+fn xdg_envs(tmp_path: &std::path::Path) -> [(&'static str, std::path::PathBuf); 4] {
+    [
+        ("XDG_CONFIG_HOME", tmp_path.join("cfg")),
+        ("XDG_DATA_HOME", tmp_path.join("data")),
+        ("XDG_CACHE_HOME", tmp_path.join("cache")),
+        ("XDG_STATE_HOME", tmp_path.join("state")),
+    ]
+}
+
+#[test]
+fn readonly_flag_blocks_ingest() {
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--readonly", "ingest", "--root", ws.to_str().unwrap()])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        stderr.contains("readonly mode"),
+        "expected 'readonly mode' in stderr, got: {stderr}"
+    );
+}
+
+#[test]
+fn readonly_flag_blocks_ingest_file() {
+    let (tmp, ws) = fixture_workspace();
+    let file = ws.join("a.md");
+    let out = Command::new(kebab_bin())
+        .args(["--readonly", "ingest-file", file.to_str().unwrap()])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.contains("readonly mode"), "stderr: {stderr}");
+}
+
+#[test]
+fn readonly_flag_blocks_reset() {
+    let (tmp, _ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--readonly", "reset", "--data-only", "--yes"])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.contains("readonly mode"), "stderr: {stderr}");
+}
+
+#[test]
+fn kebab_readonly_env_blocks_ingest() {
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["ingest", "--root", ws.to_str().unwrap()])
+        .env("KEBAB_READONLY", "1")
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.contains("readonly mode"), "stderr: {stderr}");
+}
+
+#[test]
+fn readonly_json_mode_emits_error_v1() {
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--readonly", "--json", "ingest", "--root", ws.to_str().unwrap()])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert_eq!(out.status.code(), Some(1), "expected exit 1");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    let v: serde_json::Value = serde_json::from_str(stderr.trim())
+        .unwrap_or_else(|e| panic!("expected error.v1 JSON on stderr, got {stderr:?}: {e}"));
+    assert_eq!(
+        v.get("schema_version").and_then(|s| s.as_str()),
+        Some("error.v1"),
+        "expected schema_version=error.v1"
+    );
+    assert_eq!(
+        v.get("code").and_then(|s| s.as_str()),
+        Some("readonly_mode"),
+        "expected code=readonly_mode"
+    );
+}
+
+#[test]
+fn quiet_flag_suppresses_progress_stderr() {
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--quiet", "ingest", "--root", ws.to_str().unwrap()])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert!(
+        out.status.success(),
+        "exit: {:?}, stderr: {}",
+        out.status.code(),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        stderr.is_empty(),
+        "expected empty stderr with --quiet, got: {stderr}"
+    );
+    // stdout should still have the human summary
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("scanned"),
+        "expected report summary on stdout, got: {stdout}"
+    );
+}
+
+#[test]
+fn quiet_with_json_stdout_has_report_stderr_is_empty() {
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["--quiet", "--json", "ingest", "--root", ws.to_str().unwrap()])
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.is_empty(), "expected empty stderr, got: {stderr}");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let last_line = stdout.lines().last().unwrap_or("");
+    let v: serde_json::Value = serde_json::from_str(last_line)
+        .unwrap_or_else(|e| panic!("expected JSON on stdout last line, got {last_line:?}: {e}"));
+    assert_eq!(
+        v.get("schema_version").and_then(|s| s.as_str()),
+        Some("ingest_report.v1")
+    );
+}
+```
+
+- [ ] **Step 2: Add KEBAB_PROGRESS=plain test to ingest_progress_cli.rs**
+
+Append this test to `crates/kebab-cli/tests/ingest_progress_cli.rs`:
+
+```rust
+#[test]
+fn kebab_progress_plain_env_emits_append_lines() {
+    // KEBAB_PROGRESS=plain forces non-TTY branch even in TTY-emulated envs.
+    // In subprocess tests there's no TTY anyway, so this primarily verifies
+    // the env var is accepted and the non-TTY path still works.
+    let (tmp, ws) = fixture_workspace();
+    let out = Command::new(kebab_bin())
+        .args(["ingest", "--root", ws.to_str().unwrap()])
+        .env("KEBAB_PROGRESS", "plain")
+        .envs(xdg_envs(tmp.path()))
+        .output()
+        .unwrap();
+
+    assert!(
+        out.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        stderr.contains("ingest: scanning"),
+        "expected 'ingest: scanning' in stderr, got: {stderr}"
+    );
+    assert!(
+        stderr.contains("ingest: complete"),
+        "expected 'ingest: complete' in stderr, got: {stderr}"
+    );
+}
+```
+
+- [ ] **Step 3: Build the binary**
+
+```bash
+cargo build -p kebab-cli 2>&1 | tail -5
+```
+
+- [ ] **Step 4: Run new tests**
+
+```bash
+cargo test -p kebab-cli --test cli_readonly_quiet 2>&1 | tail -20
+```
+
+Expected: all 7 tests pass.
+
+```bash
+cargo test -p kebab-cli --test ingest_progress_cli kebab_progress_plain_env 2>&1 | tail -10
+```
+
+Expected: 1 test passes.
+
+- [ ] **Step 5: Run full kebab-cli test suite**
+
+```bash
+cargo test -p kebab-cli 2>&1 | tail -20
+```
+
+Expected: all pass.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add crates/kebab-cli/tests/cli_readonly_quiet.rs crates/kebab-cli/tests/ingest_progress_cli.rs
+git commit -m "test(fb-26,fb-28): integration tests for readonly/quiet flags and KEBAB_PROGRESS=plain"
+```
+
+---
+
+## Task 6: Docs — HOTFIXES.md + task status + HANDOFF.md
+
+**Files:**
+- Modify: `tasks/HOTFIXES.md`
+- Modify: `tasks/p9/p9-fb-26-ingest-log-consistency.md`
+- Modify: `tasks/p9/p9-fb-28-agent-invocation-flags.md`
+- Modify: `tasks/INDEX.md`
+- Modify: `HANDOFF.md`
+
+- [ ] **Step 1: Add HOTFIXES entry**
+
+In `tasks/HOTFIXES.md`, find the existing entries and add a new dated entry. Append (or insert under the appropriate date):
+
+```markdown
+## 2026-05-07
+
+### fb-26: ingest log `Aborted` unconditional writeln + `Completed` TTY no summary
+
+- **File**: `crates/kebab-cli/src/progress.rs`
+- `Aborted` handler had an unconditional `writeln!` that fired in TTY mode too, duplicating output below `bar.abandon_with_message`. Fixed: guarded with `if !tty && !quiet`.
+- `Completed` TTY path called `bar.finish_and_clear()` with no subsequent summary line. Fixed: always emit `ingest: complete (...)` writeln when `!quiet`.
+- Added `KEBAB_PROGRESS=plain` env override to force non-TTY branch in CI pty wrappers.
+
+### fb-28: new error code `readonly_mode`
+
+- **File**: `crates/kebab-cli/src/main.rs`
+- `error.v1` `code: "readonly_mode"` added for `--readonly` / `KEBAB_READONLY=1` guard block. Constructed directly in `main()`, not via `classify()`.
+- Blocked subcommands: `ingest`, `ingest-file`, `ingest-stdin`, `reset`.
+```
+
+- [ ] **Step 2: Mark task specs as merged**
+
+In `tasks/p9/p9-fb-26-ingest-log-consistency.md`, change:
+
+```yaml
+status: open
+```
+
+to:
+
+```yaml
+status: merged
+```
+
+In `tasks/p9/p9-fb-28-agent-invocation-flags.md`, change:
+
+```yaml
+status: open
+```
+
+to:
+
+```yaml
+status: merged
+```
+
+- [ ] **Step 3: Update tasks/INDEX.md**
+
+Find the rows for `p9-fb-26` and `p9-fb-28` in `tasks/INDEX.md` and mark them done (⏳ → ✅ or equivalent per the existing format in the file).
+
+- [ ] **Step 4: Update HANDOFF.md**
+
+In `HANDOFF.md`, find the "머지 후 발견된 버그 / 결정 (요약)" section and add:
+
+```
+- fb-26: ingest log Aborted unconditional writeln (TTY dupe) + Completed TTY no summary fixed; KEBAB_PROGRESS=plain added
+- fb-28: --readonly (KEBAB_READONLY) blocks Ingest/IngestFile/IngestStdin/Reset; --quiet suppresses progress stderr; error.v1 code: "readonly_mode"
+```
+
+- [ ] **Step 5: Commit all docs**
+
+```bash
+git add tasks/HOTFIXES.md tasks/p9/p9-fb-26-ingest-log-consistency.md tasks/p9/p9-fb-28-agent-invocation-flags.md tasks/INDEX.md HANDOFF.md
+git commit -m "docs: mark fb-26 + fb-28 merged, HOTFIXES entry for readonly_mode + progress bugs"
+```

docs/superpowers/specs/2026-05-07-fb-26-fb-28-agent-ux-design.md

@@ -0,0 +1,149 @@
+---
+date: 2026-05-07
+tasks: [p9-fb-26, p9-fb-28, claude-md-schema-sync]
+title: "Agent UX improvements: ingest log consistency + invocation flags + schema list sync"
+status: approved
+target_version: 0.3.3
+branch: feat/p9-fb-26-fb-28-agent-ux
+---
+
+# Agent UX improvements
+
+Three bundled changes shipped as one PR: CLAUDE.md wire schema list sync (doc-only), ingest log consistency fix (fb-26), and agent invocation flags (fb-28).
+
+---
+
+## §1 — CLAUDE.md wire schema list sync
+
+### Problem
+
+`CLAUDE.md` §Wire schema v1 lists schemas that do not exist on disk, and omits schemas that do.
+
+| Schema | CLAUDE.md | `docs/wire-schema/v1/` |
+|---|---|---|
+| `eval_run.v1` | listed | **missing** |
+| `eval_compare.v1` | listed | **missing** |
+| `list_docs.v1` | listed | **missing** |
+| `chunk_inspection.v1` | **absent** | present |
+| `citation.v1` | **absent** | present |
+| `doc_summary.v1` | **absent** | present |
+
+### Fix
+
+Update the schema list in `CLAUDE.md` to match `docs/wire-schema/v1/` exactly. No other changes.
+
+**Correct list**: `ingest_report.v1`, `ingest_progress.v1`, `search_hit.v1`, `answer.v1`, `doctor.v1`, `reset_report.v1`, `schema.v1`, `error.v1`, `chunk_inspection.v1`, `citation.v1`, `doc_summary.v1`
+
+---
+
+## §2 — fb-26: Ingest log consistency
+
+### Problem
+
+`crates/kebab-cli/src/progress.rs` has two bugs that break the TTY/non-TTY symmetry:
+
+1. **`Aborted` handler** (`L170-188`): `writeln!` is unconditional — fires in TTY mode too, printing a duplicate summary below the spinner's abandoned message.
+2. **`Completed` TTY path** (`L153-169`): `bar.finish_and_clear()` clears the bar with no subsequent summary line. Users see the run end silently.
+
+Additionally, there is no escape hatch for CI environments that emulate a TTY (pty wrapper), which causes unintended spinner output in CI logs.
+
+### Design
+
+**Behavioral contract** (Option A — already the intent, bug-fixed):
+
+| Mode | Progress | Final summary |
+|---|---|---|
+| TTY | indicatif in-place spinner → progress bar | single `ingest: complete / aborted` writeln after bar clears |
+| non-TTY | append-only writeln per event | same `ingest: complete / aborted` writeln |
+| `--json` | silent stderr | `ingest_report.v1` stdout only |
+
+**Changes to `handle_human`:**
+
+1. `Completed` TTY: after `bar.finish_and_clear()`, add `writeln!(stderr, "ingest: complete (...)")`  — same format as non-TTY branch.
+2. `Aborted` TTY: wrap the existing unconditional `writeln!` in `if !tty { ... }`. The `bar.abandon_with_message(...)` already prints the spinner's final state on TTY.
+3. Unify summary format string: `ingest: complete (scanned={} new={} updated={} skipped={} errors={})` and `ingest: aborted (...)` — identical prefix in both modes.
+
+**`KEBAB_PROGRESS=plain` env override:**
+
+- When set (any non-empty value), force non-TTY branch regardless of `IsTerminal`.
+- Implemented in `ProgressMode::from_flags` — check `KEBAB_PROGRESS=plain` env, set `tty=false` when present.
+- Allows CI with pty wrappers to opt-in to append-only output explicitly.
+
+### Testing
+
+- Snapshot test: non-TTY stream for a minimal ingest (2-file TempDir KB) captures `ScanStarted`, `ScanCompleted`, `AssetStarted × 2`, `Completed` with correct prefixes.
+- `KEBAB_PROGRESS=plain` env: TTY path still uses append-only output.
+- `KEBAB_PROGRESS=plain` + `--json`: `--json` takes precedence, no human lines.
+- Manual smoke: `kebab ingest --config /tmp/... 2>&1 | cat` shows all event lines + final summary.
+
+---
+
+## §3 — fb-28: Agent invocation flags
+
+### Problem
+
+Agents invoking `kebab` face two issues:
+
+1. No way to enforce read-only KB access — a hallucinating agent could call `kebab reset` or `kebab ingest` unexpectedly.
+2. Progress/spinner output leaks to stderr even in non-TTY agent invocations where TTY is emulated, adding noise to agent context.
+
+### Design
+
+#### Global flags on `Cli`
+
+```
+kebab [--readonly] [--quiet] <subcommand> [...]
+```
+
+Both are global flags added to the `Cli` struct in `main.rs`. Evaluated before subcommand dispatch.
+
+#### `--readonly` / `KEBAB_READONLY=1`
+
+- Environment variable `KEBAB_READONLY=1` is equivalent to passing `--flag` (checked in `main` before dispatch; env wins if set).
+- **Blocked subcommands**: `ingest`, `ingest-file`, `ingest-stdin`, `reset` (all write-path commands). (`nuke` does not exist as a subcommand.)
+- **Allowed**: `search`, `ask`, `doctor`, `schema`, `mcp`, `tui` (read-path).
+- On block: exit code 1 + error output:
+  - `--json` mode: `error.v1` ndjson to stderr (`code: "readonly_mode"`, `message: "kebab: readonly mode — mutating commands are disabled"`)
+  - plain mode: single `kebab: readonly mode — mutating commands are disabled\n` to stderr
+- Implementation: `fn is_mutating(cmd: &Cmd) -> bool` + guard block in `main()` after flag parsing, before `match cli.cmd`.
+
+#### `--quiet`
+
+- Suppresses all human-readable stderr output: progress lines, hint messages.
+- Does **not** suppress `error.v1` ndjson (in `--json` mode) or plain error text — errors always reach stderr.
+- `--json` flag automatically implies `--quiet` behavior (already the case in practice; this makes it explicit and documented).
+- Implementation: extend `ProgressMode::Human { tty: bool }` → `Human { tty: bool, quiet: bool }`. Update `ProgressMode::from_flags(json: bool, quiet: bool, plain_env: bool) -> Self`. When `quiet=true` (or `--json`), `Human { tty: _, quiet: true }` overrides draw target to `hidden` and skips all `writeln!(stderr, ...)` calls in non-TTY branch. `ProgressDisplay::new(mode: ProgressMode)` signature unchanged.
+- `--quiet` without `--json` still emits `ingest_report.v1` to stdout at end (not suppressed).
+
+#### New `error.v1` code
+
+Construct `ErrorV1 { code: "readonly_mode", ... }` directly in the guard block in `main.rs` — no change to `classify()` (which dispatches on `anyhow::Error` types, not user-triggered state). Document the new code in `tasks/HOTFIXES.md`.
+
+### Testing
+
+- `kebab --readonly ingest` → exit 1, error message contains "readonly mode".
+- `kebab --readonly ingest --json` → exit 1, stderr contains `error.v1` with `code: "readonly_mode"`.
+- `KEBAB_READONLY=1 kebab ingest` → same as `--readonly`.
+- `kebab --readonly search "q"` → passes through normally.
+- `kebab --quiet ingest` → stderr silent during run, `ingest_report.v1` still on stdout.
+- `kebab ingest --json` → no human lines on stderr (auto-quiet behavior documented).
+
+---
+
+## Bundling rationale
+
+All three changes are small and independent — no shared code paths. Bundled into one branch to avoid PR noise for minor UX polish. The CLAUDE.md fix is doc-only and safe to merge first if needed.
+
+## Files changed (expected)
+
+| File | Change |
+|---|---|
+| `CLAUDE.md` | schema list update |
+| `crates/kebab-cli/src/main.rs` | `--readonly`, `--quiet` global flags + guard block |
+| `crates/kebab-cli/src/progress.rs` | Aborted/Completed bug fix, `KEBAB_PROGRESS=plain`, quiet threading |
+| `crates/kebab-app/src/error_wire.rs` | `"readonly_mode"` code |
+| `tasks/HOTFIXES.md` | new entry for `readonly_mode` error code |
+| `tasks/p9/p9-fb-26-ingest-log-consistency.md` | status → merged |
+| `tasks/p9/p9-fb-28-agent-invocation-flags.md` | status → merged |
+| `tasks/INDEX.md` | status update |
+| `HANDOFF.md` | one-liner |

integrations/claude-code/kebab/SKILL.md

@@ -5,7 +5,9 @@ description: Local knowledge base + RAG over the user's pre-indexed documents (w
 
 # kebab — local KB / RAG access
 
-`kebab` is a CLI installed at `~/.cargo/bin/kebab` (binary name: `kebab`). It indexes the user's personal documents and exposes them via lexical / vector / hybrid search and a local-LLM RAG answer. All output speaks frozen wire schema v1 — every JSON record carries a `schema_version` field.
+`kebab` indexes the user's personal documents and exposes them via lexical / vector / hybrid search and a local-LLM RAG answer. All output speaks frozen wire schema v1 — every JSON record carries a `schema_version` field.
+
+Two surfaces ship: an **MCP server** (`kebab mcp`, preferred — process stays hot across calls) and a **CLI** (`~/.cargo/bin/kebab`, fallback for hosts without MCP).
 
 ## When to invoke
 
@@ -24,56 +26,62 @@ Trigger when the user's question matches **any** of:
 
 User-specific trigger keywords (team names, system names, internal acronyms) belong in a per-user override of this SKILL.md, not in this repo-shipped version.
 
-## Two surfaces, pick the right one
+## MCP tools (preferred)
 
-### `kebab search` — when you need the source
+When `kebab` is registered as an MCP server (see `~/.claude/mcp.json` example below), six tools are exposed as `mcp__kebab__<name>`:
+
+| tool | purpose | mutation |
+|------|---------|----------|
+| `mcp__kebab__search` | corpus search → `search_hit.v1[]` | no |
+| `mcp__kebab__ask` | RAG answer → `answer.v1` | no |
+| `mcp__kebab__schema` | capability discovery → `schema.v1` | no |
+| `mcp__kebab__doctor` | health check → `doctor.v1` | no |
+| `mcp__kebab__ingest_file` | save single file → `ingest_report.v1` | yes |
+| `mcp__kebab__ingest_stdin` | save markdown blob → `ingest_report.v1` | yes |
+
+Mutation tools require explicit user intent — never auto-invoke.
+
+### `mcp__kebab__search` — when you need the source
 
 Use when the user wants to **find** a doc, or when you (the model) need raw chunks to reason from before answering.
 
-```bash
-kebab search "<query>" --mode hybrid --json
+Input:
+```json
+{ "query": "<query>", "mode": "hybrid", "k": 10 }
 ```
 
-- `--mode hybrid` is the default-correct choice. Use `vector` for semantic-only ("docs about X concept"), `lexical` for exact strings ("the literal flag `--foo-bar`").
-- Output is a JSON array of `search_hit.v1` objects. Key fields: `rank`, `score`, `doc_path`, `heading_path[]`, `section_label`, `snippet`, `citation` (has line range / page), `chunk_id`.
+- `mode = "hybrid"` is the default-correct choice. Use `"vector"` for semantic-only ("docs about X concept"), `"lexical"` for exact strings ("the literal flag `--foo-bar`").
+- Output is `search_hit.v1` array. Key fields: `rank`, `score`, `doc_path`, `heading_path[]`, `section_label`, `snippet`, `citation` (line range / page), `chunk_id`.
 - Cite back to the user as `doc_path § heading_path[-1]` so they can open the source.
 
-### `kebab ask` — when you need the answer
+### `mcp__kebab__ask` — when you need the answer
 
 Use when the user wants a synthesized answer, not a list of links.
 
-```bash
-kebab ask "<question>" --json
+Input:
+```json
+{ "query": "<question>", "session_id": "<optional-slug>", "mode": "hybrid" }
 ```
 
-- Returns one `answer.v1` object: `answer` (markdown), `citations[]`, `grounded` (bool), `refusal_reason`, `model`.
-- **If `grounded == false`** → the KB doesn't have enough context. Don't paraphrase the refusal as if it were an answer. Tell the user the KB came up dry and fall back to your own knowledge or ask for the source.
-- For follow-up turns on the same topic, pass `--session <stable-id>` so kebab gets prior history. Pick a slug (`team-onboarding-2026-05`) and reuse it across the conversation. Sessions persist across Claude sessions until `kebab reset --data-only`.
+- Returns `answer.v1`: `answer` (markdown), `citations[]`, `grounded` (bool), `refusal_reason`, `model`, `conversation_id`, `turn_index`.
+- **If `grounded == false`** → KB doesn't have enough context. Don't paraphrase the refusal as if it were an answer. Tell the user the KB came up dry and fall back to your own knowledge or ask for the source.
+- For follow-up turns on the same topic, pass `session_id` (e.g. `"team-onboarding-2026-05"`) and reuse it across the conversation. Sessions persist until `kebab reset --data-only`.
 
-## Parsing tips
+## CLI fallback
 
-- Both commands print **one JSON value to stdout**, progress / warnings to stderr. Capture stdout only: `kebab search ... --json 2>/dev/null`.
-- `search --json` output can be large for broad queries. Pipe through `jq` to project: `jq '.[] | {rank, doc_path, heading: .heading_path[-1], snippet}'`.
-- `ask --json`'s `citations[]` mirrors `search_hit.v1` minus retrieval internals — same `doc_path` / `citation` shape.
-- Schema reference lives in the kebab repo at `docs/wire-schema/v1/*.schema.json` if a field is unclear.
-
-## Capability discovery
-
-Before using streaming or multi-turn features, you can probe what this binary supports:
+If MCP tools aren't in scope (host without MCP support, or `mcp.json` not configured), call the CLI via Bash:
 
 ```bash
-kebab schema --json
+kebab search "<query>" --mode hybrid --json 2>/dev/null
+kebab ask "<question>" --json 2>/dev/null
+kebab ask "<question>" --session <stable-id> --json 2>/dev/null
 ```
 
-Returns a `schema.v1` object with: `wire.schemas` (supported wire ids), `capabilities` (bool flags — e.g. `streaming_ask`, `rag_multi_turn`), `models` (version cascade 6-axis), and `stats` (doc/chunk/asset count + last_ingest_at). Gate streaming / session flows on `capabilities.streaming_ask` / `capabilities.rag_multi_turn` being `true`. This call is cheap (no LLM) and can be run once per session.
+Same wire shapes as MCP. CLI pays cold start (~1-2s) per call — prefer MCP when available.
 
-## Quick health check
+## MCP host config
 
-If a call fails or returns suspicious output, run `kebab doctor` first — it surfaces config-load / data-dir / Ollama-reachability problems in one line each. Don't silently retry on errors; report the doctor output.
-
-## MCP server (recommended over CLI subprocess wrapping)
-
-Since v0.3.1, `kebab` exposes an MCP (Model Context Protocol) stdio server. Configure once in `~/.claude/mcp.json`:
+Register `kebab mcp` once in your host's MCP config. For Claude Code, edit `~/.claude/mcp.json`:
 
 ```json
 {
@@ -86,49 +94,62 @@ Since v0.3.1, `kebab` exposes an MCP (Model Context Protocol) stdio server. Conf
 }
 ```
 
-Claude Code spawns `kebab mcp` at session start; the process stays alive across all tool calls so SQLite / Lance / fastembed are hot after the first call. 6 tools available: `search` / `ask` / `schema` / `doctor` / `ingest_file` / `ingest_stdin`. Same wire shapes as the CLI `--json` mode — see `Two surfaces, pick the right one` above for the same guidance.
+Claude Code spawns `kebab mcp` at session start; the process stays alive across all tool calls so SQLite / Lance / fastembed are hot after the first call (~1-2s cold, sub-100ms thereafter). For Cursor / OpenAI Agents / Copilot CLI host examples plus per-tool input/output reference, see [docs/mcp-usage.md](../../../docs/mcp-usage.md) in the kebab repo.
 
-If your host doesn't support MCP, the CLI subprocess pattern (`kebab search --json` / `kebab ask --json`) above continues to work.
+## Parsing tips
 
-For per-tool input/output examples, error code reference, multi-turn ask + session management, and host config beyond Claude Code (Cursor / OpenAI Agents / Copilot CLI), see [docs/mcp-usage.md](../../../docs/mcp-usage.md) in the kebab repo.
+- MCP tools return JSON content blocks; CLI prints **one JSON value to stdout**, progress / warnings to stderr. Capture stdout only: `kebab search ... --json 2>/dev/null`.
+- `search` output can be large for broad queries. Project relevant fields when summarizing — for CLI: `jq '.[] | {rank, doc_path, heading: .heading_path[-1], snippet}'`.
+- `ask`'s `citations[]` mirrors `search_hit.v1` minus retrieval internals — same `doc_path` / `citation` shape.
+- Schema reference lives in the kebab repo at `docs/wire-schema/v1/*.schema.json` if a field is unclear.
 
-## Recipe D — agent fetched a web doc, save to KB
+## Capability discovery
 
-When you've fetched a markdown article (e.g. via WebFetch) that the user might query later:
+Before using streaming or multi-turn features, probe what this binary supports — call `mcp__kebab__schema` (or CLI `kebab schema --json`):
 
-1. Call MCP tool `ingest_stdin` with:
-   - `content`: the markdown body
-   - `title`: a stable title (article H1 or page title)
-   - `source_uri`: the URL you fetched from
+Returns `schema.v1`: `wire.schemas` (supported wire ids), `capabilities` (bool flags — e.g. `streaming_ask`, `rag_multi_turn`), `models` (version cascade 6-axis), `stats` (doc/chunk/asset count + last_ingest_at). Gate streaming / session flows on `capabilities.streaming_ask` / `capabilities.rag_multi_turn` being `true`. Cheap call (no LLM), once per session.
 
-The doc lands in `<workspace.root>/_external/<hash>.md` and is indexed for `search` / `ask` immediately. Subsequent calls with identical content are no-ops (incremental ingest detects unchanged hash).
+## Quick health check
 
-Don't loop ingest the same article — content-hash dedup makes it safe but wastes embedding cost.
-
-For files already on disk that the user references, prefer `ingest_file` with the path — kebab handles the copy + dedup.
+If a call fails or returns suspicious output, call `mcp__kebab__doctor` (or CLI `kebab doctor`) first — it surfaces config-load / data-dir / Ollama-reachability problems in one line each. Don't silently retry on errors; report the doctor output.
 
 ## Workflow recipes
 
 **Recipe A — user asks an internal-context question, you want grounded answer:**
 
-1. `kebab ask "<question>" --json`
-2. If `grounded`, cite `citations[].doc_path` in your reply and quote the user's `answer` (translate / condense as needed).
-3. If `!grounded`, switch to `kebab search "<question>" --mode hybrid --json` and look at top 3 hits — sometimes content exists but RAG threshold rejected it. If hits look relevant, summarize from snippets and cite. If still nothing, tell the user.
+1. Call `mcp__kebab__ask` (or CLI `kebab ask "<question>" --json`).
+2. If `grounded`, cite `citations[].doc_path` in your reply and quote the `answer` (translate / condense as needed).
+3. If `!grounded`, call `mcp__kebab__search` with the same query and look at top 3 hits — sometimes content exists but RAG threshold rejected it. If hits look relevant, summarize from snippets and cite. If still nothing, tell the user.
 
 **Recipe B — domain question where internal context might exist:**
 
-1. Run `kebab search "<key terms>" --mode hybrid --json` quickly (cheap, no LLM).
+1. Call `mcp__kebab__search` with key terms (cheap — no LLM).
 2. If top hit's `score` is low (< ~0.3) or no hits, answer from general knowledge without mentioning the KB.
 3. If top hit is relevant, fold its content into your answer and cite `doc_path`.
 
 **Recipe C — user wants to know "what's in the KB about X":**
 
-1. `kebab search "X" --mode hybrid --json | jq '.[] | {doc_path, heading: .heading_path[-1]}'`
+1. Call `mcp__kebab__search` with the topic.
 2. List unique `doc_path`s back to the user as a discovery surface.
 
+**Recipe D — agent fetched a web doc, save to KB:**
+
+When you've fetched a markdown article (e.g. via WebFetch) that the user might query later:
+
+1. Call `mcp__kebab__ingest_stdin` with:
+   - `content`: the markdown body
+   - `title`: a stable title (article H1 or page title)
+   - `source_uri`: the URL you fetched from
+
+The doc lands in `<workspace.root>/_external/<hash>.md` and is indexed for `search` / `ask` immediately. Subsequent calls with identical content are no-ops (content-hash dedup).
+
+Don't loop ingest the same article — dedup makes it safe but wastes embedding cost.
+
+For files already on disk the user references, prefer `mcp__kebab__ingest_file` with the path — kebab handles the copy + dedup.
+
 ## Don't
 
-- Don't run `kebab ingest` / `kebab reset` / `kebab init` automatically. Those mutate state — the user runs them.
+- Don't auto-invoke `mcp__kebab__ingest_file` / `mcp__kebab__ingest_stdin` / `kebab ingest` / `kebab reset` / `kebab init`. Those mutate state — the user must explicitly request.
 - Don't pass user-supplied raw text into the query without trimming — long queries (> a few hundred chars) waste embedding budget. Extract the question.
 - Don't fabricate `doc_path`s. If you didn't see a doc in `search` / `ask` output, it's not in the KB.
 - Don't use `kebab tui` from a skill — it's interactive only.

tasks/HOTFIXES.md

@@ -14,6 +14,39 @@ historical contract that was implemented; this file accumulates the
 deltas so phase 5+ readers can find the live behavior without diffing
 git history.
 
+## 2026-05-07 (2)
+
+### macOS XDG path collision: `data_dir` == `config_dir` → DataOnly reset deletes config
+
+- **File**: `crates/kebab-config/src/lib.rs`
+- **Root cause**: `dirs` crate 가 macOS 에서 `config_dir()` 과 `data_dir()` 모두 `~/Library/Application Support/` 반환. `ResetScope::DataOnly` 가 `data_dir` 을 삭제하면 config 파일까지 함께 삭제됨.
+- **Fix**: `xdg_config_path`, `xdg_data_dir`, `xdg_cache_dir` 의 `dirs` fallback 제거 → `$HOME/.config`, `$HOME/.local/share`, `$HOME/.cache` 직접 사용 (XDG 표준, 플랫폼 무관).
+- **Migration**: `Config::load(None)` 에서 새 경로 없고 macOS legacy (`~/Library/Application Support/kebab/config.toml`) 있으면 자동 copy + stderr 안내.
+- **New paths** (macOS):
+  - config: `~/.config/kebab/config.toml` (was `~/Library/Application Support/kebab/config.toml`)
+  - data: `~/.local/share/kebab/` (was `~/Library/Application Support/kebab/`)
+  - cache: `~/.cache/kebab/` (was `~/Library/Caches/kebab/`)
+  - state: `~/.local/state/kebab/` (unchanged)
+
+## 2026-05-07
+
+### fb-26: ingest 로그 `Aborted` 무조건 writeln + `Completed` TTY 요약 없음
+
+- **File**: `crates/kebab-cli/src/progress.rs`
+- `Aborted` 핸들러가 TTY 모드에서도 무조건 `writeln!` 하여 `bar.abandon_with_message` 아래에 중복 출력 발생. Fixed: `if !tty && !quiet` 로 가드.
+- `Completed` TTY 경로가 `bar.finish_and_clear()` 호출 후 요약 라인 없음. Fixed: `!quiet` 일 때 항상 `ingest: complete (...)` writeln 출력.
+- `KEBAB_PROGRESS=plain` env override 추가 — CI pty wrapper 에서 TTY 감지 강제 제거.
+- `ProgressMode::Human` 에 `quiet: bool` 필드 추가; `--quiet` flag 전체 progress stderr 억제.
+
+### fb-28: `--readonly` / `--quiet` 전역 flag + `readonly_mode` error code
+
+- **File**: `crates/kebab-cli/src/main.rs`
+- `--readonly` (또는 `KEBAB_READONLY=1`) — mutating subcommand (`ingest`, `ingest-file`, `ingest-stdin`, `reset`) 차단. exit code 1.
+- `--json --readonly` — stderr 로 `error.v1` 신규 code: `"readonly_mode"` emit.
+- `--quiet` — 모든 human-readable stderr (progress, hint) 억제; error 는 여전히 stderr 도달.
+- `--json` 자동 quiet 함축 (명시적 현재).
+- `error.v1` code: `"readonly_mode"` main() guard block 에서 직접 construction (classify() 경로 아님).
+
 ## 2026-05-07 — p9-fb-31 (post-dogfooding): single-file / stdin ingest
 
 **Source feedback**: 사용자 도그푸딩 2026-05-06 — agent (Claude Code via MCP, fb-30) 가 web fetch 한 markdown / 단일 외부 file 을 KB 에 저장하려면 `kebab ingest` 전체 walk 재실행 비효율. agent 메모리상 string contents 도 stdin ingest 가능해야.

tasks/INDEX.md

@@ -109,15 +109,15 @@ P0~P5 는 직렬. P6~P9 는 P5 이후 병렬 가능.
   - [p9-fb-23 incremental ingest (post-도그푸딩)](p9/p9-fb-23-incremental-ingest.md)
   - [p9-fb-24 status bar + Library header + page scroll (post-도그푸딩)](p9/p9-fb-24-tui-affordances.md)
   - [p9-fb-25 config workspace.include 제거 + 지원 형식 가시성 (post-도그푸딩)](p9/p9-fb-25-config-include-removal.md)
-  - **⏳ fb-26 ~ fb-42: 백로그 only — 미구현 + brainstorm 선행 필요.** spec 작성 시 [superpowers:brainstorming](../docs/superpowers/) 부터 시작. status: open. 다른 세션에서 이 그룹 손대기 전 사용자 확인 필요. **번호 = release 순서** — 작은 번호일수록 먼저 작업 (2026-05-06 renumber).
+  - **⏳ fb-32 ~ fb-42: 백로그 only — 미구현 + brainstorm 선행 필요.** spec 작성 시 [superpowers:brainstorming](../docs/superpowers/) 부터 시작. status: open. 다른 세션에서 이 그룹 손대기 전 사용자 확인 필요. **번호 = release 순서** — 작은 번호일수록 먼저 작업 (2026-05-06 renumber).
 
-    ### 🎯 0.3.0+ — agent foundation (MCP + introspection)
-    - [p9-fb-26 ingest 로그 출력 일관성](p9/p9-fb-26-ingest-log-consistency.md) — ⏳ 미구현, brainstorm 필요
+    ### 🎯 0.3.x — agent foundation (MCP + introspection) ✅ 완료
+    - [p9-fb-26 ingest 로그 출력 일관성](p9/p9-fb-26-ingest-log-consistency.md) — ✅ 머지 (2026-05-07)
     - [p9-fb-27 introspection + structured error wire](p9/p9-fb-27-introspection-and-error-wire.md) — ✅ 머지 + v0.3.0 cut (2026-05-07)
-    - [p9-fb-28 agent invocation flags (--readonly / --quiet)](p9/p9-fb-28-agent-invocation-flags.md) — ⏳ 미구현, brainstorm 필요
+    - [p9-fb-28 agent invocation flags (--readonly / --quiet)](p9/p9-fb-28-agent-invocation-flags.md) — ✅ 머지 (2026-05-07)
     - [p9-fb-29 HTTP daemon (`kebab serve`)](p9/p9-fb-29-http-daemon.md) — 🚫 deferred (2026-05-07) — fb-30 stdio MCP 가 동일 가치 제공, daemon 복잡도 회피. P+ 재개 trigger 는 spec 참조.
-    - [p9-fb-30 MCP server](p9/p9-fb-30-mcp-server.md) — ⏳ 미구현, brainstorm 필요 (depends_on 27 ✅, stdio-only)
-    - [p9-fb-31 single-file / stdin ingest](p9/p9-fb-31-single-file-stdin-ingest.md) — ⏳ 미구현, brainstorm 필요
+    - [p9-fb-30 MCP server](p9/p9-fb-30-mcp-server.md) — ✅ 머지 + v0.3.1 cut (2026-05-07)
+    - [p9-fb-31 single-file / stdin ingest](p9/p9-fb-31-single-file-stdin-ingest.md) — ✅ 머지 + v0.3.2 cut (2026-05-07)
 
     ### 🎯 0.4.0 — agent surface refinement (additive only)
     - [p9-fb-32 stale doc indicator](p9/p9-fb-32-stale-doc-indicator.md) — ⏳ 미구현, brainstorm 필요

tasks/p9/p9-fb-26-ingest-log-consistency.md

@@ -3,7 +3,7 @@ phase: P9
 component: kebab-cli
 task_id: p9-fb-26
 title: "Ingest 로그 출력 일관성 (in-place vs 새 줄 혼재)"
-status: open
+status: merged
 target_version: 0.3.0
 depends_on: [p9-fb-02]
 unblocks: []

tasks/p9/p9-fb-28-agent-invocation-flags.md

@@ -3,7 +3,7 @@ phase: P9
 component: kebab-cli + kebab-app
 task_id: p9-fb-28
 title: "Agent invocation flags (--readonly + --quiet)"
-status: open
+status: merged
 target_version: 0.3.0
 depends_on: []
 unblocks: []