@zhijiewang/openharness 2.23.0 → 2.25.0

package/dist/renderer/layout-sections.js

@@ -5,6 +5,8 @@
 import { getTheme } from "../utils/theme-data.js";
 import { renderDiff } from "./diff.js";
 import { isImageOutput, renderImageInline } from "./image.js";
+import { deriveSpinnerLabel } from "./spinner-label.js";
+import { toolColor } from "./tool-color.js";
 // ── Style constants ──
 const s = (fg, bold = false, dim = false) => ({ fg, bg: null, bold, dim, underline: false });
 export const S_TEXT = s(null);
@@ -93,14 +95,14 @@ export function renderThinkingSummarySection(state, grid, r, limit) {
 export function renderSpinnerSection(state, grid, r, limit) {
     if (!state.loading || state.streamingText || state.thinkingText || r >= limit)
         return r;
-    const thinkText = "Thinking";
+    const thinkText = deriveSpinnerLabel(state.toolCalls);
     const elapsed = state.thinkingStartedAt ? Math.floor((Date.now() - state.thinkingStartedAt) / 1000) : 0;
     const t = getTheme();
     const baseColor = elapsed > 60 ? t.error : elapsed > 30 ? t.stall : t.primary;
     const shimmerColor = elapsed > 60 ? t.stallShimmer : elapsed > 30 ? t.warning : t.primaryShimmer;
     const baseStyle = { fg: baseColor, bg: null, bold: false, dim: false, underline: false };
     grid.writeText(r, 0, "◆ ", { ...baseStyle, bold: true });
-    const shimmerPos = state.spinnerFrame % (thinkText.length + 6);
+    const shimmerPos = state.spinnerFrame % 20;
     const shimmerStyle = { fg: shimmerColor, bg: null, bold: true, dim: false, underline: false };
     for (let ci = 0; ci < thinkText.length; ci++) {
         grid.setCell(r, 2 + ci, thinkText[ci], Math.abs(ci - shimmerPos) <= 1 ? shimmerStyle : baseStyle);
@@ -141,8 +143,9 @@ export function renderToolCallsSection(state, grid, r, limit, opts) {
                 : tc.status === "done"
                     ? "✓"
                     : "✗";
-        const statusStyle = tc.status === "error" ? S_ERROR : tc.status === "done" ? S_GREEN : isAgent ? S_AGENT : S_YELLOW;
-        const nameStyle = isAgent ? S_AGENT : { ...S_YELLOW, bold: true };
+        const toolStyle = { fg: toolColor(tc.toolName), bg: null, bold: false, dim: false, underline: false };
+        const statusStyle = tc.status === "error" ? S_ERROR : tc.status === "done" ? S_GREEN : isAgent ? S_AGENT : toolStyle;
+        const nameStyle = isAgent ? S_AGENT : { ...toolStyle, bold: true };
         const isExpanded = state.expandedToolCalls.has(callId);
         const canExpand = tc.status !== "running" && tc.output;
         if (canExpand) {
@@ -187,7 +190,7 @@ export function renderToolCallsSection(state, grid, r, limit, opts) {
             for (const line of visible) {
                 if (r >= limit)
                     break;
-                grid.writeText(r, 6, line.slice(0, w - 8), S_DIM);
+                grid.writeTextWithLinks(r, 6, line.slice(0, w - 8), S_DIM, w - 2);
                 r++;
             }
         }
@@ -205,7 +208,7 @@ export function renderToolCallsSection(state, grid, r, limit, opts) {
                 if (r >= limit)
                     break;
                 const lineStyle = tc.status === "error" ? S_ERROR : S_DIM;
-                grid.writeText(r, 6, line.slice(0, w - 8), lineStyle);
+                grid.writeTextWithLinks(r, 6, line.slice(0, w - 8), lineStyle, w - 2);
                 r++;
             }
             if (outLines.length > maxOut && r < limit) {
@@ -427,21 +430,33 @@ export function renderInputSection(state, grid, inputRow, limit, promptText, pro
     const inputStart = promptWidth;
     const inputLines = state.inputText.split("\n");
     const maxInputLines = Math.min(inputLines.length, 5);
+    // Pre-compute the [N lines] suffix column on row 0 (if multi-line) so the
+    // wrap glyph for line 0 can yield to the suffix when they would collide.
+    // The +1 reserves the glyph column so the suffix starts one column after
+    // it (produces "text↵ [N lines]"); a +0 would let the suffix overwrite the
+    // glyph on narrow terminals.
+    let lineCountCol = -1;
+    if (inputLines.length > 1) {
+        const lineCountStr = ` [${inputLines.length} lines]`;
+        lineCountCol = Math.min(inputStart + (inputLines[0]?.length ?? 0) + 1, grid.width - lineCountStr.length - 1);
+    }
     for (let li = 0; li < maxInputLines; li++) {
         if (inputRow + li >= limit)
             break;
-        if (li === 0) {
-            grid.writeText(inputRow, inputStart, inputLines[0], S_TEXT);
-        }
-        else {
-            grid.writeText(inputRow + li, inputStart, inputLines[li], S_TEXT);
+        const lineText = inputLines[li];
+        grid.writeText(inputRow + li, inputStart, lineText, S_TEXT);
+        // Audit U-C2: append a dim ↵ continuation glyph to every non-last line.
+        if (li < inputLines.length - 1) {
+            const glyphCol = inputStart + lineText.length;
+            const wouldCollideWithLineCount = li === 0 && lineCountCol > inputStart && glyphCol >= lineCountCol;
+            if (glyphCol < grid.width && !wouldCollideWithLineCount) {
+                grid.writeText(inputRow + li, glyphCol, "↵", S_DIM);
+            }
         }
     }
-    if (inputLines.length > 1) {
+    if (inputLines.length > 1 && lineCountCol > inputStart) {
         const lineCountStr = ` [${inputLines.length} lines]`;
-        const lineCountCol = Math.min(inputStart + (inputLines[0]?.length ?? 0) + 1, grid.width - lineCountStr.length - 1);
-        if (lineCountCol > inputStart)
-            grid.writeText(inputRow, lineCountCol, lineCountStr, S_DIM);
+        grid.writeText(inputRow, lineCountCol, lineCountStr, S_DIM);
     }
     const hintsRow = inputRow + maxInputLines;
     if (hintsRow < limit) {

package/dist/renderer/markdown.js

@@ -241,7 +241,10 @@ function parseInline(text, baseStyle) {
         // Link: [text](url)
         const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/);
         if (linkMatch) {
-            segments.push({ text: linkMatch[1], style: { ...baseStyle, underline: true, fg: "cyan" } });
+            segments.push({
+                text: linkMatch[1],
+                style: { ...baseStyle, underline: true, fg: "cyan", hyperlink: linkMatch[2] },
+            });
             segments.push({ text: ` (${linkMatch[2]})`, style: { ...baseStyle, dim: true } });
             remaining = remaining.slice(linkMatch[0].length);
             continue;

package/dist/renderer/spinner-label.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Derives the spinner section label from the live tool-call map.
+ */
+import type { ToolCallInfo } from "./layout.js";
+export declare function deriveSpinnerLabel(toolCalls: Map<string, ToolCallInfo>): string;
+//# sourceMappingURL=spinner-label.d.ts.map

package/dist/renderer/spinner-label.js

@@ -0,0 +1,24 @@
+/**
+ * Derives the spinner section label from the live tool-call map.
+ */
+export function deriveSpinnerLabel(toolCalls) {
+    const running = [];
+    for (const tc of toolCalls.values()) {
+        if (tc.status === "running")
+            running.push(tc);
+    }
+    if (running.length === 0)
+        return "Thinking";
+    if (running.length === 1) {
+        const name = running[0].toolName;
+        if (name.startsWith("mcp__")) {
+            const rest = name.slice("mcp__".length);
+            const idx = rest.indexOf("__");
+            if (idx > 0)
+                return `Calling ${rest.slice(0, idx)}:${rest.slice(idx + 2)}`;
+        }
+        return `Running ${name}`;
+    }
+    return `Running ${running.length} tools`;
+}
+//# sourceMappingURL=spinner-label.js.map

package/dist/renderer/tool-color.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Maps a tool name to a display color for the tool-call section.
+ * Read-class tools → cyan, Mutate-class → yellow, Exec-class → magenta,
+ * MCP tools (mcp__ prefix) → green, everything else → yellow fallback.
+ */
+export type ToolColor = "cyan" | "yellow" | "magenta" | "green";
+export declare function toolColor(toolName: string): ToolColor;
+//# sourceMappingURL=tool-color.d.ts.map

package/dist/renderer/tool-color.js

@@ -0,0 +1,20 @@
+/**
+ * Maps a tool name to a display color for the tool-call section.
+ * Read-class tools → cyan, Mutate-class → yellow, Exec-class → magenta,
+ * MCP tools (mcp__ prefix) → green, everything else → yellow fallback.
+ */
+const READ = new Set(["Read", "Glob", "Grep", "WebFetch", "WebSearch", "ExaSearch"]);
+const MUTATE = new Set(["Edit", "Write", "NotebookEdit"]);
+const EXEC = new Set(["Bash", "PowerShell"]);
+export function toolColor(toolName) {
+    if (READ.has(toolName))
+        return "cyan";
+    if (MUTATE.has(toolName))
+        return "yellow";
+    if (EXEC.has(toolName))
+        return "magenta";
+    if (toolName.startsWith("mcp__"))
+        return "green";
+    return "yellow";
+}
+//# sourceMappingURL=tool-color.js.map

package/dist/repl.js

@@ -14,8 +14,10 @@ import { readOhConfig, writeOhConfig } from "./harness/config.js";
 import { estimateMessageTokens, getContextWarning } from "./harness/context-warning.js";
 import { CostTracker, estimateCost, getContextWindow } from "./harness/cost.js";
 import { createSession, loadSession, saveSession } from "./harness/session.js";
+import { runStatusLineScript } from "./harness/status-line-script.js";
 import { createStore } from "./harness/store.js";
 import { handleUserInput } from "./harness/submit-handler.js";
+import { isTrusted, trustSystemActive } from "./harness/trust.js";
 import { query } from "./query/index.js";
 import { resetDiffStyleCache } from "./renderer/diff.js";
 import { TerminalRenderer } from "./renderer/index.js";
@@ -23,6 +25,7 @@ import { resetStyleCache } from "./renderer/layout.js";
 import { resetMdStyleCache } from "./renderer/markdown.js";
 import { createAssistantMessage, createInfoMessage, createMessage } from "./types/message.js";
 import { formatTokenCount } from "./utils/format.js";
+import { fuzzyFilter } from "./utils/fuzzy.js";
 import { setActiveTheme } from "./utils/theme-data.js";
 import { formatToolArgs, summarizeToolOutput } from "./utils/tool-summary.js";
 export async function startREPL(config) {
@@ -131,16 +134,15 @@ export async function startREPL(config) {
     function updateAutocomplete() {
         acIsPath = false;
         if (inputText.startsWith("/") && inputText.length > 1 && !inputText.includes(" ")) {
-            // Slash command autocomplete — entries arrive in registration order
-            // (Session → Git → Info → Settings → AI → Skills → MCP), so categories
-            // are naturally contiguous after a startsWith filter (audit U-A3).
-            const prefix = inputText.slice(1).toLowerCase();
-            const entries = getCommandEntries()
-                .filter((e) => e.name.startsWith(prefix))
-                .slice(0, 8);
-            acSuggestions = entries.map((e) => e.name);
-            acDescriptions = entries.map((e) => e.description);
-            acCategories = entries.map((e) => e.category);
+            // Slash command autocomplete (audit U-B3): subsequence-match scoring,
+            // not a startsWith filter. Prefix matches still rank first via the
+            // bonus in `fuzzyScore`, but the user can type "gst" to surface
+            // "/git-status" or "perm" to surface "/permissions".
+            const query = inputText.slice(1);
+            const ranked = fuzzyFilter(query, getCommandEntries()).slice(0, 8);
+            acSuggestions = ranked.map((r) => r.entry.name);
+            acDescriptions = ranked.map((r) => r.entry.description);
+            acCategories = ranked.map((r) => r.entry.category);
             acTokenStart = 0;
             acIndex = -1;
         }
@@ -273,8 +275,38 @@ export async function startREPL(config) {
             const pct = Math.max(1, Math.ceil(usage * 100));
             ctxStr = `ctx [${bar}] ${pct}%`;
         }
-        // Use template if configured, otherwise default format
-        if (cachedConfig?.statusLineFormat) {
+        // Resolution priority: script (audit U-B1) → template → default.
+        //
+        // Script path: spawn user-configured shell with a JSON envelope on
+        // stdin; gated through the workspace-trust system from audit U-A4 so
+        // a hostile project can't auto-execute on first launch. Cached for
+        // `refreshMs` (default 1s) inside `status-line-script.ts` so the
+        // script doesn't run on every keypress. Failure → fall through to
+        // the template / default below.
+        let scriptLine = null;
+        const sl = cachedConfig?.statusLine;
+        if (sl?.command) {
+            const cwd = process.cwd();
+            if (trustSystemActive() && !isTrusted(cwd)) {
+                scriptLine = null; // untrusted — silently skip; user can /trust
+            }
+            else {
+                const ctxPct = ctxWindow > 0 && estimatedTokenCount > 0 ? estimatedTokenCount / ctxWindow : 0;
+                scriptLine = runStatusLineScript({
+                    model: currentModel || "",
+                    tokens: { input: inTok, output: outTok },
+                    cost: totalCostVal,
+                    contextPercent: ctxPct,
+                    sessionId: session.id,
+                    cwd,
+                    gitBranch: session.gitBranch,
+                }, sl);
+            }
+        }
+        if (scriptLine !== null) {
+            renderer.setStatusLine(scriptLine);
+        }
+        else if (cachedConfig?.statusLineFormat) {
             const line = cachedConfig.statusLineFormat
                 .replace("{model}", currentModel || "")
                 .replace("{tokens}", tokensStr)
@@ -945,7 +977,6 @@ export async function startREPL(config) {
                     case "tool_call_end": {
                         const toolName = callIdToToolName.get(event.callId) ?? event.callId;
                         const prevTc = renderer.getToolCall(event.callId);
-                        const _elapsed = prevTc?.startedAt ? Math.floor((Date.now() - prevTc.startedAt) / 1000) : 0;
                         renderer.setToolCall(event.callId, {
                             toolName,
                             status: event.isError ? "error" : "done",

package/dist/tools/ExaSearchTool/index.d.ts

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const SEARCH_TYPES: readonly ["auto", "neural", "fast", "keyword"];
+declare const CATEGORIES: readonly ["company", "research paper", "news", "personal site", "financial report", "people"];
+declare const inputSchema: z.ZodObject<{
+    query: z.ZodString;
+    num_results: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodEnum<["auto", "neural", "fast", "keyword"]>>;
+    category: z.ZodOptional<z.ZodEnum<["company", "research paper", "news", "personal site", "financial report", "people"]>>;
+    include_domains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude_domains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    include_text: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude_text: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    start_published_date: z.ZodOptional<z.ZodString>;
+    end_published_date: z.ZodOptional<z.ZodString>;
+    user_location: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodBoolean>;
+    highlights: z.ZodOptional<z.ZodBoolean>;
+    summary: z.ZodOptional<z.ZodBoolean>;
+    summary_query: z.ZodOptional<z.ZodString>;
+    max_text_chars: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    type?: "auto" | "fast" | "neural" | "keyword" | undefined;
+    text?: boolean | undefined;
+    summary?: boolean | undefined;
+    num_results?: number | undefined;
+    category?: "company" | "research paper" | "news" | "personal site" | "financial report" | "people" | undefined;
+    include_domains?: string[] | undefined;
+    exclude_domains?: string[] | undefined;
+    include_text?: string[] | undefined;
+    exclude_text?: string[] | undefined;
+    start_published_date?: string | undefined;
+    end_published_date?: string | undefined;
+    user_location?: string | undefined;
+    highlights?: boolean | undefined;
+    summary_query?: string | undefined;
+    max_text_chars?: number | undefined;
+}, {
+    query: string;
+    type?: "auto" | "fast" | "neural" | "keyword" | undefined;
+    text?: boolean | undefined;
+    summary?: boolean | undefined;
+    num_results?: number | undefined;
+    category?: "company" | "research paper" | "news" | "personal site" | "financial report" | "people" | undefined;
+    include_domains?: string[] | undefined;
+    exclude_domains?: string[] | undefined;
+    include_text?: string[] | undefined;
+    exclude_text?: string[] | undefined;
+    start_published_date?: string | undefined;
+    end_published_date?: string | undefined;
+    user_location?: string | undefined;
+    highlights?: boolean | undefined;
+    summary_query?: string | undefined;
+    max_text_chars?: number | undefined;
+}>;
+type ExaContents = {
+    text?: boolean | {
+        maxCharacters?: number;
+    };
+    highlights?: boolean | {
+        maxCharacters?: number;
+    };
+    summary?: boolean | {
+        query?: string;
+    };
+};
+type ExaRequest = {
+    query: string;
+    numResults: number;
+    type?: (typeof SEARCH_TYPES)[number];
+    category?: (typeof CATEGORIES)[number];
+    includeDomains?: string[];
+    excludeDomains?: string[];
+    includeText?: string[];
+    excludeText?: string[];
+    startPublishedDate?: string;
+    endPublishedDate?: string;
+    userLocation?: string;
+    contents?: ExaContents;
+};
+type ExaResultItem = {
+    id?: string;
+    url: string;
+    title?: string | null;
+    publishedDate?: string;
+    author?: string | null;
+    text?: string;
+    highlights?: string[];
+    summary?: string;
+};
+type ExaResponse = {
+    results: ExaResultItem[];
+    requestId?: string;
+};
+export declare function buildRequestBody(input: z.infer<typeof inputSchema>): ExaRequest;
+export declare function extractSnippet(item: ExaResultItem): string;
+export declare function formatResults(response: ExaResponse): string;
+export declare const ExaSearchTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/ExaSearchTool/index.js

@@ -0,0 +1,165 @@
+import { z } from "zod";
+const SEARCH_TYPES = ["auto", "neural", "fast", "keyword"];
+const CATEGORIES = ["company", "research paper", "news", "personal site", "financial report", "people"];
+const inputSchema = z.object({
+    query: z.string(),
+    num_results: z.number().optional(),
+    type: z.enum(SEARCH_TYPES).optional(),
+    category: z.enum(CATEGORIES).optional(),
+    include_domains: z.array(z.string()).optional(),
+    exclude_domains: z.array(z.string()).optional(),
+    include_text: z.array(z.string()).optional(),
+    exclude_text: z.array(z.string()).optional(),
+    start_published_date: z.string().optional(),
+    end_published_date: z.string().optional(),
+    user_location: z.string().optional(),
+    text: z.boolean().optional(),
+    highlights: z.boolean().optional(),
+    summary: z.boolean().optional(),
+    summary_query: z.string().optional(),
+    max_text_chars: z.number().optional(),
+});
+const DEFAULT_NUM_RESULTS = 5;
+const MAX_TEXT_CHARS = 1500;
+const ENDPOINT = "https://api.exa.ai/search";
+const INTEGRATION_HEADER = "openharness";
+export function buildRequestBody(input) {
+    const body = {
+        query: input.query,
+        numResults: input.num_results ?? DEFAULT_NUM_RESULTS,
+    };
+    if (input.type)
+        body.type = input.type;
+    if (input.category)
+        body.category = input.category;
+    if (input.include_domains?.length)
+        body.includeDomains = input.include_domains;
+    if (input.exclude_domains?.length)
+        body.excludeDomains = input.exclude_domains;
+    if (input.include_text?.length)
+        body.includeText = input.include_text;
+    if (input.exclude_text?.length)
+        body.excludeText = input.exclude_text;
+    if (input.start_published_date)
+        body.startPublishedDate = input.start_published_date;
+    if (input.end_published_date)
+        body.endPublishedDate = input.end_published_date;
+    if (input.user_location)
+        body.userLocation = input.user_location;
+    const wantText = input.text ?? true;
+    const wantHighlights = input.highlights ?? true;
+    const wantSummary = input.summary ?? false;
+    const contents = {};
+    if (wantText) {
+        contents.text = { maxCharacters: input.max_text_chars ?? MAX_TEXT_CHARS };
+    }
+    if (wantHighlights) {
+        contents.highlights = true;
+    }
+    if (wantSummary) {
+        contents.summary = input.summary_query ? { query: input.summary_query } : true;
+    }
+    if (Object.keys(contents).length > 0) {
+        body.contents = contents;
+    }
+    return body;
+}
+export function extractSnippet(item) {
+    if (item.highlights && item.highlights.length > 0) {
+        return item.highlights.join(" … ");
+    }
+    if (item.summary)
+        return item.summary;
+    if (item.text) {
+        const trimmed = item.text.replace(/\s+/g, " ").trim();
+        return trimmed.length > 300 ? `${trimmed.slice(0, 300)}…` : trimmed;
+    }
+    return "";
+}
+export function formatResults(response) {
+    if (!response.results || response.results.length === 0) {
+        return "No results found.";
+    }
+    return response.results
+        .map((r, i) => {
+        const title = r.title?.trim() || "(untitled)";
+        const snippet = extractSnippet(r);
+        const meta = [];
+        if (r.author)
+            meta.push(`by ${r.author}`);
+        if (r.publishedDate)
+            meta.push(r.publishedDate.slice(0, 10));
+        const metaLine = meta.length ? `   ${meta.join(" · ")}\n` : "";
+        const snippetLine = snippet ? `   ${snippet}\n` : "";
+        return `${i + 1}. ${title}\n   ${r.url}\n${metaLine}${snippetLine}`.trimEnd();
+    })
+        .join("\n\n");
+}
+export const ExaSearchTool = {
+    name: "ExaSearch",
+    description: "Search the web with Exa — neural/fast/auto search with content retrieval, domain and date filters, and category targeting.",
+    inputSchema,
+    riskLevel: "medium",
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
+    async call(input, _context) {
+        const apiKey = process.env.EXA_API_KEY;
+        if (!apiKey) {
+            return {
+                output: "Error: EXA_API_KEY environment variable is not set.",
+                isError: true,
+            };
+        }
+        const body = buildRequestBody(input);
+        try {
+            const response = await fetch(ENDPOINT, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": apiKey,
+                    "x-exa-integration": INTEGRATION_HEADER,
+                    "User-Agent": "OpenHarness/1.0",
+                },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!response.ok) {
+                const errText = await response.text().catch(() => "");
+                const detail = errText ? `: ${errText.slice(0, 500)}` : "";
+                return {
+                    output: `Error: Exa API returned ${response.status} ${response.statusText}${detail}`,
+                    isError: true,
+                };
+            }
+            const json = (await response.json());
+            return { output: formatResults(json), isError: false };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { output: `Error performing Exa search: ${message}`, isError: true };
+        }
+    },
+    prompt() {
+        return `Search the web using Exa's neural search engine and return ranked results with snippets. Requires EXA_API_KEY env var. Parameters:
+- query (string, required): The search query.
+- num_results (number, optional): Max results to return (default 5).
+- type (string, optional): "auto" (default), "neural", "fast", or "keyword".
+- category (string, optional): One of "company", "research paper", "news", "personal site", "financial report", "people".
+- include_domains (string[], optional): Restrict to these domains.
+- exclude_domains (string[], optional): Skip these domains.
+- include_text (string[], optional): Results must contain these phrases.
+- exclude_text (string[], optional): Skip results containing these phrases.
+- start_published_date / end_published_date (string, optional): ISO 8601 publication date filters.
+- user_location (string, optional): Two-letter ISO country code.
+- text (boolean, optional): Include page text (default true).
+- highlights (boolean, optional): Include highlight snippets (default true).
+- summary (boolean, optional): Include AI-generated summary (default false).
+- summary_query (string, optional): Custom summarization query.
+- max_text_chars (number, optional): Cap text length per result (default 1500).`;
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/tools.js

@@ -14,6 +14,7 @@ import { CronCreateTool, CronDeleteTool, CronListTool } from "./tools/CronTool/i
 import { DiagnosticsTool } from "./tools/DiagnosticsTool/index.js";
 import { EnterPlanModeTool } from "./tools/EnterPlanModeTool/index.js";
 import { EnterWorktreeTool } from "./tools/EnterWorktreeTool/index.js";
+import { ExaSearchTool } from "./tools/ExaSearchTool/index.js";
 import { ExitPlanModeTool } from "./tools/ExitPlanModeTool/index.js";
 import { ExitWorktreeTool } from "./tools/ExitWorktreeTool/index.js";
 import { FileEditTool } from "./tools/FileEditTool/index.js";
@@ -87,6 +88,7 @@ export function getAllTools() {
     const extended = [
         WebFetchTool,
         WebSearchTool,
+        ExaSearchTool,
         TaskGetTool,
         TaskStopTool,
         TaskOutputTool,

package/dist/utils/fuzzy.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Subsequence-match scoring for slash-command and similar pickers.
+ *
+ * Given a query, returns matched candidates in best-first order with all
+ * non-matches dropped. A candidate matches when every query character appears
+ * in the candidate name in order (not necessarily contiguous). Score rewards
+ * contiguous runs, prefix matches, and word-boundary hits so "git" still
+ * surfaces "/git" before "/login" when typing "g".
+ *
+ * Audit U-B3: replaces the prior `startsWith` filter in `src/repl.ts`.
+ */
+export type FuzzyEntry<T> = T & {
+    name: string;
+};
+export type FuzzyResult<T> = {
+    entry: FuzzyEntry<T>;
+    score: number;
+};
+/**
+ * Score a single candidate against the query. Returns `null` when query is not
+ * a subsequence of name. Higher scores are better.
+ *
+ * Scoring rubric (additive):
+ *  +100  candidate name starts with query (still earns subsequence bonus on top)
+ *  +50   per character of contiguous run (max once per matched char pair)
+ *  +20   match on a word-boundary char (after `-`, `_`, ` `, ':' or at start)
+ *  +1    base per matched character
+ *  -1    per skipped (unmatched) character before final query char
+ */
+export declare function fuzzyScore(query: string, name: string): number | null;
+/**
+ * Filter and rank entries by `entry.name` against `query`. Stable for ties:
+ * preserves the original input order so registration-order categories stay
+ * naturally contiguous when scores are equal.
+ */
+export declare function fuzzyFilter<T extends {
+    name: string;
+}>(query: string, entries: T[]): FuzzyResult<T>[];
+//# sourceMappingURL=fuzzy.d.ts.map

package/dist/utils/fuzzy.js

@@ -0,0 +1,70 @@
+/**
+ * Subsequence-match scoring for slash-command and similar pickers.
+ *
+ * Given a query, returns matched candidates in best-first order with all
+ * non-matches dropped. A candidate matches when every query character appears
+ * in the candidate name in order (not necessarily contiguous). Score rewards
+ * contiguous runs, prefix matches, and word-boundary hits so "git" still
+ * surfaces "/git" before "/login" when typing "g".
+ *
+ * Audit U-B3: replaces the prior `startsWith` filter in `src/repl.ts`.
+ */
+/**
+ * Score a single candidate against the query. Returns `null` when query is not
+ * a subsequence of name. Higher scores are better.
+ *
+ * Scoring rubric (additive):
+ *  +100  candidate name starts with query (still earns subsequence bonus on top)
+ *  +50   per character of contiguous run (max once per matched char pair)
+ *  +20   match on a word-boundary char (after `-`, `_`, ` `, ':' or at start)
+ *  +1    base per matched character
+ *  -1    per skipped (unmatched) character before final query char
+ */
+export function fuzzyScore(query, name) {
+    if (query.length === 0)
+        return 0;
+    const q = query.toLowerCase();
+    const n = name.toLowerCase();
+    let qi = 0;
+    let score = 0;
+    let lastMatchIdx = -2;
+    for (let i = 0; i < n.length && qi < q.length; i++) {
+        if (n[i] === q[qi]) {
+            score += 1;
+            const isBoundary = i === 0 || /[-_ :./]/.test(n[i - 1]);
+            if (isBoundary)
+                score += 20;
+            if (i === lastMatchIdx + 1)
+                score += 50;
+            lastMatchIdx = i;
+            qi++;
+        }
+    }
+    if (qi < q.length)
+        return null;
+    // Prefix bonus: candidate begins with the full query verbatim.
+    if (n.startsWith(q))
+        score += 100;
+    // Penalty for skipped chars between first and last match.
+    const span = lastMatchIdx - (n.indexOf(q[0]) ?? 0);
+    if (span > q.length)
+        score -= span - q.length;
+    return score;
+}
+/**
+ * Filter and rank entries by `entry.name` against `query`. Stable for ties:
+ * preserves the original input order so registration-order categories stay
+ * naturally contiguous when scores are equal.
+ */
+export function fuzzyFilter(query, entries) {
+    const out = [];
+    for (const entry of entries) {
+        const score = fuzzyScore(query, entry.name);
+        if (score === null)
+            continue;
+        out.push({ entry: entry, score });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+}
+//# sourceMappingURL=fuzzy.js.map