feat(ui+cli): fuzzy search (bfd) + --output-format stream-json (rmk); audit bash escape (umm = already-done)

Six-feature audit against maki + Claude Code. Findings:

| Feature | Status | Notes |
|---|---|---|
| SSRF on webfetch | ✅ | `validate_url_host_safety` covers loopback, link-local AWS metadata, IPv6, env-gated escape |
| `/btw` chat-isolated query | ✅ | `provider.rs:500 btw_query` |
| Ctrl-F search | ✅ now FUZZY | this commit — port `nucleo-matcher` |
| `! / !! bash escape` | ✅ | `src/shell.rs` + wired at `ui/mod.rs:1706/1737`; initial audit missed it |
| `--print --output-format stream-json` | ✅ | this commit — port maki's `OutputFormat` + Claude-shaped JSON envelopes |
| `/tasks` + Ctrl-X subagent windows + Ctrl-N/P | ❌ | tracked as dirge-ov2; bigger refactor — touches Renderer buffer model + keybindings, will coordinate before starting |

## dirge-bfd: fuzzy Ctrl-F via nucleo-matcher

`update_search` (`ui/mod.rs:4937`) was a `to_lowercase().contains()`
substring filter — failed on typos, partial words, out-of-order
keystrokes. Ported from maki
(`maki-ui/src/components/search_modal.rs:147-185`):

- Add `nucleo-matcher = "0.3"` to Cargo.toml (same dep maki uses)
- `Atom::new(.., AtomKind::Fuzzy, ..)` with `CaseMatching::Smart` +
  `Normalization::Smart` — case-insensitive when query is lowercase,
  case-sensitive when mixed; Unicode-normalized so `naïve` matches
  `naive`
- Collect `(line_idx, score)` pairs, sort by score descending,
  tie-break on earlier line for stable ordering
- Empty / whitespace queries clear matches (same as maki)

Regression test added — fuzzy `ctd` query matches `connect to
database` via non-contiguous subsequence, which the prior substring
matcher couldn't find.

## dirge-rmk: --output-format stream-json

Headless `--print` previously emitted plain text only. Ported from
maki's `OutputFormat` enum + Claude Code's NDJSON shape so tooling
written against `claude --print --output-format stream-json` works
against dirge unchanged.

New CLI: `--output-format text | json | stream-json` (gated on
`--print`).

- `Text` (default): unchanged behavior — raw response streamed
  inline.
- `Json`: suppresses inline streaming, emits ONE result envelope
  on stdout at completion: `{ type: "result", subtype: "success",
  is_error, duration_ms, num_turns, result, session_id,
  total_cost_usd }`. Same field shape as Claude.
- `StreamJson`: NDJSON. Emits `system/init` event at start
  (cwd, session_id, tools, model) + an `assistant` event per turn
  + a final `result` envelope. One JSON object per line.

`run_print` signature gained an `output_format: OutputFormat`
parameter; suppression flag derived from format. Reasoning text
(stderr) is also suppressed under Json/StreamJson so JSON output
stays clean of chain-of-thought.

Added a small UUIDv4 generator (`uuid_v4_simple`) so dirge doesn't
need to pull the `uuid` crate just for the session_id field.

## Test

1222/1223 pass (pre-existing Clojure failure unchanged). Smoke-
tested `dirge --help` confirms `--output-format` shows up with the
right enum values. Binary at ~/bin/dirge.

Author: Yogthos

.beads/issues.jsonl

@@ -73,6 +73,10 @@ uuid = { version = "1", features = ["v4", "serde"] }
 thiserror = "2"
 futures = "0.3"
 reqwest = "0.13"
+# Fuzzy matcher for Ctrl-F search (dirge-bfd). Same crate maki uses for
+# its scrollback fuzzy search; matches by score with smart-case +
+# Unicode normalization, no need to roll our own ranking.
+nucleo-matcher = "0.3"
 dirs = "6"
 compact_str = { version = "0.9", features = ["serde"] }
 smallvec = "1"

Cargo.lock

@@ -126,17 +126,53 @@ pub fn convert_history(session: &Session) -> Vec<Message> {
 
     messages
 }
+/// dirge-rmk: emit one stream-json event line to stdout. NDJSON shape
+/// matches Claude Code so tooling written against `claude --print
+/// --output-format stream-json` works against dirge unchanged.
+fn emit_stream_json_event(value: serde_json::Value) {
+    if let Ok(s) = serde_json::to_string(&value) {
+        println!("{}", s);
+        let _ = std::io::Write::flush(&mut std::io::stdout());
+    }
+}
+
 pub async fn run_print<M, P>(
     agent: &Agent<M, P>,
     prompt: &str,
     max_turns: usize,
     chunk_timeout: std::time::Duration,
+    output_format: crate::cli::OutputFormat,
 ) -> anyhow::Result<String>
 where
     M: CompletionModel + 'static,
     M::StreamingResponse: Send + Sync + Unpin + Clone + 'static,
     P: rig::agent::PromptHook<M> + 'static,
 {
+    let start_instant = std::time::Instant::now();
+    let session_id = uuid_v4_simple();
+    let mut num_turns: u32 = 0;
+    // For Json / StreamJson modes the assistant text is BUFFERED
+    // (never streamed inline to stdout) so the JSON envelope is the
+    // only thing the user sees on stdout. Text mode keeps the prior
+    // streaming behavior.
+    let suppress_inline = !matches!(output_format, crate::cli::OutputFormat::Text);
+
+    // StreamJson init event — fires once at startup so downstream
+    // tools can pick up cwd/session/model before any turns stream.
+    // Ported from maki print.rs:67-75 (InitEvent shape).
+    if matches!(output_format, crate::cli::OutputFormat::StreamJson) {
+        let cwd = std::env::current_dir()
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_default();
+        emit_stream_json_event(serde_json::json!({
+            "type": "system",
+            "subtype": "init",
+            "cwd": cwd,
+            "session_id": session_id,
+            "tools": Vec::<String>::new(),
+            "model": "",
+        }));
+    }
     // Retry loop. Print mode (`dirge --print "..."`) is commonly used
     // in scripts and CI where a single transient 502 or rate-limit
     // would otherwise turn a 5-line shell snippet into a flaky one.
@@ -176,15 +212,24 @@ where
                     text,
                 ))) => {
                     full_response.push_str(&text.text);
-                    print!("{}", text.text);
-                    let _ = std::io::Write::flush(&mut std::io::stdout());
+                    if !suppress_inline {
+                        print!("{}", text.text);
+                        let _ = std::io::Write::flush(&mut std::io::stdout());
+                    }
                     had_output = true;
                 }
                 Ok(MultiTurnStreamItem::StreamAssistantItem(
                     StreamedAssistantContent::Reasoning(r),
                 )) => {
-                    eprint!("{}", r.display_text());
-                    let _ = std::io::Write::flush(&mut std::io::stderr());
+                    if !suppress_inline {
+                        // Json / StreamJson modes: reasoning is the
+                        // model's internal thinking — not part of the
+                        // user-visible result. Suppressing keeps the
+                        // JSON output clean of chain-of-thought
+                        // noise.
+                        eprint!("{}", r.display_text());
+                        let _ = std::io::Write::flush(&mut std::io::stderr());
+                    }
                 }
                 Ok(MultiTurnStreamItem::FinalResponse(_)) => break,
                 Ok(_) => {}
@@ -222,7 +267,96 @@ where
             return Err(anyhow::anyhow!("{}", msg));
         }
 
-        println!();
+        // dirge-rmk: turn complete. Bump turn counter; emit per-format
+        // closing payload. Ported from maki print.rs:51-64
+        // (`PrintResult`) and the StreamJson assistant event shape.
+        num_turns += 1;
+        match output_format {
+            crate::cli::OutputFormat::Text => {
+                println!();
+            }
+            crate::cli::OutputFormat::Json => {
+                // Single Claude-shaped result object. `total_cost_usd`
+                // is 0.0 until provider cost plumbing lands.
+                let result = serde_json::json!({
+                    "type": "result",
+                    "subtype": "success",
+                    "is_error": false,
+                    "duration_ms": start_instant.elapsed().as_millis() as u64,
+                    "num_turns": num_turns,
+                    "result": full_response.clone(),
+                    "session_id": session_id,
+                    "total_cost_usd": 0.0,
+                });
+                if let Ok(s) = serde_json::to_string(&result) {
+                    println!("{}", s);
+                }
+            }
+            crate::cli::OutputFormat::StreamJson => {
+                // Per-turn assistant event + closing result event.
+                emit_stream_json_event(serde_json::json!({
+                    "type": "assistant",
+                    "message": {
+                        "role": "assistant",
+                        "content": [{"type": "text", "text": full_response.clone()}],
+                    },
+                    "session_id": session_id,
+                }));
+                emit_stream_json_event(serde_json::json!({
+                    "type": "result",
+                    "subtype": "success",
+                    "is_error": false,
+                    "duration_ms": start_instant.elapsed().as_millis() as u64,
+                    "num_turns": num_turns,
+                    "result": full_response.clone(),
+                    "session_id": session_id,
+                    "total_cost_usd": 0.0,
+                }));
+            }
+        }
         return Ok(full_response);
     }
 }
+
+/// Generate a UUIDv4-shaped session id without pulling the `uuid`
+/// crate (dirge already has enough deps). Random bytes via system
+/// time + thread id seeded into a small xorshift.
+fn uuid_v4_simple() -> String {
+    use std::time::{SystemTime, UNIX_EPOCH};
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_nanos() as u64)
+        .unwrap_or(0);
+    let pid = std::process::id() as u64;
+    let mut state = nanos.wrapping_mul(0x9E37_79B9_7F4A_7C15).wrapping_add(pid);
+    let mut bytes = [0u8; 16];
+    for chunk in bytes.chunks_mut(8) {
+        state ^= state << 13;
+        state ^= state >> 7;
+        state ^= state << 17;
+        let words = state.to_le_bytes();
+        chunk.copy_from_slice(&words[..chunk.len()]);
+    }
+    // Set version (4) + variant (10) bits per RFC 4122.
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    format!(
+        "{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
+        bytes[0],
+        bytes[1],
+        bytes[2],
+        bytes[3],
+        bytes[4],
+        bytes[5],
+        bytes[6],
+        bytes[7],
+        bytes[8],
+        bytes[9],
+        bytes[10],
+        bytes[11],
+        bytes[12],
+        bytes[13],
+        bytes[14],
+        bytes[15],
+    )
+}

Cargo.toml

@@ -1,14 +1,46 @@
-use clap::Parser;
+use clap::{Parser, ValueEnum};
 use compact_str::CompactString;
 
 use crate::config;
 
+/// dirge-rmk: output format selector for `--print` mode. Ported from
+/// maki's `OutputFormat` enum (`maki/src/print.rs:44-49`) which itself
+/// matches Claude Code's `--output-format` so tools/scripts written
+/// against Claude Code work against dirge unchanged.
+///
+/// - `Text` (default): the raw assistant response only, no metadata.
+/// - `Json`: a single Claude-Code-shaped `PrintResult` object on
+///   stdout with `result`, `duration_ms`, `num_turns`, `usage`, etc.
+/// - `StreamJson`: NDJSON — one JSON object per line. Emits
+///   `system/init`, `assistant`, and a final `result` event so
+///   downstream tools can stream-parse turn-by-turn.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, ValueEnum, Default)]
+#[clap(rename_all = "kebab-case")]
+pub enum OutputFormat {
+    #[default]
+    Text,
+    Json,
+    StreamJson,
+}
+
 #[derive(Parser, Debug)]
 #[command(name = "dirge", version, about = "Minimal coding agent")]
 pub struct Cli {
     #[arg(short = 'p', long = "print", help = "Print response and exit")]
     pub print: bool,
 
+    /// dirge-rmk: output format for `--print` mode (text | json |
+    /// stream-json). Mirrors Claude Code's flag exactly. Ignored
+    /// outside `--print`.
+    #[arg(
+        long = "output-format",
+        value_enum,
+        default_value_t = OutputFormat::Text,
+        requires = "print",
+        help = "Output format for --print mode (text | json | stream-json)"
+    )]
+    pub output_format: OutputFormat,
+
     #[arg(short = 'c', long = "continue", help = "Continue most recent session")]
     pub continue_session: bool,
 

src/agent/runner.rs

@@ -636,7 +636,7 @@ async fn main() -> anyhow::Result<()> {
         .await;
         let msg = cli.message.join(" ");
         let response = agent
-            .run_print(&msg, cli.resolve_max_agent_turns(&cfg))
+            .run_print(&msg, cli.resolve_max_agent_turns(&cfg), cli.output_format)
             .await?;
         if !cli.no_session {
             session.add_message(MessageRole::User, &msg);
@@ -832,7 +832,11 @@ async fn run_headless_loop(
         eprintln!();
 
         let response = match agent
-            .run_print(&iteration_prompt, cli.resolve_max_agent_turns(cfg))
+            .run_print(
+                &iteration_prompt,
+                cli.resolve_max_agent_turns(cfg),
+                cli.output_format,
+            )
             .await
         {
             Ok(r) => r,

src/cli.rs

@@ -569,17 +569,23 @@ impl AnyAgent {
         }
     }
 
-    pub async fn run_print(&self, prompt: &str, max_turns: usize) -> anyhow::Result<String> {
+    pub async fn run_print(
+        &self,
+        prompt: &str,
+        max_turns: usize,
+        output_format: crate::cli::OutputFormat,
+    ) -> anyhow::Result<String> {
         let t = self.chunk_timeout;
+        let f = output_format;
         match &self.inner {
-            AnyAgentInner::OpenRouter(a) => runner::run_print(a, prompt, max_turns, t).await,
-            AnyAgentInner::OpenAI(a) => runner::run_print(a, prompt, max_turns, t).await,
-            AnyAgentInner::Anthropic(a) => runner::run_print(a, prompt, max_turns, t).await,
-            AnyAgentInner::Gemini(a) => runner::run_print(a, prompt, max_turns, t).await,
-            AnyAgentInner::DeepSeek(a) => runner::run_print(a, prompt, max_turns, t).await,
-            AnyAgentInner::Glm(a) => runner::run_print(a, prompt, max_turns, t).await,
-            AnyAgentInner::Ollama(a) => runner::run_print(a, prompt, max_turns, t).await,
-            AnyAgentInner::Custom(a) => runner::run_print(a, prompt, max_turns, t).await,
+            AnyAgentInner::OpenRouter(a) => runner::run_print(a, prompt, max_turns, t, f).await,
+            AnyAgentInner::OpenAI(a) => runner::run_print(a, prompt, max_turns, t, f).await,
+            AnyAgentInner::Anthropic(a) => runner::run_print(a, prompt, max_turns, t, f).await,
+            AnyAgentInner::Gemini(a) => runner::run_print(a, prompt, max_turns, t, f).await,
+            AnyAgentInner::DeepSeek(a) => runner::run_print(a, prompt, max_turns, t, f).await,
+            AnyAgentInner::Glm(a) => runner::run_print(a, prompt, max_turns, t, f).await,
+            AnyAgentInner::Ollama(a) => runner::run_print(a, prompt, max_turns, t, f).await,
+            AnyAgentInner::Custom(a) => runner::run_print(a, prompt, max_turns, t, f).await,
         }
     }