cursor-opencode-provider 0.6.8 → 0.7.1

package/dist/protocol/tools.js

@@ -13,6 +13,67 @@ import { BACKGROUND_SHELL_MARKER, buildBackgroundShellCommand, } from "../shell-
 // probe (ExecServerMessage #10 → ExecClientMessage #10). request/result share a
 // field number for every exec variant, so this is also the result field.
 export const REQUEST_CONTEXT_RESULT_FIELD = 10;
+export const OPENCODE_1_TOOL_DIALECT = {
+    filePathKey: "filePath",
+    shellTool: "bash",
+};
+function jsonSchemaProperties(schema) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema))
+        return undefined;
+    const obj = schema;
+    if (obj.properties && typeof obj.properties === "object" && !Array.isArray(obj.properties)) {
+        return obj.properties;
+    }
+    const nested = obj.jsonSchema;
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+        const props = nested.properties;
+        if (props && typeof props === "object" && !Array.isArray(props)) {
+            return props;
+        }
+    }
+    return undefined;
+}
+/** Prefer `filePath`, then `path` / `file_path` — Cursor and both OpenCode majors. */
+export function opencodePathArg(args) {
+    if (!args)
+        return undefined;
+    return str(args.filePath) ?? str(args.path) ?? str(args.file_path);
+}
+/**
+ * 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) {
+    let filePathKey;
+    for (const name of ["read", "write", "edit"]) {
+        const tool = tools.find((candidate) => candidate.name === name);
+        const props = jsonSchemaProperties(tool?.inputSchema);
+        if (!props)
+            continue;
+        if ("path" in props && !("filePath" in props)) {
+            filePathKey = "path";
+            break;
+        }
+        if ("filePath" in props) {
+            filePathKey = "filePath";
+            break;
+        }
+    }
+    const names = new Set(tools.map((tool) => tool.name).filter((name) => typeof name === "string"));
+    const shellTool = names.has("shell") && !names.has("bash") ? "shell" : "bash";
+    if (!filePathKey) {
+        // OpenCode 2 hosts advertise `shell` and `path` together; use that when schemas are opaque.
+        filePathKey = shellTool === "shell" ? "path" : "filePath";
+    }
+    return { filePathKey, shellTool };
+}
+function assignHostFilePath(args, filePath, dialect) {
+    delete args.filePath;
+    delete args.path;
+    delete args.file_path;
+    if (filePath)
+        args[dialect.filePathKey] = filePath;
+}
 export const CUSTOM_WEBSEARCH_TOOL = "custom_websearch";
 export const CUSTOM_WEBFETCH_TOOL = "custom_webfetch";
 export const CUSTOM_LIST_MCP_RESOURCES_TOOL = "custom_list_mcp_resources";
@@ -171,15 +232,17 @@ export function resolveCustomWebToolAlias(toolName, aliases) {
 export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", knownMcpServers = []) {
     if (tools.length === 0)
         return [];
-    const order = [];
     const byServer = new Map();
-    for (const t of tools) {
+    // 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))) {
         const id = resolveToolServerIdentity(t.sourceName ?? t.name, providerIdentifier, knownMcpServers);
         let list = byServer.get(id.server);
         if (!list) {
             list = [];
             byServer.set(id.server, list);
-            order.push(id.server);
         }
         list.push({
             tool_name: t.sourceName ? t.name : id.toolName,
@@ -187,7 +250,14 @@ export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", kn
             input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
         });
     }
-    return order.map((server) => ({
+    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) => ({
         server_name: server,
         server_identifier: server,
         tools: byServer.get(server),
@@ -262,6 +332,7 @@ const opencodeToolToCursor = {
     write: "write_args",
     grep: "grep_args",
     bash: "shell_stream_args",
+    shell: "shell_stream_args",
     task: "subagent_args",
     mcp: "mcp_args",
 };
@@ -348,33 +419,54 @@ const CURSOR_SUBAGENT_TYPE_TO_OPENCODE = {
     security_review: "explore",
 };
 const SUBAGENT_CATALOG_MARKER = "Available agent types and the tools they have access to:";
+const SUBAGENT_INLINE_MARKER = "Available subagents:";
 function parseSubagentDescriptionCatalog(description) {
     if (!description)
         return { found: false, agents: [] };
     const marker = description.indexOf(SUBAGENT_CATALOG_MARKER);
-    if (marker < 0)
+    if (marker >= 0) {
+        const agents = [];
+        const lines = description.slice(marker + SUBAGENT_CATALOG_MARKER.length).split(/\r?\n/);
+        let started = false;
+        for (const line of lines) {
+            const match = line.match(/^\s*-\s+([^:]+):\s*(.*)$/);
+            if (!match) {
+                if (started && line.trim())
+                    break;
+                continue;
+            }
+            started = true;
+            const name = match[1].trim().replace(/^`|`$/g, "");
+            if (!name)
+                continue;
+            const agentDescription = match[2].trim();
+            agents.push({
+                name,
+                ...(agentDescription ? { description: agentDescription } : {}),
+            });
+        }
+        return { found: true, agents };
+    }
+    // OpenCode 2 `subagent` inlines the list after "Available subagents:".
+    const inlineAt = description.indexOf(SUBAGENT_INLINE_MARKER);
+    if (inlineAt < 0)
         return { found: false, agents: [] };
+    const rest = description.slice(inlineAt + SUBAGENT_INLINE_MARKER.length);
     const agents = [];
-    const lines = description.slice(marker + SUBAGENT_CATALOG_MARKER.length).split(/\r?\n/);
-    let started = false;
-    for (const line of lines) {
-        const match = line.match(/^\s*-\s+([^:]+):\s*(.*)$/);
-        if (!match) {
-            if (started && line.trim())
-                break;
-            continue;
-        }
-        started = true;
-        const name = match[1].trim().replace(/^`|`$/g, "");
-        if (!name)
-            continue;
-        const agentDescription = match[2].trim();
+    const matches = rest.matchAll(/-\s+([A-Za-z0-9_-]+):\s*/g);
+    const hits = [...matches];
+    for (let i = 0; i < hits.length; i++) {
+        const hit = hits[i];
+        const name = hit[1];
+        const start = (hit.index ?? 0) + hit[0].length;
+        const end = i + 1 < hits.length ? (hits[i + 1].index ?? rest.length) : rest.length;
+        const agentDescription = rest.slice(start, end).trim();
         agents.push({
             name,
             ...(agentDescription ? { description: agentDescription } : {}),
         });
     }
-    return { found: true, agents };
+    return { found: agents.length > 0, agents };
 }
 function subagentTypeEnumValues(schema) {
     const out = new Set();
@@ -391,7 +483,8 @@ function subagentTypeEnumValues(schema) {
             return;
         }
         const record = value;
-        if (propertyName === "subagent_type" && Array.isArray(record.enum)) {
+        if ((propertyName === "subagent_type" || propertyName === "agent")
+            && Array.isArray(record.enum)) {
             for (const item of record.enum) {
                 if (typeof item === "string" && item)
                     out.add(item);
@@ -405,16 +498,17 @@ function subagentTypeEnumValues(schema) {
 }
 /** Extract the current host's permission-filtered Task/Actor recipient catalog. */
 export function extractHostSubagentCatalog(tools) {
-    const executorTool = tools.find((tool) => tool.name === "task");
+    const executorTool = tools.find((tool) => tool.name === "task")
+        ?? tools.find((tool) => tool.name === "subagent");
     if (!executorTool)
         return { agents: [], complete: true };
     const described = parseSubagentDescriptionCatalog(executorTool.description);
     const enumNames = subagentTypeEnumValues(executorTool.inputSchema);
     const descriptions = new Map(described.agents.map((agent) => [agent.name, agent.description]));
-    // A structured subagent_type enum is stricter than prose, so it is authoritative.
+    // A structured subagent_type/agent enum is stricter than prose, so it is authoritative.
     const names = new Set(enumNames.length > 0 ? enumNames : described.agents.map((agent) => agent.name));
     return {
-        executor: "task",
+        executor: executorTool.name === "subagent" ? "subagent" : "task",
         agents: [...names].map((name) => ({
             name,
             ...(descriptions.get(name) ? { description: descriptions.get(name) } : {}),
@@ -474,13 +568,19 @@ export function remapNativeSubagentForCatalog(parsed, advertisedToolNames, catal
     if (parsed.resultField !== "subagent_result" || parsed.toolName !== "task")
         return;
     const advertised = new Set(advertisedToolNames);
-    if (!advertised.has("task"))
+    const executor = advertised.has("task")
+        ? "task"
+        : advertised.has("subagent")
+            ? "subagent"
+            : undefined;
+    if (!executor)
         return;
-    const executor = "task";
     const description = str(parsed.args.description) ?? "";
     const prompt = str(parsed.args.prompt) ?? "";
     const cursorSubagentType = str(parsed.resultMetadata?.cursor_subagent_type) ??
-        str(parsed.args.subagent_type) ?? "";
+        str(parsed.args.subagent_type) ??
+        str(parsed.args.agent) ??
+        "";
     const subagentType = resolveCursorSubagentType(cursorSubagentType, catalog);
     if (!subagentType) {
         const available = catalog?.agents.map((agent) => agent.name).join(", ") || "none";
@@ -489,15 +589,23 @@ export function remapNativeSubagentForCatalog(parsed, advertisedToolNames, catal
                 `Available subagents: ${available}.`;
         return;
     }
-    const resumeAgentId = str(parsed.args.task_id);
+    const resumeAgentId = str(parsed.args.task_id) ?? str(parsed.args.sessionID);
     parsed.toolName = executor;
-    parsed.args = {
-        description,
-        prompt,
-        subagent_type: subagentType,
-        ...(resumeAgentId ? { task_id: resumeAgentId } : {}),
-        ...(parsed.args.background === true ? { background: true } : {}),
-    };
+    parsed.args = executor === "subagent"
+        ? {
+            agent: subagentType,
+            description,
+            prompt,
+            ...(resumeAgentId ? { sessionID: resumeAgentId } : {}),
+            ...(parsed.args.background === true ? { background: true } : {}),
+        }
+        : {
+            description,
+            prompt,
+            subagent_type: subagentType,
+            ...(resumeAgentId ? { task_id: resumeAgentId } : {}),
+            ...(parsed.args.background === true ? { background: true } : {}),
+        };
 }
 /** Matches Cursor's own pre-write read threshold (`local-exec` 52428800). */
 const MAX_EDIT_SOURCE_BYTES = 50 * 1024 * 1024;
@@ -625,7 +733,7 @@ export function remapCorrelatedEditWriteForCatalog(parsed, advertisedToolNames,
     const advertised = new Set(advertisedToolNames);
     if (!advertised.has("edit") && !advertised.has(APPLY_PATCH_TOOL))
         return false;
-    const filePath = str(parsed.args.filePath);
+    const filePath = opencodePathArg(parsed.args);
     const content = stringValue(parsed.args.content);
     if (!filePath || content === undefined || !editPath)
         return false;
@@ -651,8 +759,11 @@ export function remapCorrelatedEditWriteForCatalog(parsed, advertisedToolNames,
     if (!replacement)
         return false;
     parsed.toolName = "edit";
+    const filePathKey = typeof parsed.args.path === "string" && typeof parsed.args.filePath !== "string"
+        ? "path"
+        : "filePath";
     parsed.args = {
-        filePath,
+        [filePathKey]: filePath,
         oldString: replacement.oldString,
         newString: replacement.newString,
     };
@@ -687,7 +798,7 @@ export function remapEditToolsForCatalog(parsed, advertisedToolNames, workspaceR
     if (advertised.has(parsed.toolName) || !advertised.has(APPLY_PATCH_TOOL))
         return;
     const requested = parsed.toolName;
-    const filePath = str(parsed.args.filePath);
+    const filePath = opencodePathArg(parsed.args);
     const refuse = (reason) => {
         parsed.toolName = APPLY_PATCH_TOOL;
         parsed.args = {};
@@ -749,6 +860,18 @@ export function remapEditToolsForCatalog(parsed, advertisedToolNames, workspaceR
     // the requested path for the typed Cursor result.
     parsed.resultMetadata = { ...parsed.resultMetadata, path: filePath };
 }
+function readRequestResultMetadata(raw, mappedArgs) {
+    const requestedPath = str(raw.path)
+        ?? str(raw.filePath)
+        ?? str(raw.file_path)
+        ?? opencodePathArg(mappedArgs)
+        ?? "";
+    return {
+        path: requestedPath,
+        ...(typeof mappedArgs.offset === "number" ? { offset: mappedArgs.offset } : {}),
+        ...(typeof mappedArgs.limit === "number" ? { limit: mappedArgs.limit } : {}),
+    };
+}
 /**
  * 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
@@ -775,18 +898,19 @@ export function rejectPartialReadMutation(parsed) {
         || !content.includes("[Partial read:")
         || !content.includes("It is NOT the complete file."))
         return;
-    const filePath = typeof parsed.args.filePath === "string"
-        ? parsed.args.filePath
-        : "the target file";
+    const filePath = opencodePathArg(parsed.args) ?? "the target file";
     const nextOffset = /Continue with offset=(\d+)/.exec(content)?.[1];
+    const longLine = content.includes("Use a byte-preserving read method");
     parsed.localError =
         `NO FILE CHANGE WAS MADE. Refusing a whole-file mutation of ${JSON.stringify(filePath)} ` +
             "because it contains the provider's partial-read notice. Do not retry the same mutation. " +
             (nextOffset
                 ? `Read the file from offset=${nextOffset}, then use a targeted edit or Update File patch.`
-                : "Read the remaining file ranges, then use a targeted edit or Update File patch.");
+                : longLine
+                    ? "Inspect the full line with a byte-preserving read method, then use a targeted edit or Update File patch."
+                    : "Read the remaining file ranges, then use a targeted edit or Update File patch.");
 }
-export function parseExecServerMessage(msg) {
+export function parseExecServerMessage(msg, dialect = OPENCODE_1_TOOL_DIALECT) {
     const id = msg.id;
     if (id === undefined)
         return undefined;
@@ -823,7 +947,7 @@ export function parseExecServerMessage(msg) {
         return {
             id,
             execId,
-            toolName: "bash",
+            toolName: dialect.shellTool,
             args,
             resultField,
             resultMetadata: {
@@ -877,13 +1001,17 @@ export function parseExecServerMessage(msg) {
         // tool name (Cursor's model may have shortened "opencode-read" → "read") and
         // decode the argument map back into JSON for opencode to execute.
         const m = msg.mcp_args ?? {};
-        const mapped = mapCursorArgsToOpencode(mcpRealToolName(m), decodeMcpArgs(m.args), "mcp_args");
+        const rawArgs = decodeMcpArgs(m.args);
+        const mapped = mapCursorArgsToOpencode(mcpRealToolName(m), rawArgs, "mcp_args", dialect);
         return {
             id,
             execId,
             toolName: mapped.toolName,
             args: mapped.args,
             resultField,
+            ...(mapped.toolName === "read"
+                ? { resultMetadata: readRequestResultMetadata(rawArgs, mapped.args) }
+                : {}),
         };
     }
     if (execVariant === "pi_edit_args") {
@@ -896,8 +1024,7 @@ export function parseExecServerMessage(msg) {
         const oldString = replacement ? stringValue(replacement.old_text) : undefined;
         const newString = replacement ? stringValue(replacement.new_text) : undefined;
         const args = {};
-        if (path)
-            args.filePath = path;
+        assignHostFilePath(args, path, dialect);
         if (oldString !== undefined)
             args.oldString = oldString;
         if (newString !== undefined)
@@ -916,16 +1043,12 @@ export function parseExecServerMessage(msg) {
     const toolName = cursorToolToOpencode[execVariant];
     if (!toolName)
         return undefined;
-    const mapped = mapCursorArgsToOpencode(toolName, msg[execVariant] ?? {}, execVariant);
+    const mapped = mapCursorArgsToOpencode(toolName, msg[execVariant] ?? {}, execVariant, dialect);
     const rawArgs = msg[execVariant] ?? {};
     const resultMetadata = execVariant === "shell_stream_args" || execVariant === "shell_args"
         ? shellStreamResultMetadata(rawArgs)
-        : execVariant === "read_args"
-            ? {
-                path: str(rawArgs.path) ?? str(rawArgs.file_path) ?? "",
-                ...(typeof mapped.args.offset === "number" ? { offset: mapped.args.offset } : {}),
-                ...(typeof mapped.args.limit === "number" ? { limit: mapped.args.limit } : {}),
-            }
+        : execVariant === "read_args" || execVariant === "pi_read_args"
+            ? readRequestResultMetadata(rawArgs, mapped.args)
             : undefined;
     if (resultMetadata
         && resultMetadata.timeout_behavior !== 2
@@ -980,7 +1103,7 @@ function shellStreamResultMetadata(raw) {
  * Without this, OpenCode rejects calls with InvalidArgumentsError
  * (e.g. `path` instead of `filePath`, `file_text` instead of `content`).
  */
-export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
+export function mapCursorArgsToOpencode(toolName, raw, execVariant, dialect = OPENCODE_1_TOOL_DIALECT) {
     const cleaned = {};
     for (const [k, v] of Object.entries(raw)) {
         if (v === undefined || v === null)
@@ -996,7 +1119,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
     // Native ls_args → OpenCode read (directory listing via read).
     if (execVariant === "ls_args") {
         const filePath = str(cleaned.path) ?? str(cleaned.filePath);
-        return { toolName: "read", args: filePath ? { filePath } : {} };
+        return { toolName: "read", args: filePath ? { [dialect.filePathKey]: filePath } : {} };
     }
     // F11: Cursor native delete_args → OpenCode bash. No delete builtin exists, so
     // we emulate with `rm -f -- <path>` (shell-quoted). Same permission boundary
@@ -1004,7 +1127,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
     if (execVariant === "delete_args") {
         const target = str(cleaned.path) ?? str(cleaned.filePath);
         return {
-            toolName: "bash",
+            toolName: dialect.shellTool,
             args: target ? { command: `rm -f -- ${shellQuote(target)}` } : { command: "true" },
         };
     }
@@ -1012,8 +1135,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
         case "read": {
             const args = {};
             const filePath = str(cleaned.filePath) ?? str(cleaned.path) ?? str(cleaned.file_path);
-            if (filePath)
-                args.filePath = filePath;
+            assignHostFilePath(args, filePath, dialect);
             // Cursor often sends offset=0/limit=0 as protobuf defaults. OpenCode's
             // read treats limit=0 as "read zero lines" (empty content) — omit zeros.
             const offset = num(cleaned.offset);
@@ -1027,8 +1149,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
         case "write": {
             const args = {};
             const filePath = str(cleaned.filePath) ?? str(cleaned.path) ?? str(cleaned.file_path);
-            if (filePath)
-                args.filePath = filePath;
+            assignHostFilePath(args, filePath, dialect);
             // Cursor's LocalWriteExecutor prefers `file_bytes` whenever it is
             // non-empty and only falls back to `file_text`; mirror that order so a
             // byte-encoded write is not silently seen as empty content.
@@ -1060,8 +1181,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
             }
             const args = {};
             const filePath = str(cleaned.filePath) ?? str(cleaned.path) ?? str(cleaned.file_path);
-            if (filePath)
-                args.filePath = filePath;
+            assignHostFilePath(args, filePath, dialect);
             const oldString = stringValue(cleaned.oldString) ?? stringValue(cleaned.old_string);
             if (oldString !== undefined)
                 args.oldString = oldString;
@@ -1072,7 +1192,8 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
                 args.replaceAll = cleaned.replaceAll;
             return { toolName: "edit", args };
         }
-        case "bash": {
+        case "bash":
+        case "shell": {
             const args = {};
             const command = str(cleaned.command);
             if (command)
@@ -1083,7 +1204,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
             const timeout = num(cleaned.timeout);
             if (timeout !== undefined)
                 args.timeout = timeout;
-            return { toolName: "bash", args };
+            return { toolName: dialect.shellTool, args };
         }
         case "grep": {
             const pattern = str(cleaned.pattern);
@@ -1193,12 +1314,33 @@ function num(v) {
         return Number(v);
     return undefined;
 }
+/**
+ * Fallback OpenCode task title when Cursor's SubagentArgs has no description.
+ * Prefer {@link preferCorrelatedTaskDescription} when a TaskToolCall is available —
+ * that carries Cursor's real 3–5 word title. This only slices the prompt.
+ */
 function describeSubagentTask(prompt, subagentType) {
     const words = prompt?.replace(/\s+/g, " ").trim().split(" ").filter(Boolean).slice(0, 5);
     if (words?.length)
         return words.join(" ");
     return `${subagentType || "Delegated"} task`;
 }
+/**
+ * Replace the prompt-derived task title with Cursor's TaskToolCall description
+ * when the display call is correlated via tool_call_id. SubagentArgs itself has
+ * no description field, so without this OpenCode shows a cut-off first-five-words
+ * slice of the prompt.
+ */
+export function preferCorrelatedTaskDescription(parsed, description) {
+    if (parsed.toolName !== "task" && parsed.toolName !== "subagent")
+        return;
+    if (parsed.resultField !== "subagent_result")
+        return;
+    const trimmed = description?.trim();
+    if (!trimmed)
+        return;
+    parsed.args.description = trimmed;
+}
 function shellQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
 }
@@ -1288,9 +1430,11 @@ export function isUriReadTarget(requested) {
  */
 export function resolveReadTargetPath(requested, workspaceRoot) {
     const expanded = untildify(requested);
-    if (workspaceRoot && !path.isAbsolute(expanded)) {
-        return path.resolve(workspaceRoot, expanded);
+    if (isAbsoluteToolPath(expanded)) {
+        return isForeignAbsoluteToolPath(expanded) ? expanded : path.resolve(expanded);
     }
+    if (workspaceRoot)
+        return joinToolPath(workspaceRoot, expanded);
     return path.resolve(expanded);
 }
 /**
@@ -1355,6 +1499,7 @@ export function buildExecClientMessages(input) {
     const resultField = input.resultField || "mcp_result";
     const frames = [];
     if (resultField === "shell_stream") {
+        const stdout = groundShellPathText(input.output, shellPathRoot(input.resultMetadata, input.workspaceRoot));
         // Real clients always emit Start → Stdout/Stderr* → Exit (capture/tests).
         frames.push(encodeShellStream(input.execId, undefined, { start: {} }));
         if (input.error) {
@@ -1362,8 +1507,8 @@ export function buildExecClientMessages(input) {
             frames.push(encodeShellStream(input.execId, input.executionTimeMs, { exit: { code: 1, aborted: false } }));
         }
         else {
-            if (input.output) {
-                frames.push(encodeShellStream(input.execId, undefined, { stdout: { data: input.output } }));
+            if (stdout) {
+                frames.push(encodeShellStream(input.execId, undefined, { stdout: { data: stdout } }));
             }
             if (input.shellOutcome?.kind === "backgrounded") {
                 frames.push(encodeShellStream(input.execId, input.executionTimeMs, {
@@ -1573,17 +1718,396 @@ export function buildUnsupportedExecDeny(input) {
     frames.push(buildExecStreamClose(execId));
     return frames;
 }
+/** OpenCode 2 `read` prints this when a text page does not reach EOF. */
+const OPENCODE2_READ_TRUNCATION = /^\[Output truncated\. Continue reading with offset:\s*(\d+)\]\s*$/;
+/** OpenCode 2 stops a read at 2,000 lines as well as 50 KB. */
+const OPENCODE2_READ_MAX_LINES = 2_000;
+const OPENCODE2_READ_MAX_LINE_CHARS = 2_000;
+const OPENCODE2_READ_LINE_TRUNCATION = `... (line truncated to ${OPENCODE2_READ_MAX_LINE_CHARS} chars)`;
+/**
+ * `read-filesystem.ts` shortens each selected line to 2,000 UTF-16 code units.
+ * One code unit encodes to at most three UTF-8 bytes. Add the 34-byte
+ * `... (line truncated to 2000 chars)` suffix and one line separator when
+ * proving a page was close enough for the next line not to fit.
+ */
+const OPENCODE2_MAX_RENDERED_LINE_BYTES = (OPENCODE2_READ_MAX_LINE_CHARS * 3) + Buffer.byteLength(OPENCODE2_READ_LINE_TRUNCATION, "utf8") + 1;
+function normalizeToolText(output) {
+    return output.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+/**
+ * OpenCode 2 `ReadTool.toModelContent` for a file. The whole string must match;
+ * a file that merely quotes the header stays a numbered body line.
+ *
+ *   Read file <path>, lines <start>-<end>
+ *   <n>: <line>
+ *   [Output truncated. Continue reading with offset: <next>]
+ */
+function parseOpenCode2FileRead(output, resultMetadata) {
+    const normalized = normalizeToolText(output).replace(/\n+$/, "");
+    if (!normalized.startsWith("Read file "))
+        return undefined;
+    const lines = normalized.split("\n");
+    const headerLine = (lines[0] ?? "").trim();
+    const empty = /^Read file (.*), 0 lines$/.exec(headerLine);
+    if (empty) {
+        if (lines.length !== 1)
+            return undefined;
+        return {
+            path: empty[1] ?? "",
+            content: "",
+            totalLines: 0,
+            hostTruncated: false,
+            outputCapped: false,
+            truncatedLines: [],
+        };
+    }
+    const header = /^Read file (.*), lines (\d+)-(\d+)$/.exec(headerLine);
+    if (!header)
+        return undefined;
+    const start = Number(header[2]);
+    const end = Number(header[3]);
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 1 || end < start) {
+        return undefined;
+    }
+    let bodyEnd = lines.length;
+    let nextOffset;
+    const banner = OPENCODE2_READ_TRUNCATION.exec(lines[lines.length - 1] ?? "");
+    if (banner) {
+        nextOffset = Number(banner[1]);
+        if (!Number.isSafeInteger(nextOffset) || nextOffset < 1)
+            return undefined;
+        bodyEnd -= 1;
+    }
+    const expected = end - start + 1;
+    if (bodyEnd - 1 !== expected)
+        return undefined;
+    const raw = [];
+    const truncatedLines = [];
+    for (let index = 0; index < expected; index++) {
+        const match = /^(\d+):[ \t](.*)$/.exec(lines[index + 1] ?? "");
+        if (!match || Number(match[1]) !== start + index)
+            return undefined;
+        const value = match[2] ?? "";
+        if (value.length === OPENCODE2_READ_MAX_LINE_CHARS + OPENCODE2_READ_LINE_TRUNCATION.length
+            && value.endsWith(OPENCODE2_READ_LINE_TRUNCATION)) {
+            truncatedLines.push(start + index);
+        }
+        raw.push(value);
+    }
+    const content = raw.join("\n");
+    const hostTruncated = nextOffset !== undefined;
+    const requestedLimit = num(resultMetadata?.limit);
+    const effectiveLineLimit = requestedLimit !== undefined && requestedLimit > 0
+        ? Math.min(requestedLimit, OPENCODE2_READ_MAX_LINES)
+        : OPENCODE2_READ_MAX_LINES;
+    // OpenCode 2 ends a text page only for the requested/default line limit or
+    // the 50 KiB byte limit. Fewer lines than the effective line limit, together
+    // with a page close enough that one maximum-size rendered line may not fit,
+    // identifies the byte cap without the old ASCII-only 4 KiB guess.
+    const outputCapped = hostTruncated
+        && expected < effectiveLineLimit
+        && Buffer.byteLength(content, "utf8") > OPENCODE_READ_MAX_BYTES - OPENCODE2_MAX_RENDERED_LINE_BYTES;
+    if (hostTruncated) {
+        return {
+            path: header[1] ?? "",
+            content,
+            startLine: start,
+            endLine: end,
+            nextOffset,
+            hostTruncated: true,
+            outputCapped,
+            truncatedLines,
+        };
+    }
+    // A page that reached EOF is complete. Record the span so a non-1 offset is
+    // not later mistaken for a silent cap, without flagging it truncated.
+    return {
+        path: header[1] ?? "",
+        content,
+        ...(start === 1
+            ? { totalLines: end }
+            : { startLine: start, endLine: end, totalLines: end }),
+        hostTruncated: false,
+        outputCapped: false,
+        truncatedLines,
+    };
+}
+/**
+ * OpenCode 2 directory reads list bare entry names. Join them onto the
+ * directory, then onto the workspace root, so the model can copy a real path
+ * instead of inventing an absolute prefix.
+ */
+function parseOpenCode2DirectoryListing(output, workspaceRoot) {
+    const normalized = normalizeToolText(output).replace(/\n+$/, "");
+    if (!normalized.startsWith("Read directory "))
+        return undefined;
+    const lines = normalized.split("\n");
+    const header = /^Read directory (.*), (?:0 entries|entries (\d+)-(\d+))$/.exec((lines[0] ?? "").trim());
+    if (!header) {
+        trace("parseOpenCode2DirectoryListing: OpenCode 2 directory header did not match — leaving output unchanged");
+        return undefined;
+    }
+    const requested = header[1] ?? "";
+    if (!isAbsoluteToolPath(requested) && !workspaceRoot)
+        return undefined;
+    let bodyEnd = lines.length;
+    let banner;
+    if (bodyEnd > 1 && OPENCODE2_READ_TRUNCATION.test(lines[bodyEnd - 1] ?? "")) {
+        banner = lines[bodyEnd - 1];
+        bodyEnd -= 1;
+    }
+    const rawEntries = lines.slice(1, bodyEnd);
+    if (header[2] === undefined) {
+        if (rawEntries.length !== 0)
+            return undefined;
+    }
+    else {
+        const start = Number(header[2]);
+        const end = Number(header[3]);
+        if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || end - start + 1 !== rawEntries.length) {
+            return undefined;
+        }
+    }
+    const directory = resolveToolPath(requested, workspaceRoot);
+    const directories = [];
+    const files = [];
+    const entries = rawEntries.map((entry) => {
+        const resolved = resolveListedEntry(directory, entry);
+        if (entry.endsWith("/") || entry.endsWith("\\"))
+            directories.push(resolved);
+        else
+            files.push(resolved);
+        return resolved;
+    });
+    const headerLine = header[2] === undefined
+        ? `Read directory ${directory}, 0 entries`
+        : `Read directory ${directory}, entries ${header[2]}-${header[3]}`;
+    return {
+        directory,
+        entries,
+        directories,
+        files,
+        text: [headerLine, ...entries, ...(banner ? [banner] : [])].join("\n"),
+    };
+}
+/**
+ * Absolute on this host, plus Windows drive and UNC paths. A posix agent must
+ * not prefix `C:/…` or `\\server\…` just because `path.isAbsolute` rejects them.
+ */
+function isAbsoluteToolPath(filePath) {
+    return path.isAbsolute(filePath)
+        || /^[A-Za-z]:[\\/]/.test(filePath)
+        || filePath.startsWith("\\\\");
+}
+/** Windows drive or UNC path that `path.isAbsolute` rejects on this host. */
+function isForeignAbsoluteToolPath(filePath) {
+    return isAbsoluteToolPath(filePath) && !path.isAbsolute(filePath);
+}
+/** Separator already used by a drive or UNC path. Host paths keep `path.sep`. */
+function toolPathSeparator(filePath) {
+    if (path.isAbsolute(filePath))
+        return path.sep;
+    if (filePath.startsWith("\\\\") || (filePath.includes("\\") && !filePath.includes("/")))
+        return "\\";
+    return "/";
+}
+/**
+ * Join `relative` onto `root`. Node's `path.resolve` treats `C:/…` and
+ * `\\server\…` as relative on posix and prefixes the process cwd. Keep those
+ * roots intact, including `..`, and still use `path.resolve` for host paths.
+ */
+function joinToolPath(root, relative) {
+    if (!isForeignAbsoluteToolPath(root))
+        return path.resolve(root, relative);
+    const sep = toolPathSeparator(root);
+    const base = splitForeignAbsolute(root, sep);
+    const parts = [...base.segments];
+    for (const part of relative.split(/[\\/]+/)) {
+        if (!part || part === ".")
+            continue;
+        if (part === "..") {
+            if (parts.length > base.frozen)
+                parts.pop();
+            continue;
+        }
+        parts.push(part);
+    }
+    return parts.length === 0 ? base.prefix : `${base.prefix}${parts.join(sep)}`;
+}
+function splitForeignAbsolute(filePath, sep) {
+    if (filePath.startsWith("\\\\")) {
+        const segments = filePath.slice(2).split(/[\\/]+/).filter(Boolean);
+        return { prefix: "\\\\", segments, frozen: Math.min(2, segments.length) };
+    }
+    const rest = filePath.slice(2).replace(/^[\\/]+/, "");
+    return {
+        prefix: `${filePath.slice(0, 2)}${sep}`,
+        segments: rest ? rest.split(/[\\/]+/).filter(Boolean) : [],
+        frozen: 0,
+    };
+}
+function isRelativePathToken(token) {
+    if (!token || isAbsoluteToolPath(token))
+        return false;
+    // A slash alone does not make arbitrary shell output a path. In particular,
+    // compact JSON, quoted strings, package ids, and shell syntax must remain
+    // byte-for-byte model-visible rather than being prefixed with the workspace.
+    if (/[\0"'`{}\[\]<>|;]/.test(token) || token.startsWith("@"))
+        return false;
+    if (token.startsWith("./")
+        || token.startsWith("../")
+        || token.startsWith(".\\")
+        || token.startsWith("..\\"))
+        return true;
+    return token.includes("/") || (path.sep === "\\" && token.includes("\\"));
+}
+function resolveListedEntry(directory, entry) {
+    if (!entry || isAbsoluteToolPath(entry))
+        return entry;
+    if (entry === "~" || entry.startsWith("~/") || entry.startsWith("~\\"))
+        return entry;
+    const directoryEntry = entry.endsWith("/") || entry.endsWith("\\");
+    const resolved = joinToolPath(directory, entry);
+    if (!directoryEntry || resolved.endsWith("/") || resolved.endsWith("\\"))
+        return resolved;
+    return `${resolved}${toolPathSeparator(resolved)}`;
+}
+function resolveToolPath(filePath, workspaceRoot) {
+    if (!filePath || isAbsoluteToolPath(filePath))
+        return filePath;
+    if (filePath === "~" || filePath.startsWith("~/") || filePath.startsWith("~\\"))
+        return filePath;
+    if (!workspaceRoot)
+        return filePath;
+    return joinToolPath(workspaceRoot, filePath);
+}
+/**
+ * Rewrite OpenCode 2 grep/glob lines that are still project-relative. Absolute
+ * 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.
+ */
+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");
+}
+function isBarePathList(output) {
+    const lines = output.split("\n").map((line) => line.trim()).filter(Boolean);
+    if (lines.length === 0 || lines.length > 2000)
+        return false;
+    return lines.every((line) => {
+        if (line.startsWith("("))
+            return true;
+        if (/\s/.test(line) || line.includes("://"))
+            return false;
+        return true;
+    });
+}
+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 header = /^(.*):$/.exec(line);
+    if (header && !header[1]?.includes("://")) {
+        return `${resolveToolPath(header[1] ?? "", workspaceRoot)}:`;
+    }
+    if (line.includes("://"))
+        return line;
+    return resolveToolPath(line, workspaceRoot);
+}
+/**
+ * Shell stdout is mixed prose. Rewrite only tokens that are clearly relative
+ * paths, including `file:line` and `file:line:col`. Leave sentences, URLs, and
+ * status words alone.
+ */
+function groundShellPathText(output, root) {
+    if (!root || !output)
+        return output;
+    return normalizeToolText(output).split("\n").map((line) => rewriteShellPathLine(line, root)).join("\n");
+}
+function shellPathRoot(resultMetadata, workspaceRoot) {
+    const workingDirectory = str(resultMetadata?.working_directory)?.trim();
+    if (!workingDirectory)
+        return workspaceRoot;
+    if (isAbsoluteToolPath(workingDirectory))
+        return workingDirectory;
+    return workspaceRoot ? joinToolPath(workspaceRoot, workingDirectory) : undefined;
+}
+function rewriteShellPathLine(line, root) {
+    if (!line || line.startsWith(" ") || line.startsWith("\t"))
+        return line;
+    const trimmed = line.trimEnd();
+    if (trimmed.includes("://") || trimmed === "~" || trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+        return line;
+    }
+    const located = /^(.+?):(\d+)(?::(\d+))?$/.exec(trimmed);
+    if (located && located[1] && isRelativePathToken(located[1])) {
+        const suffix = located[3] !== undefined ? `:${located[2]}:${located[3]}` : `:${located[2]}`;
+        return `${resolveToolPath(located[1], root)}${suffix}`;
+    }
+    if (/\s/.test(trimmed))
+        return line;
+    const header = /^(.*):$/.exec(trimmed);
+    if (header && header[1] && isRelativePathToken(header[1])) {
+        return `${resolveToolPath(header[1], root)}:`;
+    }
+    if (isRelativePathToken(trimmed))
+        return resolveToolPath(trimmed, root);
+    return line;
+}
+function extractGroundedPaths(output, workspaceRoot) {
+    const normalized = normalizeToolText(output);
+    const directory = parseOpenCode2DirectoryListing(normalized, 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 paths = [];
+        for (const raw of normalized.split("\n").slice(1)) {
+            const line = raw.trim();
+            if (!line || line.startsWith("(") || line.startsWith("Line ") || raw.startsWith(" ") || raw.startsWith("\t")) {
+                continue;
+            }
+            const header = /^(.*):$/.exec(line);
+            const candidate = header && !header[1]?.includes("://") ? (header[1] ?? "") : line;
+            if (!candidate || candidate.includes("://"))
+                continue;
+            paths.push(resolveToolPath(candidate, workspaceRoot));
+        }
+        return paths.slice(0, 2000);
+    }
+    if (isBarePathList(output)) {
+        return output
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith("("))
+            .map((line) => resolveToolPath(line.endsWith(":") && !line.includes("://") ? line.slice(0, -1) : line, workspaceRoot))
+            .slice(0, 2000);
+    }
+    return extractPathLines(output).map((line) => {
+        const trimmed = line.trim();
+        const candidate = trimmed.endsWith(":") && !trimmed.includes("://") ? trimmed.slice(0, -1) : trimmed;
+        return resolveToolPath(candidate, workspaceRoot);
+    });
+}
 /**
  * Strip opencode's `read` envelope, leaving raw file content.
  *
- * opencode's read tool (opencode `tool/read.ts`) wraps content in an XML-ish
- * envelope its own models are trained on, but Cursor's are not:
+ * OpenCode 1.x (`tool/read.ts`) wraps content in an XML-ish envelope its own
+ * models are trained on, but Cursor's are not:
  *   <path>{abs}</path>\n<type>file</type>\n<content>\n{N}: {line}\n…\n\n{footer}\n</content>
- * Forwarding that envelope verbatim made Cursor's model treat the wrapper as
- * literal file content and write `<path>`/`<content>` tags + `N:` line prefixes
- * back into files (silent corruption — the write still reports success; seen
- * across 8+ sessions, e.g. language-model.ts rewritten starting with
- * `<path>…</path>\n<type>file</type>\n<content>\n1: import fs…`).
+ * OpenCode 2 replaced that with `Read file <path>, lines <start>-<end>` plus
+ * the same `N: ` prefixes and `[Output truncated. Continue reading with offset: N]`.
+ * Forwarding either envelope verbatim made Cursor's model treat the wrapper as
+ * literal file content and write tags or line prefixes back into files.
  *
  * Returns the raw file body (line numbers + footer + `<system-reminder>` dropped).
  *
@@ -1596,6 +2120,12 @@ export function buildUnsupportedExecDeny(input) {
 export function unwrapReadOutput(output) {
     if (typeof output !== "string" || output.length === 0)
         return output;
+    const opencode2 = parseOpenCode2FileRead(output);
+    if (opencode2)
+        return opencode2.content;
+    if (normalizeToolText(output).startsWith("Read file ")) {
+        trace("unwrapReadOutput: OpenCode 2 read header did not match the page parser — leaving output unchanged");
+    }
     // Require the full opencode read-envelope skeleton *before* `<content>`
     // (read.ts opens with <path>…</path>, <type>file</type>, <content>) so a
     // stray "<content>" later in tool chatter can't trigger unwrapping just
@@ -1646,34 +2176,53 @@ export function unwrapReadOutput(output) {
 export function buildTypedExecResult(resultField, output, error, toolName, resultMetadata, shellOutcome, workspaceRoot) {
     // Prefer the session workspace; never advertise the host process cwd (daemon
     // often starts in $HOME) as the path Cursor shows the model for glob/ls.
-    const resultRoot = typeof workspaceRoot === "string" && workspaceRoot.trim()
-        ? path.resolve(workspaceRoot)
+    const trimmedRoot = typeof workspaceRoot === "string" ? workspaceRoot.trim() : "";
+    // A posix process must not turn `C:/…` or `\\server\…` into `<cwd>/C:/…`.
+    const resultRoot = trimmedRoot
+        ? (isForeignAbsoluteToolPath(trimmedRoot) ? trimmedRoot : path.resolve(trimmedRoot))
         : undefined;
     switch (resultField) {
         case "read_result": {
-            const readPath = str(resultMetadata?.path) ?? extractPathTag(output) ?? "";
+            const parsedFile = parseOpenCode2FileRead(output, resultMetadata);
+            const listing = error ? undefined : parseOpenCode2DirectoryListing(output, resultRoot);
+            const rawPath = str(resultMetadata?.path)
+                ?? parsedFile?.path
+                ?? listing?.directory
+                ?? extractPathTag(output)
+                ?? "";
+            const readPath = resolveToolPath(rawPath, resultRoot);
             if (error)
                 return { error: { path: readPath, error } };
-            // Strip opencode's <path>/<content> envelope so Cursor's model receives
-            // raw file content and can't echo the wrapper into subsequent writes.
+            // The host may have resolved an alternate spelling after the request
+            // (for example a Unicode-space filename). Use the result's own path for
+            // local stat/newline recovery while preserving the requested path in the
+            // Cursor result, matching the existing OpenCode 1 behavior.
+            const outputPath = parsedFile?.path ?? extractPathTag(output);
+            const statPath = resolveToolPath(outputPath ?? readPath, resultRoot);
+            // Strip OpenCode's read envelope so Cursor's model receives raw file
+            // content and can't echo the wrapper into subsequent writes.
             // Cursor's native read_args lands here; `mcp_args` reads land in
             // mcp_result. Live captures show gpt-5.4-mini and grok-4.5 both use the
             // native channel, so this is the path that matters in practice.
-            const statPath = extractPathTag(output) ?? readPath;
-            const outputMetadata = parseOpenCodeReadMetadata(output);
-            const content = restoreCompleteReadTerminator(unwrapReadOutput(output), statPath, outputMetadata, resultMetadata, resultRoot);
+            const outputMetadata = parseOpenCodeReadMetadata(output, resultMetadata);
+            const content = listing
+                ? listing.text
+                : restoreCompleteReadTerminator(unwrapReadOutput(output), statPath, outputMetadata, resultMetadata, resultRoot);
             const totalLines = outputMetadata.totalLines ?? readFileLineCount(statPath) ?? countLines(content);
             const rangeApplied = readRangeApplied(resultMetadata, totalLines);
             // `truncated` alone is not enough: it is set here, and models still assert
             // the partial content is the whole file. Cursor's own executor puts the
             // limit marker in the output text for the same reason, so append one.
-            const notice = readTruncationNotice(output, resultMetadata);
+            const notices = [
+                readTruncationNotice(output, resultMetadata),
+                readLongLineTruncationNotice(output),
+            ].filter((notice) => !!notice);
             return {
                 success: {
-                    path: readPath,
-                    content: notice ? `${content}\n\n${notice}` : content,
+                    path: listing?.directory || readPath,
+                    content: notices.length > 0 ? `${content}\n\n${notices.join("\n\n")}` : content,
                     total_lines: totalLines,
-                    file_size: readFileSize(statPath),
+                    file_size: listing ? 0 : readFileSize(statPath),
                     truncated: readOutputTruncated(resultMetadata, outputMetadata, totalLines),
                     range_applied: rangeApplied,
                 },
@@ -1684,7 +2233,7 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
                 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 = extractPathLines(output);
+            const files = extractGroundedPaths(output, resultRoot);
             const cwd = resultRoot ?? "";
             return {
                 success: {
@@ -1728,19 +2277,20 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
             // Pi results carry truncation structurally (PiReadExecSuccess field 2),
             // which is how Cursor's own executors report a capped payload.
             const content = unwrapReadOutput(output);
-            const truncation = readTruncationMessage(output, content);
+            const truncation = readTruncationMessage(output, content, resultMetadata);
             return { success: { output: content, ...(truncation ? { truncation } : {}) } };
         }
         case "shell_result": {
             const command = str(resultMetadata?.command) ?? "";
             const workingDirectory = str(resultMetadata?.working_directory) ?? "";
+            const stdout = groundShellPathText(output, shellPathRoot(resultMetadata, resultRoot));
             if (error) {
                 return {
                     failure: {
                         command,
                         working_directory: workingDirectory,
                         exit_code: 1,
-                        stdout: output || "",
+                        stdout: stdout || "",
                         stderr: error,
                         aborted: false,
                     },
@@ -1761,7 +2311,7 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
                         command: shellOutcome.command || command,
                         working_directory: shellOutcome.workingDirectory || workingDirectory,
                         exit_code: 0,
-                        stdout: output,
+                        stdout: stdout,
                         shell_id: shellOutcome.shellId,
                         pid: shellOutcome.pid,
                         ms_to_wait: shellOutcome.msToWait,
@@ -1779,18 +2329,29 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
                     command,
                     working_directory: workingDirectory,
                     exit_code: exitCode,
-                    stdout: output,
+                    stdout: stdout,
                 },
             };
         }
         case "pi_bash_result":
+            if (error)
+                return { error: { error } };
+            return { success: { output: groundShellPathText(output, shellPathRoot(resultMetadata, resultRoot)) } };
         case "pi_edit_result":
+            if (error)
+                return { error: { error } };
+            return { success: { output } };
         case "pi_grep_result":
         case "pi_find_result":
-        case "pi_ls_result":
             if (error)
                 return { error: { error } };
-            return { success: { output } };
+            return { success: { output: groundSearchOutput(output, resultRoot) } };
+        case "pi_ls_result": {
+            if (error)
+                return { error: { error } };
+            const listing = parseOpenCode2DirectoryListing(output, resultRoot);
+            return { success: { output: listing?.text ?? groundSearchOutput(output, resultRoot) } };
+        }
         case "delete_result":
             if (error)
                 return { error: { path: "", error } };
@@ -1836,17 +2397,25 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
         case "ls_result": {
             if (error)
                 return { error: { path: "", error } };
-            const rootPath = resultRoot ?? "";
-            const entries = extractPathLines(output);
+            const listing = parseOpenCode2DirectoryListing(output, resultRoot);
+            const rootPath = listing?.directory || resultRoot || "";
+            const entries = listing ? listing.entries : extractGroundedPaths(output, resultRoot);
+            const directories = listing?.directories ?? [];
+            const files = listing?.files ?? entries;
             return {
                 success: {
                     directory_tree_root: {
                         abs_path: rootPath,
-                        children_dirs: [],
-                        children_files: entries.map((name) => ({
-                            name: name.includes("/") ? name.slice(name.lastIndexOf("/") + 1) : name,
+                        children_dirs: directories.map((entry) => ({
+                            abs_path: stripTrailingPathSeparator(entry),
+                            children_dirs: [],
+                            children_files: [],
+                            num_files: 0,
                         })),
-                        num_files: entries.length,
+                        children_files: files.map((entry) => ({
+                            name: listedEntryName(entry),
+                        })),
+                        num_files: files.length,
                     },
                 },
             };
@@ -1858,17 +2427,34 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
             // a read call returns through mcp_result. Scope the unwrap to toolName
             // "read" so a non-read MCP tool whose output merely contains a
             // "<content>"-like block is never rewritten.
+            if (toolName === "grep" || toolName === "glob") {
+                return {
+                    success: {
+                        content: [{ text: { text: groundSearchOutput(output, resultRoot) } }],
+                        is_error: false,
+                    },
+                };
+            }
             if (toolName !== "read") {
                 return { success: { content: [{ text: { text: output } }], is_error: false } };
             }
+            const listing = parseOpenCode2DirectoryListing(output, resultRoot);
+            if (listing) {
+                return {
+                    success: { content: [{ text: { text: listing.text } }], is_error: false },
+                };
+            }
             // Carry the truncation notice as its own content item: the file content
             // item stays byte-exact, so it can still never be echoed into a write.
-            const notice = readTruncationNotice(output);
+            const notices = [
+                readTruncationNotice(output, resultMetadata),
+                readLongLineTruncationNotice(output),
+            ].filter((notice) => !!notice);
             return {
                 success: {
                     content: [
                         { text: { text: unwrapReadOutput(output) } },
-                        ...(notice ? [{ text: { text: notice } }] : []),
+                        ...notices.map((notice) => ({ text: { text: notice } })),
                     ],
                     is_error: false,
                 },
@@ -1945,7 +2531,19 @@ function readEnvelopeFooter(output) {
     return output.slice(start + 2, close);
 }
 /** Recover full-file metadata before unwrapReadOutput removes OpenCode's footer. */
-function parseOpenCodeReadMetadata(output) {
+function parseOpenCodeReadMetadata(output, resultMetadata) {
+    const opencode2 = parseOpenCode2FileRead(output, resultMetadata);
+    if (opencode2) {
+        return {
+            ...(opencode2.startLine !== undefined ? { startLine: opencode2.startLine } : {}),
+            ...(opencode2.endLine !== undefined ? { endLine: opencode2.endLine } : {}),
+            ...(opencode2.totalLines !== undefined ? { totalLines: opencode2.totalLines } : {}),
+            ...(opencode2.nextOffset !== undefined ? { nextOffset: opencode2.nextOffset } : {}),
+            outputCapped: opencode2.outputCapped,
+            hostTruncated: opencode2.hostTruncated,
+            ...(opencode2.truncatedLines.length > 0 ? { truncatedLines: opencode2.truncatedLines } : {}),
+        };
+    }
     const footer = readEnvelopeFooter(output);
     const showing = /Showing lines (\d+)-(\d+)(?: of (\d+))?\./.exec(footer);
     if (showing) {
@@ -1977,9 +2575,9 @@ function restoreCompleteReadTerminator(content, readPath, metadata, resultMetada
         || num(resultMetadata?.limit) !== undefined
         || content.endsWith("\n"))
         return content;
-    const absolute = path.isAbsolute(readPath)
+    const absolute = isAbsoluteToolPath(readPath)
         ? readPath
-        : path.resolve(workspaceRoot ?? process.cwd(), readPath);
+        : joinToolPath(workspaceRoot ?? process.cwd(), readPath);
     let fd;
     try {
         fd = fs.openSync(absolute, "r");
@@ -2026,8 +2624,8 @@ function restoreCompleteReadTerminator(content, readPath, metadata, resultMetada
  * that, keeping the signal out of the file content itself so it still cannot be
  * echoed into a write.
  */
-function readTruncationSummary(output) {
-    const meta = parseOpenCodeReadMetadata(output);
+function readTruncationSummary(output, resultMetadata) {
+    const meta = parseOpenCodeReadMetadata(output, resultMetadata);
     if (meta.startLine === undefined || meta.endLine === undefined)
         return undefined;
     // A complete read reports "(End of file …)" and never reaches this shape.
@@ -2036,7 +2634,7 @@ function readTruncationSummary(output) {
     return {
         startLine: meta.startLine,
         endLine: meta.endLine,
-        nextOffset: meta.endLine + 1,
+        nextOffset: meta.nextOffset ?? meta.endLine + 1,
         capped: meta.outputCapped === true,
         ...(meta.totalLines !== undefined ? { totalLines: meta.totalLines } : {}),
     };
@@ -2049,7 +2647,7 @@ function readTruncationSummary(output) {
  * would cry wolf on every deliberate paged read.
  */
 function readTruncationNotice(output, resultMetadata) {
-    const summary = readTruncationSummary(output);
+    const summary = readTruncationSummary(output, resultMetadata);
     if (!summary)
         return undefined;
     const rangeRequested = num(resultMetadata?.offset) !== undefined || num(resultMetadata?.limit) !== undefined;
@@ -2064,18 +2662,35 @@ function readTruncationNotice(output, resultMetadata) {
         `acting on the whole file; writing the content above back would delete everything ` +
         `after line ${summary.endLine}.]`);
 }
+function readLongLineTruncationNotice(output) {
+    const lines = parseOpenCodeReadMetadata(output).truncatedLines;
+    if (!lines || lines.length === 0)
+        return undefined;
+    const displayed = lines.slice(0, 8).join(", ");
+    const remainder = lines.length > 8 ? ` and ${lines.length - 8} more` : "";
+    return (`[Partial read: OpenCode shortened ${lines.length === 1 ? "line" : "lines"} ` +
+        `${displayed}${remainder} to ${OPENCODE2_READ_MAX_LINE_CHARS} characters. ` +
+        "It is NOT the complete file. Use a byte-preserving read method to inspect the full " +
+        "line content before acting on the whole file; writing the content above back would lose data.]");
+}
 /** agent.v1.PiTruncation for a capped OpenCode read. */
-function readTruncationMessage(output, content) {
-    const summary = readTruncationSummary(output);
-    if (!summary)
+function readTruncationMessage(output, content, resultMetadata) {
+    const summary = readTruncationSummary(output, resultMetadata);
+    const longLines = parseOpenCodeReadMetadata(output, resultMetadata).truncatedLines;
+    if (!summary && (!longLines || longLines.length === 0))
+        return undefined;
+    const rangeRequested = num(resultMetadata?.offset) !== undefined || num(resultMetadata?.limit) !== undefined;
+    if (summary && rangeRequested && !summary.capped && (!longLines || longLines.length === 0))
         return undefined;
     return {
         truncated: true,
-        truncated_by: summary.capped ? "bytes" : "lines",
-        ...(summary.totalLines !== undefined ? { total_lines: summary.totalLines } : {}),
-        output_lines: Math.max(0, summary.endLine - summary.startLine + 1),
+        truncated_by: summary?.capped ? "bytes" : longLines?.length ? "characters" : "lines",
+        ...(summary?.totalLines !== undefined ? { total_lines: summary.totalLines } : {}),
+        output_lines: summary
+            ? Math.max(0, summary.endLine - summary.startLine + 1)
+            : countLines(content),
         output_bytes: Buffer.byteLength(content, "utf8"),
-        ...(summary.capped ? { max_bytes: OPENCODE_READ_MAX_BYTES } : {}),
+        ...(summary?.capped ? { max_bytes: OPENCODE_READ_MAX_BYTES } : {}),
     };
 }
 /** `tool/read.ts` MAX_BYTES — mirrored only to report the cap, never to apply it. */
@@ -2091,8 +2706,15 @@ function readRangeApplied(resultMetadata, totalLines) {
     return startLine < 0 || startLine <= totalLines;
 }
 function readOutputTruncated(resultMetadata, outputMetadata, totalLines) {
+    if (outputMetadata.truncatedLines && outputMetadata.truncatedLines.length > 0)
+        return true;
     if (outputMetadata.outputCapped)
         return true;
+    if (outputMetadata.hostTruncated) {
+        const rangeRequested = num(resultMetadata?.offset) !== undefined || num(resultMetadata?.limit) !== undefined;
+        if (!rangeRequested)
+            return true;
+    }
     const returnedEnd = outputMetadata.endLine;
     if (returnedEnd === undefined || totalLines === 0)
         return false;
@@ -2106,6 +2728,14 @@ function readOutputTruncated(resultMetadata, outputMetadata, totalLines) {
         : Math.min(totalLines, Math.max(1, startLine) + limit - 1);
     return returnedEnd < expectedEnd;
 }
+function listedEntryName(entry) {
+    const trimmed = stripTrailingPathSeparator(entry);
+    const slash = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+    return slash >= 0 ? trimmed.slice(slash + 1) : trimmed;
+}
+function stripTrailingPathSeparator(entry) {
+    return entry.endsWith("/") || entry.endsWith("\\") ? entry.slice(0, -1) : entry;
+}
 function readFileSize(filePath) {
     if (!filePath)
         return 0;