cursor-opencode-provider 0.7.1 → 0.7.3

package/dist/protocol/tool-call-bridge.js

@@ -1,4 +1,4 @@
-import { mapCursorArgsToOpencode, mapCursorSubagentTypeToOpenCode, mcpRealToolName, } from "./tools.js";
+import { OPENCODE_1_TOOL_DIALECT, mapCursorArgsToOpencode, mapCursorSubagentTypeToOpenCode, mcpRealToolName, } from "./tools.js";
 import { decodeStructEntriesToJson } from "./struct.js";
 import { mapSwitchModeTarget } from "./switch-mode.js";
 const TODO_STATUS = {
@@ -50,11 +50,22 @@ const TOOL_CALL_VARIANTS = Object.keys(VARIANT_TO_OPENCODE);
 // Cursor todo merges). Data-returning, interactive, and side-effecting calls
 // must use an exec/interaction request channel where Cursor can receive their
 // actual result.
+//
+// `get_mcp_tools_tool_call` is Cursor-native discovery (prompt name
+// GetDynamicTools when dynamic namespaces are on). The agent executes it
+// server-side after mcp_state; oversized catalogs spill through write_args.
 const DISPLAY_STATE_MIRROR_VARIANTS = new Set([
     "update_todos_tool_call",
     "read_todos_tool_call",
     "create_plan_tool_call",
 ]);
+const NATIVE_DISPLAY_VARIANTS = new Set([
+    "get_mcp_tools_tool_call",
+]);
+/** Display variants Cursor executes itself (mcp_state + optional write spill). */
+export function isNativeDisplayToolCall(variant) {
+    return NATIVE_DISPLAY_VARIANTS.has(variant);
+}
 function asRecord(v) {
     return v && typeof v === "object" && !Array.isArray(v) ? v : undefined;
 }
@@ -291,7 +302,13 @@ export function parseDisplayToolCall(callId, toolCall, priorMirroredTodos) {
     if (variant === "update_todos_tool_call" || variant === "create_plan_tool_call") {
         const result = asRecord(payload.result);
         const success = asRecord(result?.success);
-        const completedTodos = Array.isArray(success?.todos) ? success.todos : undefined;
+        // Cursor's completed frame may materialize proto-default `todos: []` even
+        // when the real final snapshot is present on args.todos. An empty default
+        // must not erase that named completion snapshot. A non-empty completed
+        // payload remains authoritative (especially for merge calls).
+        const completedTodos = Array.isArray(success?.todos) && success.todos.length > 0
+            ? success.todos
+            : undefined;
         const isMerge = variant === "update_todos_tool_call" && args.merge === true;
         // OpenCode todowrite replaces the whole list. Prefer the completed payload;
         // otherwise a non-merge args list; otherwise merge against the Run snapshot.
@@ -311,7 +328,10 @@ export function parseDisplayToolCall(callId, toolCall, priorMirroredTodos) {
                 todos.unshift({
                     id: "plan",
                     content: [name && `Plan: ${name}`, overview, plan].filter(Boolean).join("\n").slice(0, 2000),
-                    status: "pending",
+                    // The plan file is already written by the time this display mirror
+                    // runs. Leaving it `pending` parks a forever-open row on hosts that
+                    // keep todowrite as the user-visible checklist.
+                    status: "completed",
                     priority: "high",
                 });
             }
@@ -454,7 +474,9 @@ function shellQuote(s) {
  * Pick an advertised OpenCode tool for a display call, remapping args as needed.
  * Returns undefined when nothing compatible is advertised this turn.
  */
-export function resolveBridgedOpenCodeToolCall(display, advertised) {
+export function resolveBridgedOpenCodeToolCall(display, advertised, dialect = OPENCODE_1_TOOL_DIALECT) {
+    if (isNativeDisplayToolCall(display.variant))
+        return undefined;
     if (!DISPLAY_STATE_MIRROR_VARIANTS.has(display.variant))
         return undefined;
     if (display.bridgeable === false)
@@ -466,7 +488,7 @@ export function resolveBridgedOpenCodeToolCall(display, advertised) {
     for (const toolName of candidates) {
         if (!names.has(toolName))
             continue;
-        const mapped = mapCursorArgsToOpencode(toolName, display.args);
+        const mapped = mapCursorArgsToOpencode(toolName, display.args, undefined, dialect);
         if (toolName === "todowrite") {
             mapped.args = {
                 todos: mapTodos(display.args.todos ?? mapped.args.todos),

package/dist/protocol/tools.d.ts

@@ -17,6 +17,7 @@ export type HostToolDialect = {
     shellTool: HostShellTool;
 };
 export declare const OPENCODE_1_TOOL_DIALECT: HostToolDialect;
+export declare const OPENCODE_2_TOOL_DIALECT: HostToolDialect;
 /** Prefer `filePath`, then `path` / `file_path` — Cursor and both OpenCode majors. */
 export declare function opencodePathArg(args: Record<string, unknown> | undefined): string | undefined;
 /**
@@ -26,7 +27,7 @@ export declare function opencodePathArg(args: Record<string, unknown> | undefine
 export declare function hostToolDialectFromTools(tools: readonly {
     name?: string;
     inputSchema?: unknown;
-}[]): HostToolDialect;
+}[], defaultDialect?: HostToolDialect): HostToolDialect;
 export declare const CUSTOM_WEBSEARCH_TOOL = "custom_websearch";
 export declare const CUSTOM_WEBFETCH_TOOL = "custom_webfetch";
 export declare const CUSTOM_LIST_MCP_RESOURCES_TOOL = "custom_list_mcp_resources";
@@ -62,7 +63,8 @@ export declare function resolveToolServerIdentity(opencodeName: string, defaultS
  * default server (`opencode`). Tools whose prefixes match configured MCP
  * servers keep those server ids (`github`, …). Composite `name` is
  * `<server>-<bareTool>`; local execution still uses the full OpenCode id
- * reconstructed in `mcpRealToolName`.
+ * reconstructed in `mcpRealToolName`. Emit in advertised order — the epoch
+ * catalog owns canonicalization; sorting here would insert on grow.
  */
 export declare function toolsToDescriptors(tools: OpencodeToolDef[], providerIdentifier?: string, knownMcpServers?: Iterable<string>): Array<Record<string, unknown>>;
 /**

package/dist/protocol/tools.js

@@ -17,6 +17,10 @@ export const OPENCODE_1_TOOL_DIALECT = {
     filePathKey: "filePath",
     shellTool: "bash",
 };
+export const OPENCODE_2_TOOL_DIALECT = {
+    filePathKey: "path",
+    shellTool: "shell",
+};
 function jsonSchemaProperties(schema) {
     if (!schema || typeof schema !== "object" || Array.isArray(schema))
         return undefined;
@@ -24,11 +28,11 @@ function jsonSchemaProperties(schema) {
     if (obj.properties && typeof obj.properties === "object" && !Array.isArray(obj.properties)) {
         return obj.properties;
     }
-    const nested = obj.jsonSchema;
+    const nested = obj.jsonSchema ?? obj.parameters ?? obj.schema;
     if (nested && typeof nested === "object" && !Array.isArray(nested)) {
-        const props = nested.properties;
-        if (props && typeof props === "object" && !Array.isArray(props)) {
-            return props;
+        const nestedProps = nested.properties;
+        if (nestedProps && typeof nestedProps === "object" && !Array.isArray(nestedProps)) {
+            return nestedProps;
         }
     }
     return undefined;
@@ -43,7 +47,7 @@ export function opencodePathArg(args) {
  * Infer the host tool dialect from advertised AI SDK schemas.
  * OpenCode 2.0 read/edit/write require `path` and rename bash → `shell`.
  */
-export function hostToolDialectFromTools(tools) {
+export function hostToolDialectFromTools(tools, defaultDialect = OPENCODE_1_TOOL_DIALECT) {
     let filePathKey;
     for (const name of ["read", "write", "edit"]) {
         const tool = tools.find((candidate) => candidate.name === name);
@@ -60,10 +64,12 @@ export function hostToolDialectFromTools(tools) {
         }
     }
     const names = new Set(tools.map((tool) => tool.name).filter((name) => typeof name === "string"));
-    const shellTool = names.has("shell") && !names.has("bash") ? "shell" : "bash";
+    const shellTool = names.has("shell") && !names.has("bash")
+        ? "shell"
+        : (names.has("bash") ? "bash" : defaultDialect.shellTool);
     if (!filePathKey) {
         // OpenCode 2 hosts advertise `shell` and `path` together; use that when schemas are opaque.
-        filePathKey = shellTool === "shell" ? "path" : "filePath";
+        filePathKey = shellTool === "shell" ? "path" : defaultDialect.filePathKey;
     }
     return { filePathKey, shellTool };
 }
@@ -115,12 +121,14 @@ export function resolveToolServerIdentity(opencodeName, defaultServer = "opencod
  * default server (`opencode`). Tools whose prefixes match configured MCP
  * servers keep those server ids (`github`, …). Composite `name` is
  * `<server>-<bareTool>`; local execution still uses the full OpenCode id
- * reconstructed in `mcpRealToolName`.
+ * reconstructed in `mcpRealToolName`. Emit in advertised order — the epoch
+ * catalog owns canonicalization; sorting here would insert on grow.
  */
 export function toolsToDescriptors(tools, providerIdentifier = "opencode", knownMcpServers = []) {
-    return [...tools]
-        .sort((left, right) => left.name.localeCompare(right.name))
-        .map((t) => {
+    // Advertised order is the prefix. The epoch catalog sorts once on first
+    // freeze and appends later names at the tail; re-sorting here would insert
+    // a new tool in front of `z` and invalidate the tools bytes.
+    return tools.map((t) => {
         const id = resolveToolServerIdentity(t.sourceName ?? t.name, providerIdentifier, knownMcpServers);
         const collisionSafeAlias = COLLISION_SAFE_ALIASES.has(t.name);
         return {
@@ -233,11 +241,10 @@ export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", kn
     if (tools.length === 0)
         return [];
     const byServer = new Map();
-    // OpenCode's tool catalog is a set even though the hook exposes it as an
-    // array. Keep both the server and per-server tool order canonical so a host
-    // that enumerates the same catalog differently does not invalidate Cursor's
-    // RequestContext prefix cache.
-    for (const t of [...tools].sort((left, right) => left.name.localeCompare(right.name))) {
+    // Walk advertised order: first-seen server, then append tools onto that
+    // server. Same-set host reorder is resolved by `resolveTurnToolState`
+    // before encode so this walk stays epoch-stable.
+    for (const t of tools) {
         const id = resolveToolServerIdentity(t.sourceName ?? t.name, providerIdentifier, knownMcpServers);
         let list = byServer.get(id.server);
         if (!list) {
@@ -250,14 +257,7 @@ export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", kn
             input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
         });
     }
-    const orderedServers = [...byServer.keys()].sort((left, right) => {
-        if (left === providerIdentifier)
-            return right === providerIdentifier ? 0 : -1;
-        if (right === providerIdentifier)
-            return 1;
-        return left.localeCompare(right);
-    });
-    return orderedServers.map((server) => ({
+    return [...byServer.keys()].map((server) => ({
         server_name: server,
         server_identifier: server,
         tools: byServer.get(server),
@@ -872,6 +872,20 @@ function readRequestResultMetadata(raw, mappedArgs) {
         ...(typeof mappedArgs.limit === "number" ? { limit: mappedArgs.limit } : {}),
     };
 }
+/**
+ * Cursor's native write executor echoes `WriteArgs.path` on `WriteSuccess.path`.
+ * Large GetMcpTools / GetDynamicTools catalogs spill through `write_args` into
+ * `agent-tools/<uuid>.txt` and then tell the model `filePath` from that success
+ * path. Host write output is free-form prose (often no `<path>` tag), so the
+ * request path is the only host-neutral identity we can report.
+ */
+function writeRequestResultMetadata(raw, mappedArgs) {
+    const requestedPath = str(raw.path)
+        ?? str(raw.filePath)
+        ?? str(raw.file_path)
+        ?? opencodePathArg(mappedArgs);
+    return requestedPath ? { path: requestedPath } : undefined;
+}
 /**
  * A partial-read notice is for Cursor's model, never for a file. Refuse only
  * whole-file mutation forms that echo it. A targeted edit or Update File patch
@@ -1049,7 +1063,11 @@ export function parseExecServerMessage(msg, dialect = OPENCODE_1_TOOL_DIALECT) {
         ? shellStreamResultMetadata(rawArgs)
         : execVariant === "read_args" || execVariant === "pi_read_args"
             ? readRequestResultMetadata(rawArgs, mapped.args)
-            : undefined;
+            : execVariant === "write_args" || execVariant === "pi_write_args"
+                ? writeRequestResultMetadata(rawArgs, mapped.args)
+                : execVariant === "grep_args"
+                    ? grepRequestResultMetadata(rawArgs)
+                    : undefined;
     if (resultMetadata
         && resultMetadata.timeout_behavior !== 2
         && typeof resultMetadata.timeout_ms === "number") {
@@ -1166,7 +1184,9 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant, dialect = OP
             else {
                 content = stringValue(cleaned.content)
                     ?? stringValue(cleaned.file_text)
-                    ?? stringValue(cleaned.fileText);
+                    ?? stringValue(cleaned.fileText)
+                    ?? stringValue(cleaned.contents)
+                    ?? stringValue(cleaned.text);
             }
             if (content !== undefined)
                 args.content = content;
@@ -1917,6 +1937,15 @@ function toolPathSeparator(filePath) {
  * roots intact, including `..`, and still use `path.resolve` for host paths.
  */
 function joinToolPath(root, relative) {
+    // `path.resolve` drops a trailing separator. Glob and find use that separator
+    // to tell a directory from a file; putting it back keeps the marker.
+    const directory = relative.endsWith("/") || relative.endsWith("\\");
+    const joined = joinResolvedToolPath(root, relative);
+    if (!directory || joined.endsWith("/") || joined.endsWith("\\"))
+        return joined;
+    return `${joined}${toolPathSeparator(joined)}`;
+}
+function joinResolvedToolPath(root, relative) {
     if (!isForeignAbsoluteToolPath(root))
         return path.resolve(root, relative);
     const sep = toolPathSeparator(root);
@@ -1986,17 +2015,169 @@ function resolveToolPath(filePath, workspaceRoot) {
  * paths, indented match previews, and prose stay untouched. Grep file headers
  * drop the trailing colon only in the structured file list, not in this text.
  */
+/**
+ * Longer phrases first. "No files found" is a prefix of the pattern sentence,
+ * and a suffix check must not stop on the shorter one.
+ */
+const SEARCH_STATUS_MESSAGES = [
+    "No files found matching pattern",
+    "No matches before timeout (scan incomplete)",
+    "No files found",
+    "No matches found",
+];
+/**
+ * A glob/find miss is prose, not a path. Hosts sometimes still carry it as a
+ * path segment (`../../workspace/No files found matching pattern`) or fold that
+ * segment into a `# dir/` header plus a bare sentence. Either shape must stay
+ * the sentence: joining it onto the workspace is what lists a fake file.
+ */
+function searchStatusMessage(line) {
+    const trimmed = line.trim().replace(/^#+\s+/, "");
+    for (const message of SEARCH_STATUS_MESSAGES) {
+        if (trimmed === message || trimmed.endsWith(`/${message}`) || trimmed.endsWith(`\\${message}`)) {
+            return message;
+        }
+    }
+    return undefined;
+}
+function collapseSearchStatus(output) {
+    return output.split("\n").map((line) => searchStatusMessage(line) ?? line).join("\n");
+}
+function isSearchStatusReport(output) {
+    const lines = output.split("\n").map((line) => line.trim()).filter(Boolean);
+    return lines.length > 0 && lines.every((line) => searchStatusMessage(line) !== undefined);
+}
+/**
+ * Cursor's find/glob executor shows one path per line. A directory ends with
+ * `/`; a file does not. Some hosts instead print a folded tree:
+ *
+ *   # src/
+ *   a.ts
+ *   ## components/
+ *   button.tsx
+ *   # tests/
+ *
+ * A `# dir/` line is a grouping header, not another match. Emitting it lists
+ * the directory beside its own children (and the shared search prefix shows up
+ * as a blank entry once that prefix is the directory being searched). Expand
+ * the tree to the files underneath only. A header with no child is still just
+ * an empty directory in the walk — Cursor find reports files, so leave it out
+ * (same as targeting that empty directory and getting a miss).
+ */
+function parseGroupedPathListing(output) {
+    const lines = output.replace(/\n+$/, "").split("\n");
+    const events = [];
+    const stack = [];
+    let sawHeader = false;
+    let inNotes = false;
+    for (const line of lines) {
+        if (!line.trim()) {
+            if (sawHeader)
+                inNotes = true;
+            continue;
+        }
+        if (inNotes) {
+            events.push({ kind: "note", text: line });
+            continue;
+        }
+        const status = searchStatusMessage(line);
+        if (status) {
+            events.push({ kind: "note", text: status });
+            continue;
+        }
+        const header = /^(#+)\s+(\S.*?)\s*$/.exec(line);
+        if (header) {
+            const rawName = header[2] ?? "";
+            if (!rawName.endsWith("/") && !rawName.endsWith("\\"))
+                return undefined;
+            const depth = header[1].length - 1;
+            if (depth > stack.length)
+                return undefined;
+            const name = rawName.slice(0, -1);
+            if (!name || name === "." || name === "..")
+                return undefined;
+            stack.length = depth;
+            const parent = depth === 0 ? "" : (stack[depth - 1] ?? "");
+            if (depth > 0 && !parent)
+                return undefined;
+            const full = parent ? joinDisplayPath(parent, name) : name;
+            stack.push(full);
+            events.push({ kind: "dir", depth, path: full });
+            sawHeader = true;
+            continue;
+        }
+        if (line.startsWith(" ") || line.startsWith("\t") || /\s/.test(line) || line.includes("://")) {
+            return undefined;
+        }
+        if (line.includes("/") || line.includes("\\"))
+            return undefined;
+        if (!sawHeader) {
+            events.push({ kind: "file", path: line });
+            continue;
+        }
+        const parent = stack[stack.length - 1];
+        if (!parent)
+            return undefined;
+        events.push({ kind: "file", path: joinDisplayPath(parent, line) });
+    }
+    if (!sawHeader)
+        return undefined;
+    const paths = [];
+    const notes = [];
+    let sawFile = false;
+    for (const event of events) {
+        if (event.kind === "note")
+            notes.push(event.text);
+        else if (event.kind === "file") {
+            sawFile = true;
+            paths.push(event.path);
+        }
+        // Directory headers are structure only — never emit them as matches.
+    }
+    // The header existed only to hold the miss sentence. Emitting it lists a
+    // directory that was never a match, usually the walk back to the workspace.
+    if (!sawFile && notes.some((note) => searchStatusMessage(note)))
+        return { paths: [], notes };
+    return { paths, notes };
+}
+function joinDisplayPath(parent, child) {
+    if (!parent || parent === ".")
+        return child;
+    if (parent === "/")
+        return `/${child}`;
+    const sep = parent.includes("\\") && !parent.includes("/") ? "\\" : "/";
+    if (parent.endsWith("/") || parent.endsWith("\\"))
+        return `${parent}${child}`;
+    return `${parent}${sep}${child}`;
+}
+function renderGroupedPathListing(listing, workspaceRoot) {
+    const paths = listing.paths.map((entry) => resolveToolPath(entry, workspaceRoot));
+    if (paths.length === 0) {
+        // Grouped output that only had directory headers (empty dirs) is a miss,
+        // same as targeting that empty directory directly.
+        if (listing.notes.length === 0)
+            return "No files found";
+        return listing.notes.join("\n");
+    }
+    if (listing.notes.length === 0)
+        return paths.join("\n");
+    return [...paths, "", ...listing.notes].join("\n");
+}
 function groundSearchOutput(output, workspaceRoot) {
-    if (!workspaceRoot)
-        return output;
     const normalized = normalizeToolText(output);
-    const first = normalized.split("\n", 1)[0] ?? "";
-    const searchShaped = /^Found \d+ matches/.test(first)
-        || first === "No matches found"
-        || first === "No files found";
-    if (!searchShaped && !isBarePathList(normalized))
-        return output;
-    return normalized.split("\n").map((line) => rewriteSearchPathLine(line, workspaceRoot)).join("\n");
+    const grouped = parseGroupedPathListing(normalized);
+    if (grouped)
+        return renderGroupedPathListing(grouped, workspaceRoot);
+    const collapsed = collapseSearchStatus(normalized);
+    if (isSearchStatusReport(collapsed))
+        return collapsed;
+    if (!workspaceRoot)
+        return collapsed;
+    const first = collapsed.split("\n", 1)[0] ?? "";
+    const searchShaped = /^Found \d+ matches/.test(first) || searchStatusMessage(first) !== undefined;
+    if (!searchShaped && !isBarePathList(collapsed))
+        return collapsed;
+    return collapsed.split("\n").map((line) => rewriteSearchPathLine(line, workspaceRoot)).join("\n");
 }
 function isBarePathList(output) {
     const lines = output.split("\n").map((line) => line.trim()).filter(Boolean);
@@ -2013,8 +2194,9 @@ function isBarePathList(output) {
 function rewriteSearchPathLine(line, workspaceRoot) {
     if (!line || line.startsWith(" ") || line.startsWith("\t") || line.startsWith("("))
         return line;
-    if (line.startsWith("Found ") || line === "No matches found" || line === "No files found")
-        return line;
+    const status = searchStatusMessage(line);
+    if (status || line.startsWith("Found "))
+        return status ?? line;
     const header = /^(.*):$/.exec(line);
     if (header && !header[1]?.includes("://")) {
         return `${resolveToolPath(header[1] ?? "", workspaceRoot)}:`;
@@ -2063,22 +2245,99 @@ function rewriteShellPathLine(line, root) {
         return resolveToolPath(trimmed, root);
     return line;
 }
+const OPENCODE_GREP_LINE = /^[ \t]+Line (\d+):[ \t]?(.*)$/;
+/**
+ * OpenCode 1.x and 2.0 both render grep as `Found N matches`, a `path:` header,
+ * and indented `Line N: text` previews. A page with no previews is not content.
+ */
+function parseOpenCodeGrepContent(output, workspaceRoot) {
+    const lines = normalizeToolText(output).split("\n");
+    const first = lines[0]?.trim() ?? "";
+    if (!/^Found \d+ matches\b/.test(first))
+        return undefined;
+    const matches = [];
+    let current;
+    let truncated = /\bmore matches available\b/.test(first);
+    let sawLine = false;
+    for (const raw of lines.slice(1)) {
+        if (!raw.trim())
+            continue;
+        const preview = OPENCODE_GREP_LINE.exec(raw);
+        if (preview) {
+            sawLine = true;
+            if (!current)
+                continue;
+            const lineNumber = Number(preview[1]);
+            if (!Number.isSafeInteger(lineNumber) || lineNumber < 1)
+                continue;
+            current.matches.push({ line_number: lineNumber, content: preview[2] ?? "" });
+            continue;
+        }
+        if (raw.trimStart().startsWith("(")) {
+            if (/truncat/i.test(raw))
+                truncated = true;
+            continue;
+        }
+        if (raw.startsWith(" ") || raw.startsWith("\t"))
+            continue;
+        const header = /^(.*):$/.exec(raw.trim());
+        if (!header || !header[1] || header[1].includes("://"))
+            continue;
+        current = { file: resolveToolPath(header[1], workspaceRoot), matches: [] };
+        matches.push(current);
+    }
+    if (!sawLine)
+        return undefined;
+    const withHits = matches.filter((file) => file.matches.length > 0);
+    if (withHits.length === 0)
+        return undefined;
+    return {
+        matches: withHits,
+        truncated,
+        totalMatchedLines: withHits.reduce((count, file) => count + file.matches.length, 0),
+    };
+}
+function grepRequestResultMetadata(raw) {
+    const pattern = str(raw.pattern);
+    const outputMode = str(raw.output_mode);
+    const searchPath = str(raw.path);
+    if (!pattern && !outputMode && !searchPath)
+        return undefined;
+    return {
+        ...(pattern ? { pattern } : {}),
+        ...(outputMode ? { output_mode: outputMode } : {}),
+        ...(searchPath ? { path: searchPath } : {}),
+    };
+}
 function extractGroundedPaths(output, workspaceRoot) {
     const normalized = normalizeToolText(output);
-    const directory = parseOpenCode2DirectoryListing(normalized, workspaceRoot);
+    const grouped = parseGroupedPathListing(normalized);
+    if (grouped) {
+        return grouped.paths.map((entry) => resolveToolPath(entry, workspaceRoot)).slice(0, 2000);
+    }
+    const collapsed = collapseSearchStatus(normalized);
+    if (isSearchStatusReport(collapsed))
+        return [];
+    const directory = parseOpenCode2DirectoryListing(collapsed, workspaceRoot);
     if (directory)
         return directory.entries.slice(0, 2000);
-    const first = normalized.split("\n", 1)[0]?.trim() ?? "";
-    if (/^Found \d+ matches/.test(first) || first === "No matches found" || first === "No files found") {
+    const first = collapsed.split("\n", 1)[0]?.trim() ?? "";
+    if (/^Found \d+ matches/.test(first) || searchStatusMessage(first)) {
         const paths = [];
-        for (const raw of normalized.split("\n").slice(1)) {
+        for (const raw of collapsed.split("\n").slice(1)) {
             const line = raw.trim();
-            if (!line || line.startsWith("(") || line.startsWith("Line ") || raw.startsWith(" ") || raw.startsWith("\t")) {
+            if (!line
+                || line.startsWith("(")
+                || line.startsWith("Line ")
+                || line.startsWith("#")
+                || searchStatusMessage(line)
+                || raw.startsWith(" ")
+                || raw.startsWith("\t")) {
                 continue;
             }
             const header = /^(.*):$/.exec(line);
             const candidate = header && !header[1]?.includes("://") ? (header[1] ?? "") : line;
-            if (!candidate || candidate.includes("://"))
+            if (!candidate || candidate.includes("://") || searchStatusMessage(candidate))
                 continue;
             paths.push(resolveToolPath(candidate, workspaceRoot));
         }
@@ -2231,21 +2490,50 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
         case "grep_result": {
             if (error)
                 return { error: { error } };
-            // Prefer files_with_matches: OpenCode glob/grep often returns path lists.
-            // Content-mode GrepSuccess also works but needs GrepFileMatch nesting.
-            const files = extractGroundedPaths(output, resultRoot);
             const cwd = resultRoot ?? "";
+            const pattern = str(resultMetadata?.pattern) ?? "";
+            const requestedPath = str(resultMetadata?.path) ?? cwd;
+            const requestedMode = str(resultMetadata?.output_mode);
+            // OpenCode always returns match previews. Cursor's native Grep defaults
+            // to content; encoding that as files_with_matches drops the previews and
+            // the model only sees paths. Keep files_with_matches for an explicit
+            // files-only request, and for path lists (glob remaps, no matches).
+            const parsedContent = parseOpenCodeGrepContent(output, resultRoot);
+            const content = requestedMode === "files_with_matches"
+                ? undefined
+                : parsedContent;
+            if (content) {
+                return {
+                    success: {
+                        pattern,
+                        path: requestedPath,
+                        output_mode: "content",
+                        workspace_results: {
+                            [cwd]: {
+                                content: {
+                                    matches: content.matches,
+                                    total_lines: content.totalMatchedLines,
+                                    total_matched_lines: content.totalMatchedLines,
+                                    client_truncated: content.truncated,
+                                    ripgrep_truncated: false,
+                                },
+                            },
+                        },
+                    },
+                };
+            }
+            const files = extractGroundedPaths(output, resultRoot);
             return {
                 success: {
-                    pattern: "",
-                    path: cwd,
+                    pattern,
+                    path: requestedPath,
                     output_mode: "files_with_matches",
                     workspace_results: {
                         [cwd]: {
                             files: {
                                 files,
                                 total_files: files.length,
-                                client_truncated: false,
+                                client_truncated: parsedContent?.truncated ?? false,
                             },
                         },
                     },
@@ -2253,8 +2541,9 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
             };
         }
         case "write_result": {
-            // `apply_patch` output carries no <path> tag, so prefer the path recorded
-            // when the request was remapped away from `write`.
+            // Prefer the path recorded from WriteArgs / a remapped apply_patch write.
+            // Host write output is not a `<path>` envelope, and Cursor's GetMcpTools
+            // spill copies WriteSuccess.path into the model-visible filePath.
             const remappedPath = str(resultMetadata?.path);
             if (error)
                 return { error: { path: remappedPath ?? "", error } };
@@ -2782,10 +3071,12 @@ function readFileLineCount(filePath) {
     }
 }
 function extractPathLines(output) {
-    const lines = output.split("\n").map((l) => l.trim()).filter(Boolean);
-    // Prefer absolute / relative path-looking lines; fall back to all non-empty.
-    const paths = lines.filter((l) => l.startsWith("/") || l.startsWith("./") || l.includes("/"));
-    return (paths.length > 0 ? paths : lines).slice(0, 2000);
+    const lines = collapseSearchStatus(output).split("\n").map((l) => l.trim()).filter(Boolean);
+    // A folded `# dir/` header is not itself a path. Prefer absolute / relative
+    // path-looking lines; fall back to remaining non-status lines.
+    const usable = lines.filter((line) => !searchStatusMessage(line) && !/^#+\s+\S/.test(line));
+    const paths = usable.filter((l) => l.startsWith("/") || l.startsWith("./") || l.includes("/"));
+    return (paths.length > 0 ? paths : usable).slice(0, 2000);
 }
 function countLines(s) {
     if (!s)