diff --git a/bing-cli/.gitignore b/bing-cli/.gitignore
new file mode 100644
index 0000000..789fcb5
--- /dev/null
+++ b/bing-cli/.gitignore
@@ -0,0 +1,15 @@
+# Build output
+/bing-cli
+*.exe
+*.dll
+*.so
+*.dylib
+
+# Test binaries
+*.test
+*.out
+
+# Editors
+.vscode/
+.idea/
+.DS_Store
diff --git a/bing-cli/ARCHAEOLOGY.md b/bing-cli/ARCHAEOLOGY.md
new file mode 100644
index 0000000..36be479
--- /dev/null
+++ b/bing-cli/ARCHAEOLOGY.md
@@ -0,0 +1,97 @@
+# Site Archaeology — Bing Search
+
+Findings from applying the archaeology protocol against Bing (English + Chinese UI) on 2026-07-15. Merged from bing-cli-acc and updated for v2.
+
+## Feature A: `search <query>`
+
+**URL:** `GET https://www.bing.com/search?q=<urlencode(query)>&count=<N>&offset=<O>`
+
+- No auth required for basic search.
+- Results are SSR'd in the DOM — no XHR needed for page one.
+- Chinese market (`cc=cn&setlang=zh-Hans`) vs international (`cc=us&setlang=en`).
+- `count` max is ~50 per page. `offset` enables pagination.
+
+### DOM Structure
+
+Each organic result lives in:
+
+```html
+<li class="b_algo" iid="SERP.NNNN">
+  <style>...</style>
+  <h2><a href="https://www.bing.com/ck/a?...">Title text</a></h2>
+  <div class="b_attribution"><cite>https://example.com</cite></div>
+  <div class="b_caption"><p class="b_paractl">Snippet text...</p></div>
+</li>
+```
+
+**Selectors:**
+
+| Field   | Selector       | Notes |
+|---------|----------------|-------|
+| title   | `#b_results > li.b_algo h2 a` textContent | |
+| url     | `#b_results > li.b_algo .b_attribution cite` textContent | Display URL (domain only) |
+| snippet | `#b_results > li.b_algo .b_caption p` textContent | May include breadcrumb prefix |
+| source  | same as `cite` | |
+| bingHref| `h2 a` getAttribute("href") | Encrypted /ck/a redirect — resolved on Go side |
+
+### Extract Strategy
+
+Async IIFE with 8 s polling deadline (google-cli pattern):
+
+1. Check for consent interstitial (`location.host.startsWith('consent.')`).
+2. Poll `#b_results > li.b_algo` every 500 ms until results appear.
+3. Deduplicate by display URL (Set).
+4. Clean snippet: `replace(/\s+/g, " ")`, strip trailing "Read more", slice to 300.
+
+### Gotchas
+
+- **Encrypted href**: The `<h2 a>` `href` is a Bing redirect (`/ck/a?...&u=<encrypted>`). The CLI follows each redirect via HTTP GET and extracts the real URL from the response HTML body using a regex.
+- **Inline `<style>` in results**: Each `li.b_algo` contains inline `<style>`. Extract by selector, never `innerHTML`.
+- **Snippet prefix**: Chinese UI snippets sometimes start with `› ` (breadcrumb). Whitespace normalization handles it.
+- **Result count**: `#b_results > li.b_algo` typically returns 10–12 per page.
+- **Consent interstitial**: EU / anonymous browsers may hit `consent.bing.com`. Detected and reported as `consent_required`.
+
+### Known Failure Modes
+
+| Symptom | Likely Cause | Fix |
+|---------|-------------|-----|
+| `consent_required` | EU consent interstitial | Accept once in Chrome, retry |
+| `no_results` / empty items | Bing reflowed selectors | Re-run archaeology against `li.b_algo` |
+| `daemon_unreachable` | kimi-webbridge not running | Start Kimi Desktop App |
+| `extension_not_connected` | WebBridge extension not installed | Install from kimi.com/features/webbridge |
+| CDP context errors | Tab still loading | Handled by evaluateWithRetry (3 retries) |
+
+---
+
+## Feature B: `result <url>`
+
+**Delivery model:** Arbitrary page; DOM extraction via `evaluate`.
+
+### Extraction
+
+```json
+{
+  "url":         "location.href after redirects",
+  "title":       "document.title",
+  "description": "meta[name=description] → meta[property='og:description'] → ''",
+  "text":        "document.body.innerText capped at 5000 chars"
+}
+```
+
+### Gotchas
+
+- `document.body.innerText` begins with header/nav text — acceptable for MVP.
+- JS-heavy pages: if `text.length < 50`, retry once with a 2 s settle delay.
+- No network capture required.
+
+---
+
+## Daemon `evaluate` Protocol (Critical for Go Client)
+
+- Code runs as a top-level expression — `return <expr>` triggers `SyntaxError`.
+- The value of the last expression is the return value.
+- For async, wrap explicitly: `(async () => { ... })()`.
+- Daemon wraps every return as `{"type": "<type>", "value": <v>}`.
+- When code ends with `JSON.stringify(...)`, `type` is `"string"`.
+- Go client **must** unwrap this envelope before unmarshalling.
+- `EvaluateJSON` handles the unwrap automatically.
diff --git a/bing-cli/CLAUDE.md b/bing-cli/CLAUDE.md
new file mode 100644
index 0000000..ff11161
--- /dev/null
+++ b/bing-cli/CLAUDE.md
@@ -0,0 +1,46 @@
+# bing-cli Architecture
+
+## Design Principles
+
+- **CLI stays simple** — one action per command, no orchestration. Agent composes calls.
+- **Raw JSON by default** — primary consumer is AI agents, not humans.
+- **No API key** — uses kimi-webbridge for real browser sessions → cookies → no bot detection.
+
+## Dedup Strategy
+
+| Flag | Behavior |
+|------|----------|
+| *(none)* | Raw Bing top 10, no filtering |
+| `-u` | Title dedup (>80% char overlap) + max 3 per domain |
+
+Only `-u` triggers dedup. Default is pass-through — agent decides if results are too noisy and retries with `-u`.
+
+## Market Strategy
+
+Default is `-m us` (international). Bing's `cc` parameter controls the market. Only use `-m cn` when Chinese-local sources (Baidu/Zhihu/etc) are specifically needed.
+
+## Platform Patterns
+
+### General Search Engines (Bing, Google, Baidu, Sogou)
+- Same strategy: default pass-through, `-u` for dedup
+- Domain diversity matters — results from multiple sources
+
+### Platform-Internal Search (Xiaohongshu, Douyin, WeChat)
+- All results from same domain → `-u` meaningless
+- Need different dedup (content-based, not domain-based)
+- Separate CLI per platform
+
+## Project Structure
+
+```
+bing-cli/
+├── main.go           # Entry point
+├── browser/          # WebBridge HTTP client (reusable across all CLI tools)
+│   └── client.go
+├── output/           # JSON output helpers
+│   └── output.go
+├── bing/             # Bing-specific search logic
+│   └── search.go
+└── cmd/              # CLI commands (cobra)
+    └── root.go
+```
diff --git a/bing-cli/README.md b/bing-cli/README.md
new file mode 100644
index 0000000..78b9f14
--- /dev/null
+++ b/bing-cli/README.md
@@ -0,0 +1,103 @@
+# bing-cli
+
+CLI wrapper around Bing Search backed by the [kimi-webbridge](https://www.kimi.com/features/webbridge) browser daemon. Runs inside your real Chrome session — no API key needed — and emits JSON on stdout.
+
+## Commands
+
+| Command | Usage | Returns |
+|---|---|---|
+| `search` | `bing-cli search <query> [-n N] [-m cn\|us] [-o N] [-r]` | `{query, count, results: [{title, url, snippet, source}]}` |
+| `result` | `bing-cli result <url> [-r]` | `{url, title, description, text}` |
+
+All output:
+
+```json
+{"ok": true, "data": ...}
+```
+or on failure (non-zero exit):
+
+```json
+{"ok": false, "error": {"code": "...", "message": "..."}}
+```
+
+### Agent consumption (recommended)
+
+Use `--raw` (`-r`) to get clean JSON without the status wrapper — saves tokens:
+
+```bash
+bing-cli search "query" -r -n 10
+# → [{"title":"...","url":"...","snippet":"...","source":"..."}]
+```
+
+## Prerequisites
+
+**kimi-webbridge daemon** running on `127.0.0.1:10086` — install from https://www.kimi.com/features/webbridge.
+
+## Install
+
+**Binary** (Windows): copy `bing-cli.exe` into a directory on your `PATH`.
+
+**Build from source** (requires Go 1.26+):
+
+```bash
+go build -o bing-cli .
+./bing-cli search "claude code"
+```
+
+## Quick test
+
+```bash
+# English search
+bing-cli search "claude code" --count 3
+
+# Chinese search
+bing-cli search "牛仔裤面料" --market cn -r -n 5
+
+# International with pagination
+bing-cli search "rust async patterns" -m us -r -n 10 -o 10
+
+# Fetch page content
+bing-cli result "https://example.com/article"
+```
+
+## Flags (search)
+
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--market` | `-m` | `""` (auto) | `cn` (China), `us` (International) |
+| `--count` | `-n` | `10` | Results per page (max 50) |
+| `--offset` | `-o` | `0` | Pagination offset |
+| `--raw` | `-r` | `false` | Bare JSON array — no wrapper |
+
+## Layout
+
+```
+bing-cli/
+├── main.go                # entrypoint
+├── browser/client.go      # kimi-webbridge HTTP client (+ EvaluateJSON, Status)
+├── output/output.go       # JSON contract: {ok, data} / {ok, error}
+├── bing/
+│   ├── search.go          # search command backend (DOM extractor + /ck/a resolver)
+│   ├── result.go          # result command backend (page content extraction)
+│   └── common.go          # evaluateWithRetry + isTransientContextError
+├── cmd/
+│   └── root.go            # Cobra CLI definition (search + result)
+├── ARCHAEOLOGY.md         # DOM-selector field notes
+└── README.md              # this file
+```
+
+## Robustness
+
+- **CDP retry**: 3-level backoff (300ms → 700ms → 1500ms) for transient context errors.
+- **Consent detection**: Detects Bing privacy interstitials and reports a clear error.
+- **Async DOM polling**: Waits up to 8 s for results to render (defense against lazy loading).
+- **URL dedup**: Filters duplicate display URLs from the result set.
+- **/ck/a redirect resolution**: Follows Bing's encrypted redirect pages to extract real target URLs.
+- **JS-heavy page retry**: For `result`, retries with a 2 s settle delay if body text is < 50 chars.
+
+## Notes
+
+- Bing encrypts the real link target in the `href` of each result's `<h2 a>` (a proprietary redirect through `/ck/a`). The CLI automatically follows each redirect and extracts the real URL from the response HTML.
+- Selectors pinned to `#b_results > li.b_algo` + `h2 a` + `.b_attribution cite` + `.b_caption p`. If Bing reflows, re-run the archaeology protocol and update `bing/search.go`.
+- No login needed for basic search.
+- `cn.bing.com` auto-redirect may happen based on IP when no `--market` flag.
diff --git a/bing-cli/bing/common.go b/bing-cli/bing/common.go
new file mode 100644
index 0000000..6dc9431
--- /dev/null
+++ b/bing-cli/bing/common.go
@@ -0,0 +1,41 @@
+package bing
+
+import (
+	"strings"
+	"time"
+
+	"bing-cli/browser"
+)
+
+// evaluateWithRetry calls client.EvaluateJSON and retries on transient CDP
+// context errors with a three-level backoff: 300ms → 700ms → 1500ms.
+// Non-transient errors are returned immediately.
+func evaluateWithRetry(client *browser.Client, code string, v any) error {
+	delays := []time.Duration{300 * time.Millisecond, 700 * time.Millisecond, 1500 * time.Millisecond}
+	var lastErr error
+	for i, d := range delays {
+		if i > 0 {
+			time.Sleep(d)
+		}
+		err := client.EvaluateJSON(code, v)
+		if err == nil {
+			return nil
+		}
+		lastErr = err
+		if !isTransientContextError(err) {
+			return err
+		}
+	}
+	return lastErr
+}
+
+// isTransientContextError returns true when the error message indicates a
+// temporary CDP execution-context race (tab is still loading / has navigated).
+func isTransientContextError(err error) bool {
+	if err == nil {
+		return false
+	}
+	msg := err.Error()
+	return strings.Contains(msg, "Cannot find default execution context") ||
+		strings.Contains(msg, "Execution context was destroyed")
+}
diff --git a/bing-cli/bing/result.go b/bing-cli/bing/result.go
new file mode 100644
index 0000000..f3074cf
--- /dev/null
+++ b/bing-cli/bing/result.go
@@ -0,0 +1,73 @@
+package bing
+
+import (
+	"fmt"
+
+	"bing-cli/browser"
+)
+
+// PageResult holds the extracted content from a fetched page.
+type PageResult struct {
+	URL         string `json:"url"`
+	Title       string `json:"title"`
+	Description string `json:"description"`
+	Text        string `json:"text"`
+}
+
+// resultExtractJS extracts page metadata and body text.
+// For JS-heavy pages where text hasn't rendered yet, the caller should
+// retry once after a 1.5 s wait if text length < 50.
+const resultExtractJS = `(() => {
+  const meta = document.querySelector('meta[name="description"]');
+  const og   = document.querySelector('meta[property="og:description"]');
+  return JSON.stringify({
+    url:         location.href,
+    title:       document.title,
+    description: meta ? meta.getAttribute('content') : (og ? og.getAttribute('content') : ''),
+    text:        (document.body ? document.body.innerText : '').slice(0, 5000)
+  });
+})()`
+
+// FetchResult navigates to url and extracts title, description, and text.
+// JS-heavy pages get a single retry after a 1.5 s settle delay.
+func FetchResult(client *browser.Client, targetURL string) (*PageResult, error) {
+	if err := client.Navigate(targetURL); err != nil {
+		return nil, fmt.Errorf("navigate: %w", err)
+	}
+
+	var page PageResult
+	if err := evaluateWithRetry(client, resultExtractJS, &page); err != nil {
+		return nil, fmt.Errorf("extract: %w", err)
+	}
+
+	// JS-heavy pages: if body text is suspiciously short, wait and retry once.
+	if len(page.Text) < 50 {
+		// Use a raw Evaluate call so we can sleep inside JS; the daemon
+		// doesn't support time.Sleep in Go, so we re-evaluate after a
+		// short settle via a simple JS delay.
+		settleJS := `(async () => {
+		  await new Promise(r => setTimeout(r, 2000));
+		  return JSON.stringify({
+		    url:         location.href,
+		    title:       document.title,
+		    description: (() => {
+		      const m = document.querySelector('meta[name="description"]');
+		      if (m) return m.getAttribute('content');
+		      const og = document.querySelector('meta[property="og:description"]');
+		      return og ? og.getAttribute('content') : '';
+		    })(),
+		    text: (document.body ? document.body.innerText : '').slice(0, 5000)
+		  });
+		})()`
+		var retry PageResult
+		if err := client.EvaluateJSON(settleJS, &retry); err != nil {
+			// Fall back to the original (possibly short) result.
+			return &page, nil
+		}
+		if len(retry.Text) > len(page.Text) {
+			page = retry
+		}
+	}
+
+	return &page, nil
+}
diff --git a/bing-cli/bing/search.go b/bing-cli/bing/search.go
new file mode 100644
index 0000000..43e226a
--- /dev/null
+++ b/bing-cli/bing/search.go
@@ -0,0 +1,328 @@
+package bing
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+
+	"bing-cli/browser"
+)
+
+const baseURL = "https://www.bing.com/search"
+
+// ErrConsentRequired is returned when Bing serves a consent/privacy
+// interstitial. The user must accept it once in Chrome, then retry.
+type ErrConsentRequired struct{}
+
+func (e ErrConsentRequired) Error() string {
+	return "Bing served a consent interstitial. Accept once in Chrome, then retry."
+}
+
+// bingRedirectRe matches the real target URL embedded in Bing's /ck/a redirect page.
+var bingRedirectRe = regexp.MustCompile(`https?://[a-zA-Z0-9][a-zA-Z0-9._/-]*[a-zA-Z0-9/]`)
+
+// SearchResult is one item in the Bing search result list.
+type SearchResult struct {
+	Title   string `json:"title"`
+	URL     string `json:"url"`
+	Snippet string `json:"snippet"`
+	Source  string `json:"source"`
+}
+
+// SearchOptions bundles all search parameters.
+type SearchOptions struct {
+	Query  string
+	Market string // "cn", "us", "" (auto)
+	Count  int
+	Offset int
+	Unique bool // title dedup (>80% overlap) + max 3 per domain
+}
+
+// searchExtractJS is the merged extractor:
+//   - Async polling (8 s deadline) — google-cli pattern
+//   - Consent interstitial detection — google-cli pattern
+//   - Bing selectors (#b_results > li.b_algo) — v2
+//   - bingHref capture for /ck/a redirect resolution — acc
+//   - URL dedup — google-cli pattern
+//   - Snippet cleaning (whitespace + trailing "Read more") — both
+const searchExtractJS = `(async () => {
+  const deadline = Date.now() + 8000;
+  let results = [];
+
+  while (Date.now() < deadline) {
+    if (location.host.startsWith('consent.')) {
+      return JSON.stringify({consent: true, items: []});
+    }
+
+    const items = document.querySelectorAll("#b_results > li.b_algo");
+    if (items.length > 0) {
+      const seen = new Set();
+      results = Array.from(items).map(el => {
+        const h2 = el.querySelector("h2 a");
+        const cite = el.querySelector(".b_attribution cite, cite");
+        const p = el.querySelector(".b_caption p");
+        if (!h2) return null;
+        const displayURL = cite ? cite.textContent.trim() : "";
+        if (!displayURL || seen.has(displayURL)) return null;
+        seen.add(displayURL);
+        return {
+          title:    h2.textContent.trim(),
+          url:      displayURL,
+          snippet:  (p ? p.textContent.trim().replace(/\s+/g, " ") : "")
+                      .replace(/\s*Read more\.?$/, "")
+                      .slice(0, 300),
+          source:   cite ? cite.textContent.trim() : "",
+          bingHref: h2.getAttribute("href") || ""
+        };
+      }).filter(Boolean);
+      if (results.length > 0) break;
+    }
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  return JSON.stringify({consent: false, items: results});
+})()`
+
+// resolveBingURL follows Bing's /ck/a redirect and extracts the real target
+// URL from the HTML response body. Falls back to the original URL on failure.
+func resolveBingURL(bingURL string) string {
+	if !strings.Contains(bingURL, "/ck/a") || !strings.Contains(bingURL, "u=") {
+		return bingURL
+	}
+	client := &http.Client{Timeout: 8 * time.Second}
+	resp, err := client.Get(bingURL)
+	if err != nil {
+		return bingURL
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return bingURL
+	}
+	body, _ := io.ReadAll(resp.Body)
+	matches := bingRedirectRe.FindAllString(string(body), -1)
+	for _, m := range matches {
+		if !strings.Contains(m, "bing.com/ck") {
+			return m
+		}
+	}
+	return bingURL
+}
+
+// Search navigates to the Bing SERP and extracts organic results.
+func Search(client *browser.Client, opts SearchOptions) ([]SearchResult, error) {
+	params := url.Values{}
+	params.Set("q", opts.Query)
+
+	// When deduplicating by domain, request extra results to compensate.
+	reqCount := opts.Count
+	if opts.Unique {
+		reqCount = opts.Count * 2
+		if reqCount > 50 {
+			reqCount = 50
+		}
+	}
+	if reqCount > 0 {
+		params.Set("count", fmt.Sprintf("%d", reqCount))
+	} else {
+		params.Set("count", "10")
+	}
+	if opts.Offset > 0 {
+		params.Set("offset", fmt.Sprintf("%d", opts.Offset))
+	}
+	if opts.Market != "" {
+		switch opts.Market {
+		case "cn", "zh-CN", "zh":
+			params.Set("cc", "cn")
+			params.Set("setlang", "zh-Hans")
+		case "us", "en-US", "en":
+			params.Set("cc", "us")
+			params.Set("setlang", "en")
+		default:
+			params.Set("cc", opts.Market)
+		}
+	}
+
+	searchURL := baseURL + "?" + params.Encode()
+
+	if err := client.Navigate(searchURL); err != nil {
+		return nil, fmt.Errorf("navigate: %w", err)
+	}
+
+	// Extract results with CDP retry.
+	var rawPayload struct {
+		Consent bool `json:"consent"`
+		Items   []struct {
+			Title    string `json:"title"`
+			URL      string `json:"url"`
+			Snippet  string `json:"snippet"`
+			Source   string `json:"source"`
+			BingHref string `json:"bingHref"`
+		} `json:"items"`
+	}
+
+	if err := evaluateWithRetry(client, searchExtractJS, &rawPayload); err != nil {
+		return nil, fmt.Errorf("extract: %w", err)
+	}
+
+	if rawPayload.Consent {
+		return nil, ErrConsentRequired{}
+	}
+
+	results := make([]SearchResult, 0, len(rawPayload.Items))
+	for _, item := range rawPayload.Items {
+		finalURL := item.URL
+		// Resolve Bing's encrypted /ck/a redirect to the real URL.
+		if item.BingHref != "" && strings.Contains(item.BingHref, "/ck/a") {
+			if resolved := resolveBingURL(item.BingHref); resolved != item.BingHref {
+				finalURL = resolved
+			}
+		}
+		results = append(results, SearchResult{
+			Title:   item.Title,
+			URL:     finalURL,
+			Snippet: item.Snippet,
+			Source:  item.Source,
+		})
+	}
+
+	// --unique: title dedup (>80% overlap) + max 3 per domain.
+	if opts.Unique {
+		results = dedupResults(results, opts.Count)
+	}
+
+	return results, nil
+}
+
+// dedupResults applies --unique filtering:
+//  1. Title similarity dedup (>80% character overlap → same content, keep first)
+//  2. Max 3 results per domain
+//
+// Returns at most `limit` results.
+func dedupResults(results []SearchResult, limit int) []SearchResult {
+	if len(results) == 0 {
+		return results
+	}
+
+	// Pass 1: title dedup (highest-ranked first).
+	titleKept := make([]SearchResult, 0, len(results))
+	titleNorms := make([]string, 0, len(results))
+	for _, r := range results {
+		n := normalizeTitle(r.Title)
+		dup := false
+		for _, existing := range titleNorms {
+			if isSimilar(n, existing) {
+				dup = true
+				break
+			}
+		}
+		if !dup {
+			titleNorms = append(titleNorms, n)
+			titleKept = append(titleKept, r)
+		}
+	}
+
+	// Pass 2: per-domain cap of 3 (keep highest-ranked per domain first).
+	domainCount := make(map[string]int)
+	out := make([]SearchResult, 0, limit)
+	for _, r := range titleKept {
+		d := extractDomain(r.Source)
+		if domainCount[d] >= 3 {
+			continue
+		}
+		domainCount[d]++
+		out = append(out, r)
+		if len(out) >= limit {
+			break
+		}
+	}
+	return out
+}
+
+// normalizeTitle strips noise so that near-identical titles compare equal.
+func normalizeTitle(t string) string {
+	s := strings.ToLower(t)
+	// Remove common Chinese/English delimiter characters
+	for _, c := range []string{" ", "-", "_", "|", "：", ":", "【", "】", "《", "》", "（", "）", "(", ")", "[", "]"} {
+		s = strings.ReplaceAll(s, c, "")
+	}
+	return s
+}
+
+// isSimilar returns true when two normalized titles likely represent
+// the same content. Uses character-level containment: if the shorter
+// title is mostly contained within the longer one, they match.
+func isSimilar(a, b string) bool {
+	if a == b {
+		return true
+	}
+	short, long := a, b
+	if len(short) > len(long) {
+		short, long = long, short
+	}
+	if len(short) < 8 {
+		return false // too short to judge, keep both
+	}
+
+	// Count characters from short that appear in long (order-independent).
+	runeCount := make(map[rune]int)
+	for _, r := range long {
+		runeCount[r]++
+	}
+	matched := 0
+	for _, r := range short {
+		if runeCount[r] > 0 {
+			runeCount[r]--
+			matched++
+		}
+	}
+	ratio := float64(matched) / float64(len([]rune(short)))
+
+	// 80%+ character overlap → same content.
+	return ratio >= 0.80
+}
+
+// extractDomain returns the host part from a URL string.
+func extractDomain(raw string) string {
+	if raw == "" {
+		return ""
+	}
+	// Strip protocol if present
+	s := raw
+	if after, ok := strings.CutPrefix(s, "https://"); ok {
+		s = after
+	} else if after, ok := strings.CutPrefix(s, "http://"); ok {
+		s = after
+	}
+	// Return everything before the first slash
+	if idx := strings.IndexByte(s, '/'); idx >= 0 {
+		return s[:idx]
+	}
+	return s
+}
+
+// FormatResults returns a human-readable string for terminal display (stderr).
+func FormatResults(results []SearchResult, query string) string {
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("Bing Search: %s\n", query))
+	sb.WriteString(strings.Repeat("─", 80) + "\n")
+	for i, r := range results {
+		sb.WriteString(fmt.Sprintf("\n%d. %s\n", i+1, r.Title))
+		sb.WriteString(fmt.Sprintf("   %s\n", r.URL))
+		if r.Snippet != "" {
+			sb.WriteString(fmt.Sprintf("   %s\n", truncate(r.Snippet, 200)))
+		}
+	}
+	return sb.String()
+}
+
+func truncate(s string, n int) string {
+	runes := []rune(s)
+	if len(runes) <= n {
+		return s
+	}
+	return string(runes[:n]) + "…"
+}
diff --git a/bing-cli/browser/client.go b/bing-cli/browser/client.go
new file mode 100644
index 0000000..ba397ff
--- /dev/null
+++ b/bing-cli/browser/client.go
@@ -0,0 +1,120 @@
+package browser
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+)
+
+const DefaultDaemonURL = "http://127.0.0.1:10086"
+
+type Client struct {
+	baseURL string
+	session string
+	http    *http.Client
+}
+
+func NewClient(session string) *Client {
+	return &Client{
+		baseURL: DefaultDaemonURL,
+		session: session,
+		http:    &http.Client{Timeout: 90 * time.Second},
+	}
+}
+
+// Status reports whether the kimi-webbridge daemon and its Chrome extension
+// are alive. Always call this before Navigate/Evaluate so the user gets a
+// clear diagnostic when the bridge is down.
+type Status struct {
+	Running            bool   `json:"running"`
+	ExtensionConnected bool   `json:"extension_connected"`
+	ExtensionVersion   string `json:"extension_version"`
+	Version            string `json:"version"`
+}
+
+func (c *Client) Status() (*Status, error) {
+	resp, err := c.http.Get(c.baseURL + "/status")
+	if err != nil {
+		return nil, fmt.Errorf("daemon unreachable at %s: %w", c.baseURL, err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	var s Status
+	if err := json.Unmarshal(body, &s); err != nil {
+		return nil, fmt.Errorf("parse status: %w (body=%s)", err, string(body))
+	}
+	return &s, nil
+}
+
+func (c *Client) Call(action string, args map[string]any) (json.RawMessage, error) {
+	body, _ := json.Marshal(map[string]any{
+		"action":  action,
+		"session": c.session,
+		"args":    args,
+	})
+	resp, err := c.http.Post(c.baseURL+"/command", "application/json", bytes.NewReader(body))
+	if err != nil {
+		return nil, fmt.Errorf("daemon unreachable: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var result struct {
+		OK    bool            `json:"ok"`
+		Data  json.RawMessage `json:"data"`
+		Error *struct {
+			Code    string `json:"code"`
+			Message string `json:"message"`
+		} `json:"error"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+	if !result.OK {
+		return nil, fmt.Errorf("%s: %s", result.Error.Code, result.Error.Message)
+	}
+	return result.Data, nil
+}
+
+func (c *Client) Navigate(url string) error {
+	_, err := c.Call("navigate", map[string]any{"url": url, "newTab": false})
+	return err
+}
+
+// Evaluate runs `code` as a top-level JS expression in the active tab.
+// The daemon wraps the result as {"type": "...", "value": ...}. For structured
+// data, prefer EvaluateJSON, which unwraps the envelope for you.
+func (c *Client) Evaluate(code string) (json.RawMessage, error) {
+	return c.Call("evaluate", map[string]any{"code": code})
+}
+
+// EvaluateJSON runs `code` and decodes the stringified JSON it returns into v.
+// `code` must end with a `JSON.stringify(...)` expression; the daemon reports
+// that as {"type":"string","value":"<stringified JSON>"}.
+func (c *Client) EvaluateJSON(code string, v any) error {
+	raw, err := c.Evaluate(code)
+	if err != nil {
+		return err
+	}
+	var env struct {
+		Type  string `json:"type"`
+		Value string `json:"value"`
+	}
+	if err := json.Unmarshal(raw, &env); err != nil {
+		return fmt.Errorf("decode evaluate envelope: %w", err)
+	}
+	if env.Type != "string" {
+		return fmt.Errorf("expected evaluate type=string, got %q — did the code end with JSON.stringify(...)?", env.Type)
+	}
+	if err := json.Unmarshal([]byte(env.Value), v); err != nil {
+		return fmt.Errorf("decode evaluate value: %w", err)
+	}
+	return nil
+}
+
+func (c *Client) Close() error {
+	_, err := c.Call("close_session", map[string]any{})
+	return err
+}
diff --git a/bing-cli/cmd/root.go b/bing-cli/cmd/root.go
new file mode 100644
index 0000000..8275c28
--- /dev/null
+++ b/bing-cli/cmd/root.go
@@ -0,0 +1,87 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"bing-cli/bing"
+	"bing-cli/browser"
+	"bing-cli/output"
+
+	"github.com/spf13/cobra"
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "bing-cli",
+	Short: "Bing search CLI powered by browser automation",
+	Long: `Bing search CLI using real browser sessions via kimi-webbridge.
+No API key required — results from real Bing pages, avoiding bot detection.
+
+Default output is a flat JSON array — designed for agent consumption.
+Use --human (-H) to also print readable text on stderr.`,
+}
+
+func Execute() error {
+	return rootCmd.Execute()
+}
+
+func init() {
+	searchCmd := &cobra.Command{
+		Use:   "search [query]",
+		Short: "Search Bing, returns JSON array to stdout",
+		Args:  cobra.MinimumNArgs(1),
+		Run:   runSearch,
+	}
+	searchCmd.Flags().StringP("market", "m", "us", "Market: us (default, international), cn (China-local)")
+	searchCmd.Flags().IntP("count", "n", 10, "Number of results (max 50)")
+	searchCmd.Flags().IntP("offset", "o", 0, "Result offset for pagination")
+	searchCmd.Flags().BoolP("unique", "u", false, "Title dedup (>80% similar) + max 3 per domain")
+	searchCmd.Flags().BoolP("human", "H", false, "Also print human-readable text to stderr")
+
+	rootCmd.AddCommand(searchCmd)
+}
+
+func runSearch(cmd *cobra.Command, args []string) {
+	query := args[0]
+	market, _ := cmd.Flags().GetString("market")
+	count, _ := cmd.Flags().GetInt("count")
+	offset, _ := cmd.Flags().GetInt("offset")
+	unique, _ := cmd.Flags().GetBool("unique")
+	human, _ := cmd.Flags().GetBool("human")
+
+	if count < 1 {
+		count = 1
+	}
+	if count > 50 {
+		count = 50
+	}
+
+	client := browser.NewClient("bing")
+	defer client.Close()
+
+	results, err := bing.Search(client, bing.SearchOptions{
+		Query:  query,
+		Market: market,
+		Count:  count,
+		Offset: offset,
+		Unique: unique,
+	})
+	if err != nil {
+		output.Error("search_error", err.Error())
+		os.Exit(1)
+	}
+
+	// Default: flat JSON array on stdout (optimized for agent consumption)
+	enc := json.NewEncoder(os.Stdout)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(results); err != nil {
+		output.Error("encode_error", err.Error())
+		os.Exit(1)
+	}
+
+	// Optional human-readable output on stderr
+	if human {
+		fmt.Fprint(os.Stderr, "\n"+bing.FormatResults(results, query))
+	}
+}
diff --git a/bing-cli/go.mod b/bing-cli/go.mod
new file mode 100644
index 0000000..6b7e28e
--- /dev/null
+++ b/bing-cli/go.mod
@@ -0,0 +1,9 @@
+module bing-cli
+
+go 1.26.5
+
+require (
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/spf13/cobra v1.10.2 // indirect
+	github.com/spf13/pflag v1.0.9 // indirect
+)
diff --git a/bing-cli/go.sum b/bing-cli/go.sum
new file mode 100644
index 0000000..a6ee3e0
--- /dev/null
+++ b/bing-cli/go.sum
@@ -0,0 +1,10 @@
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
+github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
+github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/bing-cli/main.go b/bing-cli/main.go
new file mode 100644
index 0000000..9643a4e
--- /dev/null
+++ b/bing-cli/main.go
@@ -0,0 +1,12 @@
+package main
+
+import (
+	"bing-cli/cmd"
+	"os"
+)
+
+func main() {
+	if err := cmd.Execute(); err != nil {
+		os.Exit(1)
+	}
+}
diff --git a/bing-cli/output/output.go b/bing-cli/output/output.go
new file mode 100644
index 0000000..4341740
--- /dev/null
+++ b/bing-cli/output/output.go
@@ -0,0 +1,24 @@
+package output
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+func Success(data any) {
+	printJSON(map[string]any{"ok": true, "data": data})
+}
+
+func Error(code, message string) {
+	printJSON(map[string]any{"ok": false, "error": map[string]any{"code": code, "message": message}})
+}
+
+func printJSON(v any) {
+	enc := json.NewEncoder(os.Stdout)
+	enc.SetEscapeHTML(false)
+	enc.SetIndent("", "  ")
+	if err := enc.Encode(v); err != nil {
+		fmt.Fprintf(os.Stderr, "output error: %v\n", err)
+	}
+}
diff --git a/bing-cli/root.go b/bing-cli/root.go
new file mode 100644
index 0000000..8275c28
--- /dev/null
+++ b/bing-cli/root.go
@@ -0,0 +1,87 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"bing-cli/bing"
+	"bing-cli/browser"
+	"bing-cli/output"
+
+	"github.com/spf13/cobra"
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "bing-cli",
+	Short: "Bing search CLI powered by browser automation",
+	Long: `Bing search CLI using real browser sessions via kimi-webbridge.
+No API key required — results from real Bing pages, avoiding bot detection.
+
+Default output is a flat JSON array — designed for agent consumption.
+Use --human (-H) to also print readable text on stderr.`,
+}
+
+func Execute() error {
+	return rootCmd.Execute()
+}
+
+func init() {
+	searchCmd := &cobra.Command{
+		Use:   "search [query]",
+		Short: "Search Bing, returns JSON array to stdout",
+		Args:  cobra.MinimumNArgs(1),
+		Run:   runSearch,
+	}
+	searchCmd.Flags().StringP("market", "m", "us", "Market: us (default, international), cn (China-local)")
+	searchCmd.Flags().IntP("count", "n", 10, "Number of results (max 50)")
+	searchCmd.Flags().IntP("offset", "o", 0, "Result offset for pagination")
+	searchCmd.Flags().BoolP("unique", "u", false, "Title dedup (>80% similar) + max 3 per domain")
+	searchCmd.Flags().BoolP("human", "H", false, "Also print human-readable text to stderr")
+
+	rootCmd.AddCommand(searchCmd)
+}
+
+func runSearch(cmd *cobra.Command, args []string) {
+	query := args[0]
+	market, _ := cmd.Flags().GetString("market")
+	count, _ := cmd.Flags().GetInt("count")
+	offset, _ := cmd.Flags().GetInt("offset")
+	unique, _ := cmd.Flags().GetBool("unique")
+	human, _ := cmd.Flags().GetBool("human")
+
+	if count < 1 {
+		count = 1
+	}
+	if count > 50 {
+		count = 50
+	}
+
+	client := browser.NewClient("bing")
+	defer client.Close()
+
+	results, err := bing.Search(client, bing.SearchOptions{
+		Query:  query,
+		Market: market,
+		Count:  count,
+		Offset: offset,
+		Unique: unique,
+	})
+	if err != nil {
+		output.Error("search_error", err.Error())
+		os.Exit(1)
+	}
+
+	// Default: flat JSON array on stdout (optimized for agent consumption)
+	enc := json.NewEncoder(os.Stdout)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(results); err != nil {
+		output.Error("encode_error", err.Error())
+		os.Exit(1)
+	}
+
+	// Optional human-readable output on stderr
+	if human {
+		fmt.Fprint(os.Stderr, "\n"+bing.FormatResults(results, query))
+	}
+}
diff --git a/bing-cli/search.go b/bing-cli/search.go
new file mode 100644
index 0000000..43e226a
--- /dev/null
+++ b/bing-cli/search.go
@@ -0,0 +1,328 @@
+package bing
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+
+	"bing-cli/browser"
+)
+
+const baseURL = "https://www.bing.com/search"
+
+// ErrConsentRequired is returned when Bing serves a consent/privacy
+// interstitial. The user must accept it once in Chrome, then retry.
+type ErrConsentRequired struct{}
+
+func (e ErrConsentRequired) Error() string {
+	return "Bing served a consent interstitial. Accept once in Chrome, then retry."
+}
+
+// bingRedirectRe matches the real target URL embedded in Bing's /ck/a redirect page.
+var bingRedirectRe = regexp.MustCompile(`https?://[a-zA-Z0-9][a-zA-Z0-9._/-]*[a-zA-Z0-9/]`)
+
+// SearchResult is one item in the Bing search result list.
+type SearchResult struct {
+	Title   string `json:"title"`
+	URL     string `json:"url"`
+	Snippet string `json:"snippet"`
+	Source  string `json:"source"`
+}
+
+// SearchOptions bundles all search parameters.
+type SearchOptions struct {
+	Query  string
+	Market string // "cn", "us", "" (auto)
+	Count  int
+	Offset int
+	Unique bool // title dedup (>80% overlap) + max 3 per domain
+}
+
+// searchExtractJS is the merged extractor:
+//   - Async polling (8 s deadline) — google-cli pattern
+//   - Consent interstitial detection — google-cli pattern
+//   - Bing selectors (#b_results > li.b_algo) — v2
+//   - bingHref capture for /ck/a redirect resolution — acc
+//   - URL dedup — google-cli pattern
+//   - Snippet cleaning (whitespace + trailing "Read more") — both
+const searchExtractJS = `(async () => {
+  const deadline = Date.now() + 8000;
+  let results = [];
+
+  while (Date.now() < deadline) {
+    if (location.host.startsWith('consent.')) {
+      return JSON.stringify({consent: true, items: []});
+    }
+
+    const items = document.querySelectorAll("#b_results > li.b_algo");
+    if (items.length > 0) {
+      const seen = new Set();
+      results = Array.from(items).map(el => {
+        const h2 = el.querySelector("h2 a");
+        const cite = el.querySelector(".b_attribution cite, cite");
+        const p = el.querySelector(".b_caption p");
+        if (!h2) return null;
+        const displayURL = cite ? cite.textContent.trim() : "";
+        if (!displayURL || seen.has(displayURL)) return null;
+        seen.add(displayURL);
+        return {
+          title:    h2.textContent.trim(),
+          url:      displayURL,
+          snippet:  (p ? p.textContent.trim().replace(/\s+/g, " ") : "")
+                      .replace(/\s*Read more\.?$/, "")
+                      .slice(0, 300),
+          source:   cite ? cite.textContent.trim() : "",
+          bingHref: h2.getAttribute("href") || ""
+        };
+      }).filter(Boolean);
+      if (results.length > 0) break;
+    }
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  return JSON.stringify({consent: false, items: results});
+})()`
+
+// resolveBingURL follows Bing's /ck/a redirect and extracts the real target
+// URL from the HTML response body. Falls back to the original URL on failure.
+func resolveBingURL(bingURL string) string {
+	if !strings.Contains(bingURL, "/ck/a") || !strings.Contains(bingURL, "u=") {
+		return bingURL
+	}
+	client := &http.Client{Timeout: 8 * time.Second}
+	resp, err := client.Get(bingURL)
+	if err != nil {
+		return bingURL
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return bingURL
+	}
+	body, _ := io.ReadAll(resp.Body)
+	matches := bingRedirectRe.FindAllString(string(body), -1)
+	for _, m := range matches {
+		if !strings.Contains(m, "bing.com/ck") {
+			return m
+		}
+	}
+	return bingURL
+}
+
+// Search navigates to the Bing SERP and extracts organic results.
+func Search(client *browser.Client, opts SearchOptions) ([]SearchResult, error) {
+	params := url.Values{}
+	params.Set("q", opts.Query)
+
+	// When deduplicating by domain, request extra results to compensate.
+	reqCount := opts.Count
+	if opts.Unique {
+		reqCount = opts.Count * 2
+		if reqCount > 50 {
+			reqCount = 50
+		}
+	}
+	if reqCount > 0 {
+		params.Set("count", fmt.Sprintf("%d", reqCount))
+	} else {
+		params.Set("count", "10")
+	}
+	if opts.Offset > 0 {
+		params.Set("offset", fmt.Sprintf("%d", opts.Offset))
+	}
+	if opts.Market != "" {
+		switch opts.Market {
+		case "cn", "zh-CN", "zh":
+			params.Set("cc", "cn")
+			params.Set("setlang", "zh-Hans")
+		case "us", "en-US", "en":
+			params.Set("cc", "us")
+			params.Set("setlang", "en")
+		default:
+			params.Set("cc", opts.Market)
+		}
+	}
+
+	searchURL := baseURL + "?" + params.Encode()
+
+	if err := client.Navigate(searchURL); err != nil {
+		return nil, fmt.Errorf("navigate: %w", err)
+	}
+
+	// Extract results with CDP retry.
+	var rawPayload struct {
+		Consent bool `json:"consent"`
+		Items   []struct {
+			Title    string `json:"title"`
+			URL      string `json:"url"`
+			Snippet  string `json:"snippet"`
+			Source   string `json:"source"`
+			BingHref string `json:"bingHref"`
+		} `json:"items"`
+	}
+
+	if err := evaluateWithRetry(client, searchExtractJS, &rawPayload); err != nil {
+		return nil, fmt.Errorf("extract: %w", err)
+	}
+
+	if rawPayload.Consent {
+		return nil, ErrConsentRequired{}
+	}
+
+	results := make([]SearchResult, 0, len(rawPayload.Items))
+	for _, item := range rawPayload.Items {
+		finalURL := item.URL
+		// Resolve Bing's encrypted /ck/a redirect to the real URL.
+		if item.BingHref != "" && strings.Contains(item.BingHref, "/ck/a") {
+			if resolved := resolveBingURL(item.BingHref); resolved != item.BingHref {
+				finalURL = resolved
+			}
+		}
+		results = append(results, SearchResult{
+			Title:   item.Title,
+			URL:     finalURL,
+			Snippet: item.Snippet,
+			Source:  item.Source,
+		})
+	}
+
+	// --unique: title dedup (>80% overlap) + max 3 per domain.
+	if opts.Unique {
+		results = dedupResults(results, opts.Count)
+	}
+
+	return results, nil
+}
+
+// dedupResults applies --unique filtering:
+//  1. Title similarity dedup (>80% character overlap → same content, keep first)
+//  2. Max 3 results per domain
+//
+// Returns at most `limit` results.
+func dedupResults(results []SearchResult, limit int) []SearchResult {
+	if len(results) == 0 {
+		return results
+	}
+
+	// Pass 1: title dedup (highest-ranked first).
+	titleKept := make([]SearchResult, 0, len(results))
+	titleNorms := make([]string, 0, len(results))
+	for _, r := range results {
+		n := normalizeTitle(r.Title)
+		dup := false
+		for _, existing := range titleNorms {
+			if isSimilar(n, existing) {
+				dup = true
+				break
+			}
+		}
+		if !dup {
+			titleNorms = append(titleNorms, n)
+			titleKept = append(titleKept, r)
+		}
+	}
+
+	// Pass 2: per-domain cap of 3 (keep highest-ranked per domain first).
+	domainCount := make(map[string]int)
+	out := make([]SearchResult, 0, limit)
+	for _, r := range titleKept {
+		d := extractDomain(r.Source)
+		if domainCount[d] >= 3 {
+			continue
+		}
+		domainCount[d]++
+		out = append(out, r)
+		if len(out) >= limit {
+			break
+		}
+	}
+	return out
+}
+
+// normalizeTitle strips noise so that near-identical titles compare equal.
+func normalizeTitle(t string) string {
+	s := strings.ToLower(t)
+	// Remove common Chinese/English delimiter characters
+	for _, c := range []string{" ", "-", "_", "|", "：", ":", "【", "】", "《", "》", "（", "）", "(", ")", "[", "]"} {
+		s = strings.ReplaceAll(s, c, "")
+	}
+	return s
+}
+
+// isSimilar returns true when two normalized titles likely represent
+// the same content. Uses character-level containment: if the shorter
+// title is mostly contained within the longer one, they match.
+func isSimilar(a, b string) bool {
+	if a == b {
+		return true
+	}
+	short, long := a, b
+	if len(short) > len(long) {
+		short, long = long, short
+	}
+	if len(short) < 8 {
+		return false // too short to judge, keep both
+	}
+
+	// Count characters from short that appear in long (order-independent).
+	runeCount := make(map[rune]int)
+	for _, r := range long {
+		runeCount[r]++
+	}
+	matched := 0
+	for _, r := range short {
+		if runeCount[r] > 0 {
+			runeCount[r]--
+			matched++
+		}
+	}
+	ratio := float64(matched) / float64(len([]rune(short)))
+
+	// 80%+ character overlap → same content.
+	return ratio >= 0.80
+}
+
+// extractDomain returns the host part from a URL string.
+func extractDomain(raw string) string {
+	if raw == "" {
+		return ""
+	}
+	// Strip protocol if present
+	s := raw
+	if after, ok := strings.CutPrefix(s, "https://"); ok {
+		s = after
+	} else if after, ok := strings.CutPrefix(s, "http://"); ok {
+		s = after
+	}
+	// Return everything before the first slash
+	if idx := strings.IndexByte(s, '/'); idx >= 0 {
+		return s[:idx]
+	}
+	return s
+}
+
+// FormatResults returns a human-readable string for terminal display (stderr).
+func FormatResults(results []SearchResult, query string) string {
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("Bing Search: %s\n", query))
+	sb.WriteString(strings.Repeat("─", 80) + "\n")
+	for i, r := range results {
+		sb.WriteString(fmt.Sprintf("\n%d. %s\n", i+1, r.Title))
+		sb.WriteString(fmt.Sprintf("   %s\n", r.URL))
+		if r.Snippet != "" {
+			sb.WriteString(fmt.Sprintf("   %s\n", truncate(r.Snippet, 200)))
+		}
+	}
+	return sb.String()
+}
+
+func truncate(s string, n int) string {
+	runes := []rune(s)
+	if len(runes) <= n {
+		return s
+	}
+	return string(runes[:n]) + "…"
+}