buildwithnexus 0.11.0 → 0.11.2

package/harness/Cargo.lock

@@ -49,7 +49,7 @@ checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
 
 [[package]]
 name = "buildwithnexus"
-version = "0.11.0"
+version = "0.11.2"
 dependencies = [
  "criterion",
  "crossterm",

package/harness/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "buildwithnexus"
-version = "0.11.0"
+version = "0.11.2"
 edition = "2021"
 description = "A hilariously fast agentic AI CLI harness — remote or local models, full TUI with modes, memory, skills, hooks, and image input"
 license = "MIT"

package/harness/src/agent.rs

@@ -721,22 +721,73 @@ fn parse_text_tool_calls(text: &str, defs: &[tools::ToolDef]) -> Option<Vec<prov
 
 fn extract_json_tool_candidate(text: &str) -> Option<&str> {
     let trimmed = text.trim();
+    // Whole-text JSON (the strict, original case).
     if trimmed.starts_with('{') || trimmed.starts_with('[') {
         return Some(trimmed);
     }
-    let rest = trimmed.strip_prefix("```")?;
-    let fence_end = rest.find('\n')?;
-    let lang = rest[..fence_end].trim().to_ascii_lowercase();
-    if !lang.is_empty() && lang != "json" {
-        return None;
+    // A fenced ```json block that is the entire message.
+    if let Some(rest) = trimmed.strip_prefix("```") {
+        if let Some(fence_end) = rest.find('\n') {
+            let lang = rest[..fence_end].trim().to_ascii_lowercase();
+            if lang.is_empty() || lang == "json" {
+                let body = &rest[fence_end + 1..];
+                if let Some(close) = body.rfind("```") {
+                    if body[close + 3..].trim().is_empty() {
+                        return Some(body[..close].trim());
+                    }
+                }
+            }
+        }
     }
-    let body = &rest[fence_end + 1..];
-    let close = body.rfind("```")?;
-    let after = body[close + 3..].trim();
-    if !after.is_empty() {
-        return None;
+    // XML-tagged tool calls. Small local coders (notably Qwen2.5-Coder on
+    // llama.cpp/Ollama) emit calls as `<tools>{…}</tools>` or
+    // `<tool_call>{…}</tool_call>` text in `content` instead of native
+    // tool_calls. Pull the first balanced JSON object out of the tagged region.
+    for tag in ["<tools>", "<tool_call>", "<function_call>", "<function>"] {
+        if let Some(pos) = text.find(tag) {
+            if let Some(json) = balanced_json_object(&text[pos + tag.len()..]) {
+                return Some(json);
+            }
+        }
+    }
+    // A bare object embedded in prose (a leading sentence, then the JSON).
+    balanced_json_object(text)
+}
+
+// Return the first balanced `{…}` slice, tracking string state so braces inside
+// JSON string values (e.g. CSS `{ }` inside an HTML `content` field) don't end
+// the object early. None if there's no `{` or it never closes (truncated output).
+fn balanced_json_object(text: &str) -> Option<&str> {
+    let bytes = text.as_bytes();
+    let start = text.find('{')?;
+    let mut depth = 0usize;
+    let mut in_string = false;
+    let mut escaped = false;
+    for i in start..bytes.len() {
+        let c = bytes[i];
+        if in_string {
+            if escaped {
+                escaped = false;
+            } else if c == b'\\' {
+                escaped = true;
+            } else if c == b'"' {
+                in_string = false;
+            }
+            continue;
+        }
+        match c {
+            b'"' => in_string = true,
+            b'{' => depth += 1,
+            b'}' => {
+                depth -= 1;
+                if depth == 0 {
+                    return Some(&text[start..=i]);
+                }
+            }
+            _ => {}
+        }
     }
-    Some(body[..close].trim())
+    None
 }
 
 fn collect_text_tool_calls(
@@ -3227,6 +3278,67 @@ mod tests {
         assert_eq!(normalized.calls[0].input["command"], "npm start");
     }
 
+    #[test]
+    fn qwen_tools_tagged_call_with_css_braces_is_parsed() {
+        // The real failure from an end-to-end run against qwen2.5-coder-1.5b on
+        // llama.cpp: the model emits its call as `<tools>{…}</tools>` text with
+        // an HTML `content` field whose CSS contains `{ }`. The balanced-object
+        // scanner must not stop at the first CSS brace.
+        let defs = tools::defs_for_context(true, 128_000);
+        let reply = Reply {
+            text: "<tools>{\"name\":\"write_file\",\"arguments\":{\"path\":\"index.html\",\"content\":\"<style>body { color: #ff6faa; } .hero { padding: 2rem; }</style>\"}}</tools>".to_string(),
+            ..Default::default()
+        };
+        let normalized = normalize_text_tool_calls(reply, &defs, "build a donut shop site");
+        assert_eq!(normalized.calls.len(), 1, "text: unparsed");
+        assert_eq!(normalized.calls[0].name, "write_file");
+        assert_eq!(normalized.calls[0].input["path"], "index.html");
+        assert!(normalized.calls[0].input["content"]
+            .as_str()
+            .unwrap()
+            .contains("#ff6faa"));
+    }
+
+    #[test]
+    fn tool_call_tagged_and_embedded_json_variants_parse() {
+        let defs = tools::defs_for_context(true, 128_000);
+        // Hermes/Qwen `<tool_call>` wrapper.
+        let a = normalize_text_tool_calls(
+            Reply {
+                text: "<tool_call>{\"name\":\"read_file\",\"arguments\":{\"path\":\"a.txt\"}}</tool_call>"
+                    .to_string(),
+                ..Default::default()
+            },
+            &defs,
+            "read it",
+        );
+        assert_eq!(a.calls.len(), 1);
+        assert_eq!(a.calls[0].name, "read_file");
+        // A leading sentence, then a bare JSON object.
+        let b = normalize_text_tool_calls(
+            Reply {
+                text: "Sure, I'll do that now. {\"name\":\"read_file\",\"arguments\":{\"path\":\"b.txt\"}}"
+                    .to_string(),
+                ..Default::default()
+            },
+            &defs,
+            "read it",
+        );
+        assert_eq!(b.calls.len(), 1);
+        assert_eq!(b.calls[0].input["path"], "b.txt");
+    }
+
+    #[test]
+    fn balanced_json_object_respects_strings_and_truncation() {
+        assert_eq!(
+            balanced_json_object("x {\"a\":\"}{\"} y"),
+            Some("{\"a\":\"}{\"}")
+        );
+        // Unterminated object (truncated at the token limit) yields nothing.
+        assert_eq!(balanced_json_object("{\"a\": {\"b\": 1"), None);
+        assert_eq!(balanced_json_object("no braces here"), None);
+    }
+
     #[test]
     fn casual_text_json_mutating_tool_call_is_ignored() {
         let defs = tools::defs_for_context(true, 128_000);

package/harness/src/provider.rs

@@ -531,7 +531,7 @@ fn anthropic_parse(v: Value) -> Result<Reply, String> {
     }
     let stop_reason = v["stop_reason"].as_str().map(normalize_stop_reason);
     Ok(Reply {
-        text,
+        text: strip_think(&text),
         calls,
         stop_reason,
     })
@@ -729,9 +729,35 @@ fn openai_request_at(
     (req, body)
 }
 
+// Remove `<think>…</think>` reasoning blocks that local reasoning models
+// (DeepSeek-R1 distills, Qwen thinking variants) emit inline in `content` on
+// the non-streaming path. Handles multiple blocks and an unclosed `<think>`
+// (drops the trailing leaked chain-of-thought). Text without think tags is
+// returned untouched. The streaming path already routes these to on_thinking.
+fn strip_think(text: &str) -> String {
+    if !text.contains("<think>") {
+        return text.to_string();
+    }
+    let mut out = String::with_capacity(text.len());
+    let mut rest = text;
+    while let Some(start) = rest.find("<think>") {
+        out.push_str(&rest[..start]);
+        let after = &rest[start + "<think>".len()..];
+        match after.find("</think>") {
+            Some(end) => rest = &after[end + "</think>".len()..],
+            None => {
+                rest = "";
+                break;
+            }
+        }
+    }
+    out.push_str(rest);
+    out.trim().to_string()
+}
+
 fn openai_parse(v: Value) -> Result<Reply, String> {
     let msg = &v["choices"][0]["message"];
-    let text = msg["content"].as_str().unwrap_or_default().to_string();
+    let text = strip_think(msg["content"].as_str().unwrap_or_default());
     let mut calls = Vec::new();
     if let Some(tcs) = msg["tool_calls"].as_array() {
         for tc in tcs {
@@ -756,14 +782,38 @@ fn openai_parse(v: Value) -> Result<Reply, String> {
     })
 }
 
+// If `s` ends with a non-empty *proper* prefix of `tag` (e.g. "a<thi" for
+// "<think>"), split so the prefix can be held until the next chunk completes it.
+// Returns (emit, hold). No trailing partial → (s, "").
+fn split_trailing_partial<'a>(s: &'a str, tag: &str) -> (&'a str, &'a str) {
+    let max = (tag.len() - 1).min(s.len());
+    for k in (1..=max).rev() {
+        if s.is_char_boundary(s.len() - k) && s.as_bytes().ends_with(&tag.as_bytes()[..k]) {
+            return (&s[..s.len() - k], &s[s.len() - k..]);
+        }
+    }
+    (s, "")
+}
+
+// Route streamed OpenAI/Ollama `content` deltas: `<think>…</think>` spans go to
+// `on_thinking`, everything else to `text`/`on_text`. `carry` holds a `<think>`
+// or `</think>` tag that was split across chunk boundaries (routine with
+// token-by-token local streaming) so the partial marker isn't leaked as output.
 fn route_openai_content(
     chunk: &str,
     in_think: &mut bool,
+    carry: &mut String,
     text: &mut String,
     on_text: &mut dyn FnMut(&str),
     on_thinking: &mut dyn FnMut(&str),
 ) {
-    let mut rest = chunk;
+    let combined = if carry.is_empty() {
+        chunk.to_string()
+    } else {
+        format!("{carry}{chunk}")
+    };
+    carry.clear();
+    let mut rest = combined.as_str();
     loop {
         if *in_think {
             if let Some(end) = rest.find("</think>") {
@@ -777,9 +827,12 @@ fn route_openai_content(
                     break;
                 }
             } else {
-                if !rest.is_empty() {
-                    on_thinking(rest);
+                // Hold a possible partial `</think>` at the tail for next chunk.
+                let (emit, hold) = split_trailing_partial(rest, "</think>");
+                if !emit.is_empty() {
+                    on_thinking(emit);
                 }
+                *carry = hold.to_string();
                 break;
             }
         } else if let Some(start) = rest.find("<think>") {
@@ -794,15 +847,33 @@ fn route_openai_content(
                 break;
             }
         } else {
-            if !rest.is_empty() {
-                text.push_str(rest);
-                on_text(rest);
+            // Hold a possible partial `<think>` at the tail for the next chunk.
+            let (emit, hold) = split_trailing_partial(rest, "<think>");
+            if !emit.is_empty() {
+                text.push_str(emit);
+                on_text(emit);
             }
+            *carry = hold.to_string();
             break;
         }
     }
 }
 
+// Flush a leftover `carry` at stream end: if we're not mid-think it was ordinary
+// text that merely resembled a tag prefix, so surface it; mid-think residue
+// (a dangling `</think>` prefix with no answer after) is dropped.
+fn flush_think_carry(
+    carry: &str,
+    in_think: bool,
+    text: &mut String,
+    on_text: &mut dyn FnMut(&str),
+) {
+    if !in_think && !carry.is_empty() {
+        text.push_str(carry);
+        on_text(carry);
+    }
+}
+
 fn openai_stream(
     reader: impl Read,
     on_text: &mut dyn FnMut(&str),
@@ -810,6 +881,7 @@ fn openai_stream(
 ) -> Result<Reply, String> {
     let mut text = String::new();
     let mut in_think = false;
+    let mut think_carry = String::new();
     let mut stop_reason: Option<String> = None;
     // index → (id, name, accumulated args)
     let mut pending: Vec<(String, String, String)> = Vec::new();
@@ -832,7 +904,14 @@ fn openai_stream(
             on_thinking(r);
         }
         if let Some(t) = delta["content"].as_str() {
-            route_openai_content(t, &mut in_think, &mut text, on_text, on_thinking);
+            route_openai_content(
+                t,
+                &mut in_think,
+                &mut think_carry,
+                &mut text,
+                on_text,
+                on_thinking,
+            );
         }
         if let Some(tcs) = delta["tool_calls"].as_array() {
             for tc in tcs {
@@ -858,6 +937,7 @@ fn openai_stream(
         }
         false
     })?;
+    flush_think_carry(&think_carry, in_think, &mut text, on_text);
     let calls = pending
         .into_iter()
         .filter(|e| !e.1.is_empty())
@@ -1084,7 +1164,7 @@ fn ollama_call(i: usize, tc: &Value) -> ToolCall {
 
 fn ollama_parse(v: Value) -> Result<Reply, String> {
     let msg = &v["message"];
-    let text = msg["content"].as_str().unwrap_or_default().to_string();
+    let text = strip_think(msg["content"].as_str().unwrap_or_default());
     let mut calls = Vec::new();
     if let Some(tcs) = msg["tool_calls"].as_array() {
         for tc in tcs {
@@ -1139,6 +1219,7 @@ fn ollama_stream(
 ) -> Result<Reply, String> {
     let mut text = String::new();
     let mut in_think = false;
+    let mut think_carry = String::new();
     let mut stop_reason: Option<String> = None;
     let mut stream_err: Option<String> = None;
     let mut calls: Vec<ToolCall> = Vec::new();
@@ -1161,7 +1242,14 @@ fn ollama_stream(
         }
         if let Some(t) = msg["content"].as_str() {
             if !t.is_empty() {
-                route_openai_content(t, &mut in_think, &mut text, on_text, on_thinking);
+                route_openai_content(
+                    t,
+                    &mut in_think,
+                    &mut think_carry,
+                    &mut text,
+                    on_text,
+                    on_thinking,
+                );
             }
         }
         // Unlike OpenAI's fragmented deltas, each streamed tool call arrives
@@ -1180,6 +1268,7 @@ fn ollama_stream(
     if let Some(e) = stream_err {
         return Err(e);
     }
+    flush_think_carry(&think_carry, in_think, &mut text, on_text);
     Ok(Reply {
         text,
         calls,
@@ -1518,6 +1607,75 @@ mod tests {
         assert_eq!(think_out, "inspect first");
     }
 
+    #[test]
+    fn split_trailing_partial_holds_tag_prefix() {
+        assert_eq!(
+            split_trailing_partial("hello <thi", "<think>"),
+            ("hello ", "<thi")
+        );
+        assert_eq!(
+            split_trailing_partial("reason</thi", "</think>"),
+            ("reason", "</thi")
+        );
+        // No trailing partial → nothing held.
+        assert_eq!(
+            split_trailing_partial("plain text", "<think>"),
+            ("plain text", "")
+        );
+        // A complete tag ends with `>`, not a tag prefix, so nothing is held —
+        // the caller's find() handles complete tags first.
+        assert_eq!(
+            split_trailing_partial("a<think>", "<think>"),
+            ("a<think>", "")
+        );
+    }
+
+    #[test]
+    fn openai_stream_handles_think_open_tag_split_across_chunks() {
+        // "<think>" is split as "<thi" | "nk>".
+        let sse = "data: {\"choices\":[{\"delta\":{\"content\":\"hello <thi\"}}]}\n\
+                   data: {\"choices\":[{\"delta\":{\"content\":\"nk>reason</think>done\"}}]}\n\
+                   data: [DONE]\n";
+        let mut text_out = String::new();
+        let mut think_out = String::new();
+        openai_stream(
+            Cursor::new(sse.as_bytes().to_vec()),
+            &mut |t| text_out.push_str(t),
+            &mut |t| think_out.push_str(t),
+        )
+        .unwrap();
+        assert_eq!(text_out, "hello done");
+        assert_eq!(think_out, "reason");
+    }
+
+    #[test]
+    fn openai_stream_handles_think_close_tag_split_across_chunks() {
+        // "</think>" is split as "</thi" | "nk>".
+        let sse = "data: {\"choices\":[{\"delta\":{\"content\":\"<think>reason</thi\"}}]}\n\
+                   data: {\"choices\":[{\"delta\":{\"content\":\"nk>done\"}}]}\n\
+                   data: [DONE]\n";
+        let mut text_out = String::new();
+        let mut think_out = String::new();
+        openai_stream(
+            Cursor::new(sse.as_bytes().to_vec()),
+            &mut |t| text_out.push_str(t),
+            &mut |t| think_out.push_str(t),
+        )
+        .unwrap();
+        assert_eq!(text_out, "done");
+        assert_eq!(think_out, "reason");
+    }
+
+    #[test]
+    fn openai_stream_flushes_false_partial_at_stream_end() {
+        // Content that merely ends with a tag-prefix and then stops must not be
+        // swallowed — it wasn't a real tag.
+        let sse = "data: {\"choices\":[{\"delta\":{\"content\":\"answer<thi\"}}]}\n\
+                   data: [DONE]\n";
+        let r = drain_openai(sse);
+        assert_eq!(r.text, "answer<thi");
+    }
+
     #[test]
     fn openai_stream_accumulates_text_and_stops_on_done() {
         let sse = "data: {\"choices\":[{\"delta\":{\"content\":\"Hel\"}}]}\n\
@@ -1744,6 +1902,40 @@ mod tests {
         assert_eq!(r.calls[0].input, json!({}));
     }
 
+    // ── think-tag stripping ─────────────────────────────────────────────────
+    #[test]
+    fn strip_think_removes_blocks_and_keeps_answer() {
+        assert_eq!(
+            strip_think("<think>let me reason</think>The answer is 42."),
+            "The answer is 42."
+        );
+        // Multiple blocks, with real content between them.
+        assert_eq!(strip_think("<think>a</think>X<think>b</think>Y"), "XY");
+        // No tags → untouched.
+        assert_eq!(strip_think("plain answer"), "plain answer");
+    }
+
+    #[test]
+    fn strip_think_drops_unclosed_reasoning() {
+        // An unterminated <think> means the model never emitted a final answer;
+        // the leaked reasoning must not become the answer.
+        assert_eq!(strip_think("intro <think>reasoning with no close"), "intro");
+    }
+
+    #[test]
+    fn openai_parse_strips_think_from_content() {
+        let v = json!({"choices": [{"message": {"content": "<think>plan</think>done"}}]});
+        let r = openai_parse(v).unwrap();
+        assert_eq!(r.text, "done");
+    }
+
+    #[test]
+    fn ollama_parse_strips_think_from_content() {
+        let v = json!({"message": {"content": "<think>hmm</think>result"}, "done_reason": "stop"});
+        let r = ollama_parse(v).unwrap();
+        assert_eq!(r.text, "result");
+    }
+
     // ── stop_reason ─────────────────────────────────────────────────────────
     #[test]
     fn anthropic_parse_captures_stop_reason() {

package/harness/src/tools.rs

@@ -1490,14 +1490,8 @@ fn strip_html(html: &str) -> String {
         i += 1;
     }
 
-    // Collapse whitespace and decode common HTML entities.
-    let decoded = out
-        .replace("&", "&")
-        .replace("&lt;", "<")
-        .replace("&gt;", ">")
-        .replace("&quot;", "\"")
-        .replace("&nbsp;", " ")
-        .replace("&#39;", "'");
+    // Collapse whitespace and decode HTML entities (named + numeric).
+    let decoded = decode_html_entities(&out);
 
     let mut result = String::new();
     let mut prev_ws = true;
@@ -1515,6 +1509,205 @@ fn strip_html(html: &str) -> String {
     result.trim().to_string()
 }
 
+// One parsed web-search result.
+struct SearchHit {
+    title: String,
+    url: String,
+    snippet: String,
+}
+
+// Percent-decode a URL-encoded string (also treats `+` as space). Invalid
+// escapes are left as-is. Bytes are reassembled as UTF-8 lossily.
+fn percent_decode(s: &str) -> String {
+    let bytes = s.as_bytes();
+    let mut out = Vec::with_capacity(bytes.len());
+    let mut i = 0;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'%' if i + 2 < bytes.len() => {
+                if let Ok(b) = u8::from_str_radix(&s[i + 1..i + 3], 16) {
+                    out.push(b);
+                    i += 3;
+                    continue;
+                }
+                out.push(b'%');
+                i += 1;
+            }
+            b'+' => {
+                out.push(b' ');
+                i += 1;
+            }
+            b => {
+                out.push(b);
+                i += 1;
+            }
+        }
+    }
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+// Resolve a single entity body (the text between `&` and `;`) to its character:
+// the common named entities plus decimal (`#8217`) and hex (`#x2019`) numeric
+// character references. Returns None for anything unrecognized.
+fn entity_char(ent: &str) -> Option<char> {
+    match ent {
+        "amp" => Some('&'),
+        "lt" => Some('<'),
+        "gt" => Some('>'),
+        "quot" => Some('"'),
+        "apos" => Some('\''),
+        "nbsp" => Some(' '),
+        "mdash" => Some('—'),
+        "ndash" => Some('–'),
+        "hellip" => Some('…'),
+        "rsquo" => Some('’'),
+        "lsquo" => Some('‘'),
+        "rdquo" => Some('”'),
+        "ldquo" => Some('“'),
+        _ => {
+            let num = ent.strip_prefix('#')?;
+            let code = match num.strip_prefix('x').or_else(|| num.strip_prefix('X')) {
+                Some(hex) => u32::from_str_radix(hex, 16).ok()?,
+                None => num.parse::<u32>().ok()?,
+            };
+            char::from_u32(code)
+        }
+    }
+}
+
+// Decode HTML entities in a single left-to-right pass — named entities and
+// decimal/hex numeric character references. Single-pass so `&amp;lt;` decodes to
+// the literal `&lt;` (not `<`), and an unrecognized `&…;` is left untouched.
+fn decode_html_entities(s: &str) -> String {
+    if !s.contains('&') {
+        return s.to_string();
+    }
+    let mut out = String::with_capacity(s.len());
+    let mut rest = s;
+    while let Some(amp) = rest.find('&') {
+        out.push_str(&rest[..amp]);
+        let tail = &rest[amp..];
+        // `&` and `;` are ASCII, so `semi` is a valid char boundary; the ≤12
+        // bound keeps a lone `&` in prose from swallowing a distant `;`.
+        if let Some(semi) = tail.find(';') {
+            if semi <= 12 {
+                if let Some(ch) = entity_char(&tail[1..semi]) {
+                    out.push(ch);
+                    rest = &tail[semi + 1..];
+                    continue;
+                }
+            }
+        }
+        out.push('&');
+        rest = &tail[1..];
+    }
+    out.push_str(rest);
+    out
+}
+
+// Read attribute `attr` from the tag that opens at byte index `tag_start`,
+// scanning only within that tag (up to its closing `>`).
+fn tag_attr(html: &str, tag_start: usize, attr: &str) -> Option<String> {
+    let end = html[tag_start..].find('>').map(|e| tag_start + e)?;
+    let seg = &html[tag_start..end];
+    let key = format!("{attr}=");
+    let after = &seg[seg.find(&key)? + key.len()..];
+    let quote = after.chars().next()?;
+    if quote == '"' || quote == '\'' {
+        let rest = &after[1..];
+        rest.find(quote).map(|c| rest[..c].to_string())
+    } else {
+        let endv = after.find(char::is_whitespace).unwrap_or(after.len());
+        Some(after[..endv].to_string())
+    }
+}
+
+// DuckDuckGo Lite wraps result links in a redirect: `//duckduckgo.com/l/?uddg=
+// <percent-encoded-target>&rut=…`. Recover the real destination; fall back to
+// normalizing a protocol-relative href.
+fn ddg_real_url(href: &str) -> String {
+    let href = href.replace("&amp;", "&");
+    if let Some(p) = href.find("uddg=") {
+        let rest = &href[p + "uddg=".len()..];
+        let end = rest.find('&').unwrap_or(rest.len());
+        return percent_decode(&rest[..end]);
+    }
+    if let Some(stripped) = href.strip_prefix("//") {
+        return format!("https://{stripped}");
+    }
+    href.to_string()
+}
+
+// Parse DuckDuckGo Lite result rows into structured hits. Returns empty if the
+// markup doesn't match (the caller then falls back to a stripped-text blob).
+fn parse_ddg_lite(html: &str) -> Vec<SearchHit> {
+    let mut titles: Vec<(String, String)> = Vec::new();
+    let mut i = 0;
+    while let Some(rel) = html[i..].find("<a ") {
+        let tag_start = i + rel;
+        let Some(gt) = html[tag_start..].find('>').map(|e| tag_start + e) else {
+            break;
+        };
+        if html[tag_start..gt].contains("result-link") {
+            let url = ddg_real_url(&tag_attr(html, tag_start, "href").unwrap_or_default());
+            let after = &html[gt + 1..];
+            if let Some(close) = after.to_lowercase().find("</a") {
+                let title = decode_html_entities(&strip_html(&after[..close]))
+                    .trim()
+                    .to_string();
+                if !title.is_empty() {
+                    titles.push((title, url));
+                }
+            }
+        }
+        i = gt + 1;
+    }
+
+    let mut snippets: Vec<String> = Vec::new();
+    let mut j = 0;
+    while let Some(rel) = html[j..].find("result-snippet") {
+        let pos = j + rel;
+        if let Some(gt) = html[pos..].find('>') {
+            let start = pos + gt + 1;
+            if let Some(lt) = html[start..].find('<') {
+                snippets.push(
+                    decode_html_entities(&strip_html(&html[start..start + lt]))
+                        .trim()
+                        .to_string(),
+                );
+            }
+        }
+        j = pos + "result-snippet".len();
+    }
+
+    titles
+        .into_iter()
+        .enumerate()
+        .map(|(k, (title, url))| SearchHit {
+            title,
+            url,
+            snippet: snippets.get(k).cloned().unwrap_or_default(),
+        })
+        .collect()
+}
+
+// Render parsed hits as compact, numbered `title / url / snippet` blocks that a
+// small model can read, capped at `max` results.
+fn format_search_hits(hits: &[SearchHit], max: usize) -> String {
+    let mut out = String::new();
+    for (n, h) in hits.iter().take(max).enumerate() {
+        out.push_str(&format!("{}. {}\n", n + 1, h.title));
+        if !h.url.is_empty() {
+            out.push_str(&format!("   {}\n", h.url));
+        }
+        if !h.snippet.is_empty() {
+            out.push_str(&format!("   {}\n", h.snippet));
+        }
+        out.push('\n');
+    }
+    out.trim_end().to_string()
+}
+
 // Commands so destructive they require confirmation in every mode.
 pub fn catastrophic(cmd: &str) -> bool {
     let lower = cmd.to_lowercase();
@@ -1861,13 +2054,170 @@ fn xml_escape(s: &str) -> String {
 }
 
 fn docx_paragraph(text: &str, style: Option<&str>) -> String {
-    let style = style
+    let ppr = style
         .map(|s| format!("<w:pPr><w:pStyle w:val=\"{s}\"/></w:pPr>"))
         .unwrap_or_default();
-    format!(
-        "<w:p>{style}<w:r><w:t>{}</w:t></w:r></w:p>",
+    format!("<w:p>{ppr}{}</w:p>", docx_runs(text))
+}
+
+// Emit one Word run for `text` with the active inline formatting. Empty text
+// produces nothing (an all-empty paragraph is still valid OOXML).
+fn docx_push_run(out: &mut String, text: &str, bold: bool, italic: bool, code: bool) {
+    if text.is_empty() {
+        return;
+    }
+    let mut rpr = String::new();
+    if bold {
+        rpr.push_str("<w:b/>");
+    }
+    if italic {
+        rpr.push_str("<w:i/>");
+    }
+    if code {
+        rpr.push_str("<w:rFonts w:ascii=\"Consolas\" w:hAnsi=\"Consolas\" w:cs=\"Consolas\"/>");
+    }
+    if !rpr.is_empty() {
+        rpr = format!("<w:rPr>{rpr}</w:rPr>");
+    }
+    out.push_str("<w:r>");
+    out.push_str(&rpr);
+    out.push_str(&format!(
+        "<w:t xml:space=\"preserve\">{}</w:t></w:r>",
         xml_escape(text)
-    )
+    ));
+}
+
+// Light-markdown inline formatting → Word runs: `**bold**`, `*italic*`, and
+// `` `code` `` (verbatim). Emphasis markers only toggle when they flank
+// non-space text, so arithmetic like `5 * 3` and glob patterns stay literal;
+// underscores are deliberately left alone so `snake_case` isn't italicized.
+fn docx_runs(text: &str) -> String {
+    let chars: Vec<char> = text.chars().collect();
+    let n = chars.len();
+    let mut out = String::new();
+    let mut buf = String::new();
+    let (mut bold, mut italic, mut code) = (false, false, false);
+    let mut i = 0;
+    while i < n {
+        let c = chars[i];
+        // Inside a code span everything is literal until the closing backtick.
+        if code {
+            if c == '`' {
+                docx_push_run(&mut out, &buf, bold, italic, code);
+                buf.clear();
+                code = false;
+            } else {
+                buf.push(c);
+            }
+            i += 1;
+            continue;
+        }
+        match c {
+            '`' => {
+                docx_push_run(&mut out, &buf, bold, italic, code);
+                buf.clear();
+                code = true;
+                i += 1;
+            }
+            '*' if i + 1 < n && chars[i + 1] == '*' => {
+                // Opening `**` must precede non-space; closing must follow it.
+                let flanks = if bold {
+                    i > 0 && !chars[i - 1].is_whitespace()
+                } else {
+                    i + 2 < n && !chars[i + 2].is_whitespace()
+                };
+                if flanks {
+                    docx_push_run(&mut out, &buf, bold, italic, code);
+                    buf.clear();
+                    bold = !bold;
+                } else {
+                    buf.push('*');
+                    buf.push('*');
+                }
+                i += 2;
+            }
+            '*' => {
+                let flanks = if italic {
+                    i > 0 && !chars[i - 1].is_whitespace()
+                } else {
+                    i + 1 < n && !chars[i + 1].is_whitespace()
+                };
+                if flanks {
+                    docx_push_run(&mut out, &buf, bold, italic, code);
+                    buf.clear();
+                    italic = !italic;
+                } else {
+                    buf.push('*');
+                }
+                i += 1;
+            }
+            _ => {
+                buf.push(c);
+                i += 1;
+            }
+        }
+    }
+    docx_push_run(&mut out, &buf, bold, italic, code);
+    out
+}
+
+// Split a markdown table line into trimmed cells, dropping the outer pipes.
+fn parse_table_cells(line: &str) -> Vec<String> {
+    let t = line.trim();
+    let t = t.strip_prefix('|').unwrap_or(t);
+    let t = t.strip_suffix('|').unwrap_or(t);
+    t.split('|').map(|c| c.trim().to_string()).collect()
+}
+
+// A markdown table row: trimmed, starts with `|`, and has at least two pipes.
+fn is_table_row(line: &str) -> bool {
+    let t = line.trim();
+    t.starts_with('|') && t.matches('|').count() >= 2
+}
+
+// The `|---|:--:|` alignment row: every cell is only dashes/colons.
+fn is_table_separator(line: &str) -> bool {
+    let cells = parse_table_cells(line);
+    !cells.is_empty()
+        && cells
+            .iter()
+            .all(|c| !c.is_empty() && c.chars().all(|ch| ch == '-' || ch == ':'))
+}
+
+// One table cell. Header cells are a single bold run; body cells get full
+// inline markdown formatting.
+fn docx_table_cell(text: &str, header: bool) -> String {
+    let runs = if header {
+        let mut s = String::new();
+        docx_push_run(&mut s, text, true, false, false);
+        s
+    } else {
+        docx_runs(text)
+    };
+    format!("<w:tc><w:tcPr><w:tcW w:w=\"0\" w:type=\"auto\"/></w:tcPr><w:p>{runs}</w:p></w:tc>")
+}
+
+// A bordered Word table. The first row is treated as the (bold) header.
+fn docx_table(rows: &[Vec<String>]) -> String {
+    let mut out = String::from(
+        "<w:tbl><w:tblPr><w:tblW w:w=\"0\" w:type=\"auto\"/><w:tblBorders>\
+<w:top w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"auto\"/>\
+<w:left w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"auto\"/>\
+<w:bottom w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"auto\"/>\
+<w:right w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"auto\"/>\
+<w:insideH w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"auto\"/>\
+<w:insideV w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"auto\"/>\
+</w:tblBorders></w:tblPr>",
+    );
+    for (r, row) in rows.iter().enumerate() {
+        out.push_str("<w:tr>");
+        for cell in row {
+            out.push_str(&docx_table_cell(cell, r == 0));
+        }
+        out.push_str("</w:tr>");
+    }
+    out.push_str("</w:tbl>");
+    out
 }
 
 fn docx_document(title: &str, body: &str) -> String {
@@ -1875,8 +2225,25 @@ fn docx_document(title: &str, body: &str) -> String {
         r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>"#,
     );
     out.push_str(&docx_paragraph(title, Some("Title")));
-    for line in body.lines() {
-        let trimmed = line.trim();
+    let lines: Vec<&str> = body.lines().collect();
+    let mut idx = 0;
+    while idx < lines.len() {
+        // A run of consecutive `|`-delimited rows becomes one Word table; the
+        // alignment separator row is dropped and the first row is the header.
+        if is_table_row(lines[idx]) {
+            let mut rows: Vec<Vec<String>> = Vec::new();
+            while idx < lines.len() && is_table_row(lines[idx]) {
+                if !is_table_separator(lines[idx]) {
+                    rows.push(parse_table_cells(lines[idx]));
+                }
+                idx += 1;
+            }
+            if !rows.is_empty() {
+                out.push_str(&docx_table(&rows));
+            }
+            continue;
+        }
+        let trimmed = lines[idx].trim();
         if trimmed.is_empty() {
             out.push_str("<w:p/>");
         } else if let Some(h) = trimmed.strip_prefix("### ") {
@@ -1890,6 +2257,7 @@ fn docx_document(title: &str, body: &str) -> String {
         } else {
             out.push_str(&docx_paragraph(trimmed, None));
         }
+        idx += 1;
     }
     out.push_str(r#"<w:sectPr><w:pgSz w:w="12240" w:h="15840"/><w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440"/></w:sectPr></w:body></w:document>"#);
     out
@@ -2983,7 +3351,20 @@ pub fn run(name: &str, input: &Value, cwd: &Path) -> Outcome {
                     .set("User-Agent", "Mozilla/5.0 (compatible; buildwithnexus/1.0)"),
             ) {
                 Ok(resp) => match resp.into_string() {
-                    Ok(html) => ok(truncate(strip_html(&html), MAX_OUT)),
+                    Ok(html) => {
+                        let hits = parse_ddg_lite(&html);
+                        if hits.is_empty() {
+                            // Markup didn't match — fall back to the raw text so
+                            // the model still gets something.
+                            ok(truncate(strip_html(&html), MAX_OUT))
+                        } else {
+                            let body = format_search_hits(&hits, 10);
+                            ok(truncate(
+                                format!("{} results for \"{query}\":\n\n{body}", hits.len()),
+                                MAX_OUT,
+                            ))
+                        }
+                    }
                     Err(e) => err(format!("search response error: {e}")),
                 },
                 Err(e) => err(format!("web search failed: {e}")),
@@ -3802,6 +4183,178 @@ mod tests {
     use super::*;
     use std::path::PathBuf;
 
+    // ── web search parsing ──────────────────────────────────────────────────
+    const DDG_LITE_SAMPLE: &str = r#"<html><body><form>search</form><table>
+      <tr><td>1.&nbsp;</td><td>
+        <a rel="nofollow" href="//duckduckgo.com/l/?uddg=https%3A%2F%2Fdoc.rust-lang.org%2Fstd%2F&amp;rut=abc" class='result-link'>Rust std docs</a>
+      </td></tr>
+      <tr><td>&nbsp;</td><td class='result-snippet'>The Rust Standard Library &amp; API reference.</td></tr>
+      <tr><td>2.&nbsp;</td><td>
+        <a rel="nofollow" href="//duckduckgo.com/l/?uddg=https%3A%2F%2Fcrates.io%2F&amp;rut=def" class='result-link'>crates.io</a>
+      </td></tr>
+      <tr><td>&nbsp;</td><td class='result-snippet'>The Rust package registry.</td></tr>
+    </table></body></html>"#;
+
+    #[test]
+    fn percent_decode_handles_escapes_and_plus() {
+        assert_eq!(percent_decode("a%2Fb%20c+d"), "a/b c d");
+        // A malformed trailing escape is left literal, not dropped.
+        assert_eq!(percent_decode("100%"), "100%");
+    }
+
+    #[test]
+    fn decode_html_entities_single_pass_no_double_decode() {
+        // Single pass: &amp; becomes a literal & and the following "lt;" is left
+        // alone, so this must not collapse to "<".
+        assert_eq!(decode_html_entities("a &amp;lt; b"), "a &lt; b");
+        assert_eq!(
+            decode_html_entities("x &lt;y&gt; &quot;z&quot;"),
+            "x <y> \"z\""
+        );
+    }
+
+    #[test]
+    fn decode_html_entities_resolves_numeric_and_typographic() {
+        // Decimal and hex numeric references for a curly apostrophe.
+        assert_eq!(decode_html_entities("it&#8217;s"), "it’s");
+        assert_eq!(decode_html_entities("it&#x2019;s"), "it’s");
+        // Common typographic named entities.
+        assert_eq!(decode_html_entities("a &mdash; b &hellip;"), "a — b …");
+    }
+
+    #[test]
+    fn decode_html_entities_leaves_unknown_and_bare_amp_literal() {
+        assert_eq!(decode_html_entities("Tom & Jerry"), "Tom & Jerry");
+        assert_eq!(decode_html_entities("&notreal;"), "&notreal;");
+        // A `&` with no nearby `;` is untouched.
+        assert_eq!(
+            decode_html_entities("cats & dogs everywhere"),
+            "cats & dogs everywhere"
+        );
+    }
+
+    #[test]
+    fn ddg_real_url_recovers_target_from_redirect() {
+        assert_eq!(
+            ddg_real_url("//duckduckgo.com/l/?uddg=https%3A%2F%2Fexample.com%2Fa&amp;rut=z"),
+            "https://example.com/a"
+        );
+        assert_eq!(ddg_real_url("//example.com/x"), "https://example.com/x");
+    }
+
+    #[test]
+    fn parse_ddg_lite_extracts_structured_hits() {
+        let hits = parse_ddg_lite(DDG_LITE_SAMPLE);
+        assert_eq!(hits.len(), 2);
+        assert_eq!(hits[0].title, "Rust std docs");
+        assert_eq!(hits[0].url, "https://doc.rust-lang.org/std/");
+        assert_eq!(
+            hits[0].snippet,
+            "The Rust Standard Library & API reference."
+        );
+        assert_eq!(hits[1].title, "crates.io");
+        assert_eq!(hits[1].url, "https://crates.io/");
+    }
+
+    #[test]
+    fn parse_ddg_lite_returns_empty_on_unrelated_html() {
+        assert!(parse_ddg_lite("<html><body>no results here</body></html>").is_empty());
+    }
+
+    #[test]
+    fn format_search_hits_numbers_and_caps() {
+        let hits = parse_ddg_lite(DDG_LITE_SAMPLE);
+        let out = format_search_hits(&hits, 1);
+        assert!(out.starts_with("1. Rust std docs"));
+        assert!(out.contains("https://doc.rust-lang.org/std/"));
+        // Capped at 1 — the second hit must not appear.
+        assert!(!out.contains("crates.io"));
+    }
+
+    // ── docx tables ─────────────────────────────────────────────────────────
+    #[test]
+    fn table_row_and_separator_detection() {
+        assert!(is_table_row("| a | b |"));
+        assert!(is_table_row("|a|b|"));
+        assert!(!is_table_row("a | b")); // no leading pipe
+        assert!(!is_table_row("- bullet"));
+        assert!(is_table_separator("| --- | :---: |"));
+        assert!(!is_table_separator("| a | b |"));
+    }
+
+    #[test]
+    fn parse_table_cells_drops_outer_pipes_and_trims() {
+        assert_eq!(parse_table_cells("|  a | b  |c|"), vec!["a", "b", "c"]);
+    }
+
+    #[test]
+    fn docx_document_renders_markdown_table() {
+        let body = "Intro line.\n| Name | Price |\n| --- | --- |\n| Glazed | $1.50 |\n| Old Fashioned | $2.00 |\n\nOutro.";
+        let doc = docx_document("Menu", body);
+        // A real table with a header row is emitted.
+        assert!(doc.contains("<w:tbl>"));
+        assert_eq!(doc.matches("<w:tr>").count(), 3); // header + 2 body rows
+                                                      // Header cells are bold; the separator row is gone.
+        assert!(doc.contains("<w:rPr><w:b/></w:rPr><w:t xml:space=\"preserve\">Name</w:t>"));
+        assert!(!doc.contains("---"));
+        // Surrounding prose still renders as paragraphs.
+        assert!(doc.contains(">Intro line.</w:t>"));
+        assert!(doc.contains(">Outro.</w:t>"));
+    }
+
+    #[test]
+    fn docx_document_without_table_is_unchanged_shape() {
+        let doc = docx_document("T", "# Head\n- item\nplain");
+        assert!(!doc.contains("<w:tbl>"));
+        assert!(doc.contains(">• item</w:t>"));
+    }
+
+    // ── docx inline formatting ──────────────────────────────────────────────
+    #[test]
+    fn docx_runs_renders_bold_italic_and_code() {
+        let out = docx_runs("plain **bold** and *italic* and `code` end");
+        // Bold run carries <w:b/>, italic <w:i/>, code the monospace font.
+        assert!(out.contains("<w:rPr><w:b/></w:rPr><w:t xml:space=\"preserve\">bold</w:t>"));
+        assert!(out.contains("<w:rPr><w:i/></w:rPr><w:t xml:space=\"preserve\">italic</w:t>"));
+        assert!(out.contains("w:ascii=\"Consolas\""));
+        assert!(out.contains(">code</w:t>"));
+        // The markers themselves are consumed, not emitted as literal text.
+        assert!(!out.contains('*'));
+        assert!(!out.contains('`'));
+    }
+
+    #[test]
+    fn docx_runs_leaves_arithmetic_and_snake_case_literal() {
+        // Spaced `*` is not emphasis; `_` never toggles italic.
+        let out = docx_runs("compute 5 * 3 for my_var_name");
+        assert!(!out.contains("<w:i/>"));
+        assert!(!out.contains("<w:b/>"));
+        assert!(out.contains("5 * 3 for my_var_name"));
+    }
+
+    #[test]
+    fn docx_runs_code_span_is_verbatim() {
+        // Emphasis markers inside a code span stay literal.
+        let out = docx_runs("call `a*b` now");
+        assert!(out.contains(">a*b</w:t>"));
+        assert!(!out.contains("<w:i/>"));
+    }
+
+    #[test]
+    fn docx_runs_escapes_xml_in_runs() {
+        let out = docx_runs("**a < b & c**");
+        assert!(out.contains("a &lt; b &amp; c"));
+        assert!(out.contains("<w:b/>"));
+    }
+
+    #[test]
+    fn docx_runs_unmatched_marker_stays_literal() {
+        // A lone trailing `**` with nothing after it must not open emphasis.
+        let out = docx_runs("trailing **");
+        assert!(!out.contains("<w:b/>"));
+        assert!(out.contains("trailing **"));
+    }
+
     // ── truncate ────────────────────────────────────────────────────────────
     #[test]
     fn truncate_shorter_than_max_unchanged() {

package/harness/src/tui.rs

@@ -1074,39 +1074,89 @@ fn format_links(s: &str) -> String {
     out
 }
 
-fn format_italics(s: &str) -> String {
-    if !s.contains('*') {
-        return s.to_string();
+// Flush the pending plain-text run to `out`, wrapping it in the styles active
+// when it was collected. Italic is applied inside bold so both can nest.
+fn flush_styled_run(out: &mut String, buf: &mut String, bold_on: bool, italic_on: bool) {
+    if buf.is_empty() {
+        return;
     }
-    let mut out = String::with_capacity(s.len() + 16);
-    let mut is_italic = false;
-    for (i, part) in s.split('*').enumerate() {
-        if i > 0 && is_italic {
-            out.push_str(&italic(part));
-        } else {
-            out.push_str(part);
-        }
-        is_italic = !is_italic;
+    let mut s = std::mem::take(buf);
+    if italic_on {
+        s = italic(&s);
     }
-    out
+    if bold_on {
+        s = bold(&s);
+    }
+    out.push_str(&s);
 }
 
+// Render inline Markdown (`` `code` ``, `**bold**`, `*italic*`) into ANSI in a
+// single left-to-right pass. A marker only opens a style when a matching closer
+// exists ahead and it isn't followed by whitespace, so an unmatched `` ` ``,
+// `**`, or `*` — including arithmetic like `5 * 3` — stays literal instead of
+// styling the rest of the line. Links are resolved first by `format_links`.
 fn format_inline_md(text: &str) -> String {
-    let mut out = String::with_capacity(text.len() + 32);
-    for (i, part) in text.split('`').enumerate() {
-        if i % 2 == 1 {
-            out.push_str(&yellow(part));
-        } else {
-            let with_links = format_links(part);
-            for (j, bpart) in with_links.split("**").enumerate() {
-                if j % 2 == 1 {
-                    out.push_str(&bold(bpart));
-                } else {
-                    out.push_str(&format_italics(bpart));
-                }
+    let linked = format_links(text);
+    let chars: Vec<char> = linked.chars().collect();
+    let n = chars.len();
+    let mut out = String::with_capacity(linked.len() + 32);
+    let mut buf = String::new();
+    let (mut bold_on, mut italic_on) = (false, false);
+    let mut i = 0;
+    while i < n {
+        let c = chars[i];
+        if c == '`' {
+            // Code span: style only if there's a closing backtick ahead.
+            if let Some(rel) = chars[i + 1..].iter().position(|&x| x == '`') {
+                flush_styled_run(&mut out, &mut buf, bold_on, italic_on);
+                let code: String = chars[i + 1..i + 1 + rel].iter().collect();
+                out.push_str(&yellow(&code));
+                i += rel + 2;
+                continue;
+            }
+            buf.push('`');
+            i += 1;
+            continue;
+        }
+        if c == '*' && i + 1 < n && chars[i + 1] == '*' {
+            let toggles = if bold_on {
+                i > 0 && !chars[i - 1].is_whitespace()
+            } else {
+                i + 2 < n
+                    && !chars[i + 2].is_whitespace()
+                    && chars[i + 2..]
+                        .windows(2)
+                        .any(|w| w[0] == '*' && w[1] == '*')
+            };
+            if toggles {
+                flush_styled_run(&mut out, &mut buf, bold_on, italic_on);
+                bold_on = !bold_on;
+            } else {
+                buf.push('*');
+                buf.push('*');
+            }
+            i += 2;
+            continue;
+        }
+        if c == '*' {
+            let toggles = if italic_on {
+                i > 0 && !chars[i - 1].is_whitespace()
+            } else {
+                i + 1 < n && !chars[i + 1].is_whitespace() && chars[i + 1..].contains(&'*')
+            };
+            if toggles {
+                flush_styled_run(&mut out, &mut buf, bold_on, italic_on);
+                italic_on = !italic_on;
+            } else {
+                buf.push('*');
             }
+            i += 1;
+            continue;
         }
+        buf.push(c);
+        i += 1;
     }
+    flush_styled_run(&mut out, &mut buf, bold_on, italic_on);
     out
 }
 
@@ -3591,6 +3641,25 @@ mod tests {
         assert_eq!(super::end_word(&b, 10), 14);
     }
 
+    #[test]
+    fn inline_md_unbalanced_markers_stay_literal() {
+        // A single `*` (arithmetic), a lone backtick, and an unmatched `**`
+        // must not style the rest of the line — they render verbatim.
+        assert_eq!(format_inline_md("5 * 3 = 15"), "5 * 3 = 15");
+        assert_eq!(format_inline_md("call `foo now"), "call `foo now");
+        assert_eq!(format_inline_md("a ** b"), "a ** b");
+    }
+
+    #[test]
+    fn inline_md_balanced_markers_consume_delimiters() {
+        // Balanced emphasis/code: the markers are consumed and the inner text
+        // preserved (checked after stripping ANSI, so this holds in any color
+        // mode).
+        assert_eq!(plain(&format_inline_md("a *word* b")), "a word b");
+        assert_eq!(plain(&format_inline_md("a **bold** c")), "a bold c");
+        assert_eq!(plain(&format_inline_md("use `code` here")), "use code here");
+    }
+
     #[test]
     fn render_md_draws_fenced_code_blocks() {
         let doc = "before\n```rust\nlet x = 1;\n```\nafter";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buildwithnexus",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "A hilariously fast, agentic AI CLI harness in Rust — remote (API key) or local models, full-screen TUI with sessions, plan/build/brainstorm modes, and hooks",
   "bin": {
     "buildwithnexus": "bin/buildwithnexus.js",