@rama_nigg/open-cursor 2.1.7 → 2.2.0

package/dist/index.js

@@ -1,5 +1,20 @@
 import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -12833,6 +12848,9 @@ ${result.output || "(no output)"}`
 }
 
 // src/utils/logger.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
 function getConfiguredLevel() {
   const env = process.env.CURSOR_ACP_LOG_LEVEL?.toLowerCase();
   if (env && env in LEVEL_PRIORITY) {
@@ -12863,32 +12881,90 @@ function formatMessage(level, component, message, data) {
   }
   return formatted;
 }
+function isConsoleEnabled() {
+  const consoleEnv = process.env.CURSOR_ACP_LOG_CONSOLE;
+  return consoleEnv === "1" || consoleEnv === "true";
+}
+function ensureLogDir() {
+  if (logDirEnsured)
+    return;
+  try {
+    if (!fs.existsSync(LOG_DIR)) {
+      fs.mkdirSync(LOG_DIR, { recursive: true });
+    }
+    logDirEnsured = true;
+  } catch {
+    logFileError = true;
+  }
+}
+function rotateIfNeeded() {
+  try {
+    const stats = fs.statSync(LOG_FILE);
+    if (stats.size >= MAX_LOG_SIZE) {
+      const backupFile = LOG_FILE + ".1";
+      fs.renameSync(LOG_FILE, backupFile);
+    }
+  } catch {}
+}
+function writeToFile(message) {
+  if (logFileError)
+    return;
+  ensureLogDir();
+  if (logFileError)
+    return;
+  try {
+    rotateIfNeeded();
+    const timestamp = new Date().toISOString();
+    fs.appendFileSync(LOG_FILE, `${timestamp} ${message}
+`);
+  } catch {
+    if (!logFileError) {
+      logFileError = true;
+      console.error(`[cursor-acp] Failed to write logs. Using: ${LOG_FILE}`);
+    }
+  }
+}
 function createLogger(component) {
   return {
     debug: (message, data) => {
-      if (shouldLog("debug")) {
-        console.error(formatMessage("debug", component, message, data));
-      }
+      if (!shouldLog("debug"))
+        return;
+      const formatted = formatMessage("debug", component, message, data);
+      writeToFile(formatted);
+      if (isConsoleEnabled())
+        console.error(formatted);
     },
     info: (message, data) => {
-      if (shouldLog("info")) {
-        console.error(formatMessage("info", component, message, data));
-      }
+      if (!shouldLog("info"))
+        return;
+      const formatted = formatMessage("info", component, message, data);
+      writeToFile(formatted);
+      if (isConsoleEnabled())
+        console.error(formatted);
     },
     warn: (message, data) => {
-      if (shouldLog("warn")) {
-        console.error(formatMessage("warn", component, message, data));
-      }
+      if (!shouldLog("warn"))
+        return;
+      const formatted = formatMessage("warn", component, message, data);
+      writeToFile(formatted);
+      if (isConsoleEnabled())
+        console.error(formatted);
     },
     error: (message, data) => {
-      if (shouldLog("error")) {
-        console.error(formatMessage("error", component, message, data));
-      }
+      if (!shouldLog("error"))
+        return;
+      const formatted = formatMessage("error", component, message, data);
+      writeToFile(formatted);
+      if (isConsoleEnabled())
+        console.error(formatted);
     }
   };
 }
-var LEVEL_PRIORITY;
+var LOG_DIR, LOG_FILE, MAX_LOG_SIZE, LEVEL_PRIORITY, logDirEnsured = false, logFileError = false;
 var init_logger = __esm(() => {
+  LOG_DIR = path.join(os.homedir(), ".opencode-cursor");
+  LOG_FILE = path.join(LOG_DIR, "plugin.log");
+  MAX_LOG_SIZE = 5 * 1024 * 1024;
   LEVEL_PRIORITY = {
     debug: 0,
     info: 1,
@@ -12989,15 +13065,15 @@ function formatErrorForUser(error45) {
 
 // src/auth.ts
 import { spawn } from "child_process";
-import { existsSync } from "fs";
-import { homedir, platform } from "os";
-import { join } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir2, platform } from "os";
+import { join as join2 } from "path";
 function getHomeDir() {
   const override = process.env.CURSOR_ACP_HOME_DIR;
   if (override && override.length > 0) {
     return override;
   }
-  return homedir();
+  return homedir2();
 }
 async function pollForAuthFile(timeoutMs = AUTH_POLL_TIMEOUT, intervalMs = AUTH_POLL_INTERVAL) {
   const startTime = Date.now();
@@ -13006,7 +13082,7 @@ async function pollForAuthFile(timeoutMs = AUTH_POLL_TIMEOUT, intervalMs = AUTH_
     const check2 = () => {
       const elapsed = Date.now() - startTime;
       for (const authPath of possiblePaths) {
-        if (existsSync(authPath)) {
+        if (existsSync2(authPath)) {
           log.debug("Auth file detected", { path: authPath });
           resolve(true);
           return;
@@ -13133,7 +13209,7 @@ async function startCursorOAuth() {
 function verifyCursorAuth() {
   const possiblePaths = getPossibleAuthPaths();
   for (const authPath of possiblePaths) {
-    if (existsSync(authPath)) {
+    if (existsSync2(authPath)) {
       log.debug("Auth file found", { path: authPath });
       return true;
     }
@@ -13148,23 +13224,23 @@ function getPossibleAuthPaths() {
   const authFiles = ["cli-config.json", "auth.json"];
   if (isDarwin) {
     for (const file2 of authFiles) {
-      paths.push(join(home, ".cursor", file2));
+      paths.push(join2(home, ".cursor", file2));
     }
     for (const file2 of authFiles) {
-      paths.push(join(home, ".config", "cursor", file2));
+      paths.push(join2(home, ".config", "cursor", file2));
     }
   } else {
     for (const file2 of authFiles) {
-      paths.push(join(home, ".config", "cursor", file2));
+      paths.push(join2(home, ".config", "cursor", file2));
     }
     const xdgConfig = process.env.XDG_CONFIG_HOME;
-    if (xdgConfig && xdgConfig !== join(home, ".config")) {
+    if (xdgConfig && xdgConfig !== join2(home, ".config")) {
       for (const file2 of authFiles) {
-        paths.push(join(xdgConfig, "cursor", file2));
+        paths.push(join2(xdgConfig, "cursor", file2));
       }
     }
     for (const file2 of authFiles) {
-      paths.push(join(home, ".cursor", file2));
+      paths.push(join2(home, ".cursor", file2));
     }
   }
   return paths;
@@ -13172,7 +13248,7 @@ function getPossibleAuthPaths() {
 function getAuthFilePath() {
   const possiblePaths = getPossibleAuthPaths();
   for (const authPath of possiblePaths) {
-    if (existsSync(authPath)) {
+    if (existsSync2(authPath)) {
       return authPath;
     }
   }
@@ -13400,7 +13476,68 @@ var init_perf = __esm(() => {
 });
 
 // src/proxy/prompt-builder.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+function ensureLogDir2() {
+  try {
+    if (!existsSync3(DEBUG_LOG_DIR)) {
+      mkdirSync2(DEBUG_LOG_DIR, { recursive: true });
+    }
+  } catch {}
+}
+function debugLogToFile(message, data) {
+  try {
+    ensureLogDir2();
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}
+`;
+    appendFileSync2(DEBUG_LOG_FILE, logLine);
+  } catch (err) {
+    log4.debug(message, data);
+  }
+}
 function buildPromptFromMessages(messages, tools) {
+  const messageSummary = messages.map((m, i) => {
+    const role = m?.role ?? "?";
+    const hasToolCalls = Array.isArray(m?.tool_calls) ? m.tool_calls.length : 0;
+    const tcNames = hasToolCalls > 0 ? m.tool_calls.map((tc) => tc?.function?.name).join(",") : "";
+    const contentType = typeof m?.content;
+    const contentLen = typeof m?.content === "string" ? m.content.length : Array.isArray(m?.content) ? `arr:${m.content.length}` : "null";
+    const toolCallId = m?.tool_call_id ?? null;
+    return { i, role, hasToolCalls, tcNames, contentType, contentLen, toolCallId };
+  });
+  const assistantWithToolCalls = messages.filter((m) => m?.role === "assistant" && Array.isArray(m?.tool_calls) && m.tool_calls.length > 0);
+  const assistantEmpty = messages.filter((m) => m?.role === "assistant" && (!m?.tool_calls || m.tool_calls.length === 0) && (!m?.content || m.content === "" || m.content === null));
+  const toolResults = messages.filter((m) => m?.role === "tool");
+  debugLogToFile("buildPromptFromMessages", {
+    totalMessages: messages.length,
+    totalTools: tools.length,
+    messageSummary,
+    stats: {
+      assistantWithToolCalls: assistantWithToolCalls.length,
+      assistantEmpty: assistantEmpty.length,
+      toolResults: toolResults.length
+    },
+    assistantDetails: assistantWithToolCalls.length > 0 ? assistantWithToolCalls.map((m, i) => ({
+      index: i,
+      toolCallCount: Array.isArray(m?.tool_calls) ? m.tool_calls.length : 0,
+      toolCallIds: Array.isArray(m?.tool_calls) ? m.tool_calls.map((tc) => tc?.id).join(",") : "",
+      toolCallNames: Array.isArray(m?.tool_calls) ? m.tool_calls.map((tc) => tc?.function?.name).join(",") : "",
+      contentType: typeof m?.content,
+      contentPreview: typeof m?.content === "string" ? m.content.slice(0, 50) : typeof m?.content
+    })) : [],
+    emptyAssistantDetails: assistantEmpty.length > 0 ? assistantEmpty.map((m, i) => ({
+      index: i,
+      contentType: typeof m?.content,
+      contentPreview: typeof m?.content === "string" ? m.content.slice(0, 50) : typeof m?.content
+    })) : [],
+    toolResultDetails: toolResults.length > 0 ? toolResults.map((m, i) => ({
+      index: i,
+      toolCallId: m?.tool_call_id,
+      contentPreview: typeof m?.content === "string" ? m.content.slice(0, 100) : typeof m?.content
+    })) : []
+  });
   const lines = [];
   if (tools.length > 0) {
     const toolDescs = tools.map((t) => {
@@ -13414,6 +13551,7 @@ function buildPromptFromMessages(messages, tools) {
     }).join(`
 `);
     lines.push(`SYSTEM: You have access to the following tools. When you need to use one, respond with a tool_call in the standard OpenAI format.
+` + `Tool guidance: prefer write/edit for file changes; use bash mainly to run commands/tests.
 
 Available tools:
 ${toolDescs}`);
@@ -13453,10 +13591,30 @@ ${toolDescs}`);
       }
     }
   }
-  return lines.join(`
+  const hasToolResults = messages.some((m) => m?.role === "tool");
+  if (hasToolResults) {
+    lines.push("The above tool calls have been executed. Continue your response based on these results.");
+  }
+  const finalPrompt = lines.join(`
 
 `);
-}
+  debugLogToFile("buildPromptFromMessages: final prompt", {
+    lineCount: lines.length,
+    promptLength: finalPrompt.length,
+    promptPreview: finalPrompt.slice(0, 500),
+    hasToolResultFormat: finalPrompt.includes("TOOL_RESULT"),
+    hasAssistantToolCallFormat: finalPrompt.includes("tool_call(id:"),
+    hasCompletionSignal: finalPrompt.includes("Based on the tool results")
+  });
+  return finalPrompt;
+}
+var log4, DEBUG_LOG_DIR, DEBUG_LOG_FILE;
+var init_prompt_builder = __esm(() => {
+  init_logger();
+  log4 = createLogger("proxy:prompt-builder");
+  DEBUG_LOG_DIR = join3(homedir3(), ".config", "opencode", "logs");
+  DEBUG_LOG_FILE = join3(DEBUG_LOG_DIR, "tool-loop-debug.log");
+});
 
 // src/proxy/tool-loop.ts
 function extractAllowedToolNames(tools) {
@@ -13482,7 +13640,7 @@ function extractOpenAiToolCall(event, allowedToolNames) {
   }
   const resolvedName = resolveAllowedToolName(name, allowedToolNames);
   if (!resolvedName) {
-    log4.debug("Tool call name not allowed; skipping interception", {
+    log5.debug("Tool call name not allowed; skipping interception", {
       name,
       normalized: normalizeAliasKey(name),
       allowedToolCount: allowedToolNames.size,
@@ -13491,7 +13649,7 @@ function extractOpenAiToolCall(event, allowedToolNames) {
     return null;
   }
   if (args === undefined && event.subtype === "started") {
-    log4.debug("Tool call args extraction returned undefined", {
+    log5.debug("Tool call args extraction returned undefined", {
       toolName: name,
       subtype: event.subtype ?? "none",
       payloadKeys: Object.entries(event.tool_call || {}).map(([k, v]) => `${k}:[${isRecord(v) ? Object.keys(v).join(",") : typeof v}]`),
@@ -13647,10 +13805,10 @@ function toOpenAiArguments(args) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var log4, TOOL_NAME_ALIASES;
+var log5, TOOL_NAME_ALIASES;
 var init_tool_loop = __esm(() => {
   init_logger();
-  log4 = createLogger("proxy:tool-loop");
+  log5 = createLogger("proxy:tool-loop");
   TOOL_NAME_ALIASES = new Map([
     ["runcommand", "bash"],
     ["executecommand", "bash"],
@@ -13764,7 +13922,7 @@ class OpenCodeToolDiscovery {
         const mcpTools = await this.tryListMcpTools();
         tools = tools.concat(mcpTools);
       } catch (err) {
-        log5.debug("SDK tool.list failed, will try CLI", { error: String(err) });
+        log6.debug("SDK tool.list failed, will try CLI", { error: String(err) });
       }
     }
     if (tools.length === 0 && this.executorPref !== "sdk") {
@@ -13776,10 +13934,10 @@ class OpenCodeToolDiscovery {
         if (parsed?.data?.tools?.length) {
           tools = parsed.data.tools.map((t) => this.normalize(t, "cli"));
         } else {
-          log5.debug("CLI tool list failed", { status: res.status, stderr: res.stderr });
+          log6.debug("CLI tool list failed", { status: res.status, stderr: res.stderr });
         }
       } catch (err) {
-        log5.debug("CLI tool list error", { error: String(err) });
+        log6.debug("CLI tool list error", { error: String(err) });
       }
     }
     const map2 = new Map;
@@ -13815,7 +13973,7 @@ class OpenCodeToolDiscovery {
         return [];
       return mcpList.data.tools.map((t) => this.normalize(t, "mcp"));
     } catch (err) {
-      log5.debug("MCP tool discovery skipped", { error: String(err) });
+      log6.debug("MCP tool discovery skipped", { error: String(err) });
       return [];
     }
   }
@@ -13836,11 +13994,11 @@ class OpenCodeToolDiscovery {
     return null;
   }
 }
-var log5;
+var log6;
 var init_discovery = __esm(() => {
   init_logger();
   init_strip_ansi();
-  log5 = createLogger("tools:discovery");
+  log6 = createLogger("tools:discovery");
 });
 
 // src/tools/schema.ts
@@ -13897,10 +14055,10 @@ function describeTool(t) {
   const base = t.description || "OpenCode tool";
   return base.length > 400 ? base.slice(0, 400) : base;
 }
-var log6;
+var log7;
 var init_schema = __esm(() => {
   init_logger();
-  log6 = createLogger("tools:schema");
+  log7 = createLogger("tools:schema");
 });
 
 // src/tools/router.ts
@@ -13925,18 +14083,18 @@ class ToolRouter {
     }
     const tool3 = this.ctx.toolsByName.get(name);
     if (!tool3) {
-      log7.warn("Unknown tool call", { name });
+      log8.warn("Unknown tool call", { name });
       return this.buildResult(meta, callId, name, { status: "error", error: `Unknown tool ${name}` });
     }
     const args = this.extractArgs(event);
-    log7.debug("Executing tool", { name, toolId: tool3.id });
+    log8.debug("Executing tool", { name, toolId: tool3.id });
     const t0 = Date.now();
     const result = await this.ctx.execute(tool3.id, args);
     const elapsed = Date.now() - t0;
     if (result.status === "error") {
-      log7.warn("Tool execution returned error", { name, error: result.error, elapsed });
+      log8.warn("Tool execution returned error", { name, error: result.error, elapsed });
     } else {
-      log7.debug("Tool execution completed", { name, toolId: tool3.id, elapsed });
+      log8.debug("Tool execution completed", { name, toolId: tool3.id, elapsed });
     }
     return this.buildResult(meta, callId, name, result);
   }
@@ -13985,10 +14143,10 @@ class ToolRouter {
     };
   }
 }
-var log7;
+var log8;
 var init_router = __esm(() => {
   init_logger();
-  log7 = createLogger("tools:router");
+  log8 = createLogger("tools:router");
 });
 
 // src/tools/skills/loader.ts
@@ -14300,7 +14458,7 @@ var separatorArrayExplode = (style) => {
 };
 
 // node_modules/@opencode-ai/sdk/dist/gen/core/utils.gen.js
-var PATH_PARAM_RE, defaultPathSerializer = ({ path, url: _url2 }) => {
+var PATH_PARAM_RE, defaultPathSerializer = ({ path: path2, url: _url2 }) => {
   let url2 = _url2;
   const matches = _url2.match(PATH_PARAM_RE);
   if (matches) {
@@ -14319,7 +14477,7 @@ var PATH_PARAM_RE, defaultPathSerializer = ({ path, url: _url2 }) => {
         name = name.substring(1);
         style = "matrix";
       }
-      const value = path[name];
+      const value = path2[name];
       if (value === undefined || value === null) {
         continue;
       }
@@ -14349,11 +14507,11 @@ var PATH_PARAM_RE, defaultPathSerializer = ({ path, url: _url2 }) => {
     }
   }
   return url2;
-}, getUrl = ({ baseUrl, path, query, querySerializer, url: _url2 }) => {
+}, getUrl = ({ baseUrl, path: path2, query, querySerializer, url: _url2 }) => {
   const pathUrl = _url2.startsWith("/") ? _url2 : `/${_url2}`;
   let url2 = (baseUrl ?? "") + pathUrl;
-  if (path) {
-    url2 = defaultPathSerializer({ path, url: url2 });
+  if (path2) {
+    url2 = defaultPathSerializer({ path: path2, url: url2 });
   }
   let search = query ? querySerializer(query) : "";
   if (search.startsWith("?")) {
@@ -15474,15 +15632,15 @@ class LocalExecutor {
       const out = await handler(args);
       return { status: "success", output: out };
     } catch (err) {
-      log8.warn("Local tool execution failed", { toolId, error: String(err?.message || err) });
+      log9.warn("Local tool execution failed", { toolId, error: String(err?.message || err) });
       return { status: "error", error: String(err?.message || err) };
     }
   }
 }
-var log8;
+var log9;
 var init_local = __esm(() => {
   init_logger();
-  log8 = createLogger("tools:executor:local");
+  log9 = createLogger("tools:executor:local");
 });
 
 // src/tools/executors/sdk.ts
@@ -15509,7 +15667,7 @@ class SdkExecutor {
       const out = typeof res === "string" ? res : JSON.stringify(res);
       return { status: "success", output: out };
     } catch (err) {
-      log9.warn("SDK tool execution failed", { toolId, error: String(err?.message || err) });
+      log10.warn("SDK tool execution failed", { toolId, error: String(err?.message || err) });
       return { status: "error", error: String(err?.message || err) };
     }
   }
@@ -15522,10 +15680,10 @@ class SdkExecutor {
     ]);
   }
 }
-var log9;
+var log10;
 var init_sdk = __esm(() => {
   init_logger();
-  log9 = createLogger("tools:executor:sdk");
+  log10 = createLogger("tools:executor:sdk");
 });
 
 // src/tools/executors/mcp.ts
@@ -15552,7 +15710,7 @@ class McpExecutor {
       const out = typeof res === "string" ? res : JSON.stringify(res);
       return { status: "success", output: out };
     } catch (err) {
-      log10.warn("MCP tool execution failed", { toolId, error: String(err?.message || err) });
+      log11.warn("MCP tool execution failed", { toolId, error: String(err?.message || err) });
       return { status: "error", error: String(err?.message || err) };
     }
   }
@@ -15565,10 +15723,10 @@ class McpExecutor {
     ]);
   }
 }
-var log10;
+var log11;
 var init_mcp = __esm(() => {
   init_logger();
-  log10 = createLogger("tools:executor:mcp");
+  log11 = createLogger("tools:executor:mcp");
 });
 
 // src/tools/core/executor.ts
@@ -15578,17 +15736,17 @@ async function executeWithChain(executors, toolId, args) {
       try {
         return await ex.execute(toolId, args);
       } catch (err) {
-        log11.warn("Executor threw unexpected error", { toolId, error: String(err?.message || err) });
+        log12.warn("Executor threw unexpected error", { toolId, error: String(err?.message || err) });
         return { status: "error", error: String(err?.message || err) };
       }
     }
   }
   return { status: "error", error: `No executor available for ${toolId}` };
 }
-var log11;
+var log12;
 var init_executor = __esm(() => {
   init_logger();
-  log11 = createLogger("tools:executor:chain");
+  log12 = createLogger("tools:executor:chain");
 });
 
 // src/tools/defaults.ts
@@ -15596,7 +15754,7 @@ function registerDefaultTools(registry2) {
   registry2.register({
     id: "bash",
     name: "bash",
-    description: "Execute a shell command in a safe environment",
+    description: "Execute a shell command. Use this to run programs/tests; prefer write/edit for creating or modifying files.",
     parameters: {
       type: "object",
       properties: {
@@ -15660,12 +15818,12 @@ function registerDefaultTools(registry2) {
     },
     source: "local"
   }, async (args) => {
-    const fs = await import("fs");
+    const fs2 = await import("fs");
     try {
-      const path = args.path;
+      const path2 = args.path;
       const offset = args.offset;
       const limit = args.limit;
-      let content = fs.readFileSync(path, "utf-8");
+      let content = fs2.readFileSync(path2, "utf-8");
       if (offset !== undefined || limit !== undefined) {
         const lines = content.split(`
 `);
@@ -15682,7 +15840,7 @@ function registerDefaultTools(registry2) {
   registry2.register({
     id: "write",
     name: "write",
-    description: "Write content to a file (creates or overwrites)",
+    description: "Write content to a file (creates or overwrites). Prefer this over using bash redirection/heredocs for file creation.",
     parameters: {
       type: "object",
       properties: {
@@ -15699,16 +15857,16 @@ function registerDefaultTools(registry2) {
     },
     source: "local"
   }, async (args) => {
-    const fs = await import("fs");
-    const path = await import("path");
+    const fs2 = await import("fs");
+    const path2 = await import("path");
     try {
       const filePath = args.path;
       const content = args.content;
-      const dir = path.dirname(filePath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
+      const dir = path2.dirname(filePath);
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
       }
-      fs.writeFileSync(filePath, content, "utf-8");
+      fs2.writeFileSync(filePath, content, "utf-8");
       return `File written successfully: ${filePath}`;
     } catch (error45) {
       throw error45;
@@ -15717,7 +15875,7 @@ function registerDefaultTools(registry2) {
   registry2.register({
     id: "edit",
     name: "edit",
-    description: "Edit a file by replacing old text with new text",
+    description: "Edit a file by replacing old text with new text. Use for targeted replacements; use write to overwrite an entire file.",
     parameters: {
       type: "object",
       properties: {
@@ -15738,8 +15896,8 @@ function registerDefaultTools(registry2) {
     },
     source: "local"
   }, async (args) => {
-    const fs = await import("fs");
-    const path = await import("path");
+    const fs2 = await import("fs");
+    const path2 = await import("path");
     try {
       const resolvedArgs = resolveEditArguments(args);
       const filePath = resolvedArgs.path;
@@ -15756,27 +15914,27 @@ function registerDefaultTools(registry2) {
       }
       let content = "";
       try {
-        content = fs.readFileSync(filePath, "utf-8");
+        content = fs2.readFileSync(filePath, "utf-8");
       } catch (error45) {
         if (error45?.code === "ENOENT") {
-          const dir = path.dirname(filePath);
-          if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
+          const dir = path2.dirname(filePath);
+          if (!fs2.existsSync(dir)) {
+            fs2.mkdirSync(dir, { recursive: true });
           }
-          fs.writeFileSync(filePath, newString, "utf-8");
+          fs2.writeFileSync(filePath, newString, "utf-8");
           return `File did not exist. Created and wrote content: ${filePath}`;
         }
         throw error45;
       }
       if (!oldString) {
-        fs.writeFileSync(filePath, newString, "utf-8");
+        fs2.writeFileSync(filePath, newString, "utf-8");
         return `File edited successfully: ${filePath}`;
       }
       if (!content.includes(oldString)) {
         return `Error: Could not find the text to replace in ${filePath}`;
       }
       content = content.replaceAll(oldString, newString);
-      fs.writeFileSync(filePath, content, "utf-8");
+      fs2.writeFileSync(filePath, content, "utf-8");
       return `File edited successfully: ${filePath}`;
     } catch (error45) {
       throw error45;
@@ -15810,13 +15968,13 @@ function registerDefaultTools(registry2) {
     const { promisify } = await import("util");
     const execFileAsync = promisify(execFile);
     const pattern = args.pattern;
-    const path = args.path;
+    const path2 = args.path;
     const include = args.include;
     const grepArgs = ["-r", "-n"];
     if (include) {
       grepArgs.push(`--include=${include}`);
     }
-    grepArgs.push(pattern, path);
+    grepArgs.push(pattern, path2);
     const runGrep = async (extraArgs = []) => {
       return execFileAsync("grep", [...extraArgs, ...grepArgs], { timeout: 30000 });
     };
@@ -15859,11 +16017,11 @@ function registerDefaultTools(registry2) {
     },
     source: "local"
   }, async (args) => {
-    const fs = await import("fs");
-    const path = await import("path");
+    const fs2 = await import("fs");
+    const path2 = await import("path");
     try {
       const dirPath = args.path;
-      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      const entries = fs2.readdirSync(dirPath, { withFileTypes: true });
       const result = entries.map((entry) => {
         const type = entry.isDirectory() ? "d" : entry.isSymbolicLink() ? "l" : entry.isFile() ? "f" : "?";
         return `[${type}] ${entry.name}`;
@@ -15901,8 +16059,8 @@ function registerDefaultTools(registry2) {
     if (!pattern) {
       throw new Error("glob: missing required argument 'pattern'");
     }
-    const path = resolvePathArg(args, "glob");
-    const cwd = path || ".";
+    const path2 = resolvePathArg(args, "glob");
+    const cwd = path2 || ".";
     const normalizedPattern = pattern.replace(/\\/g, "/");
     const isPathPattern = normalizedPattern.includes("/");
     const findArgs = [cwd, "-type", "f"];
@@ -16030,7 +16188,7 @@ function registerDefaultTools(registry2) {
   });
 }
 function resolveEditArguments(args) {
-  const path = typeof args.path === "string" ? args.path : "";
+  const path2 = typeof args.path === "string" ? args.path : "";
   let oldString = typeof args.old_string === "string" ? args.old_string : undefined;
   let newString = typeof args.new_string === "string" ? args.new_string : undefined;
   if (newString === undefined) {
@@ -16043,7 +16201,7 @@ function resolveEditArguments(args) {
     oldString = "";
   }
   return {
-    path,
+    path: path2,
     old_string: oldString,
     new_string: newString
   };
@@ -16386,6 +16544,23 @@ function normalizeToolSpecificArgs(toolName, args) {
       todos
     };
   }
+  if (normalizedToolName === "write") {
+    const normalized = { ...args };
+    if (normalized.content === undefined && normalized.new_string !== undefined) {
+      const coerced = coerceToString2(normalized.new_string);
+      if (coerced !== null) {
+        normalized.content = coerced;
+      }
+      delete normalized.new_string;
+    }
+    if (normalized.content !== undefined && typeof normalized.content !== "string") {
+      const coerced = coerceToString2(normalized.content);
+      if (coerced !== null) {
+        normalized.content = coerced;
+      }
+    }
+    return normalized;
+  }
   if (normalizedToolName !== "edit" || !EDIT_COMPAT_REPAIR_ENABLED) {
     return args;
   }
@@ -16628,6 +16803,9 @@ var init_tool_schema_compat = __esm(() => {
     ["terminalcommand", "command"],
     ["contents", "content"],
     ["text", "content"],
+    ["body", "content"],
+    ["data", "content"],
+    ["payload", "content"],
     ["streamcontent", "content"],
     ["recursive", "force"],
     ["oldstring", "old_string"],
@@ -16641,7 +16819,7 @@ async function handleToolLoopEventLegacy(options) {
     event,
     toolLoopMode,
     allowedToolNames,
-    toolSchemaMap: _toolSchemaMap,
+    toolSchemaMap,
     toolLoopGuard,
     toolMapper,
     toolSessionId,
@@ -16656,11 +16834,44 @@ async function handleToolLoopEventLegacy(options) {
   } = options;
   const interceptedToolCall = toolLoopMode === "opencode" ? extractOpenAiToolCall(event, allowedToolNames) : null;
   if (interceptedToolCall) {
-    const termination = evaluateToolLoopGuard(toolLoopGuard, interceptedToolCall);
+    const compat2 = applyToolSchemaCompat(interceptedToolCall, toolSchemaMap);
+    let normalizedToolCall = compat2.toolCall;
+    log13.debug("Applied tool schema compatibility (legacy)", {
+      tool: normalizedToolCall.function.name,
+      originalArgKeys: compat2.originalArgKeys,
+      normalizedArgKeys: compat2.normalizedArgKeys,
+      collisionKeys: compat2.collisionKeys,
+      validationOk: compat2.validation.ok
+    });
+    if (compat2.validation.hasSchema && !compat2.validation.ok) {
+      const validationTermination = evaluateSchemaValidationLoopGuard(toolLoopGuard, normalizedToolCall, compat2.validation);
+      if (validationTermination) {
+        return { intercepted: false, skipConverter: true, terminate: validationTermination };
+      }
+      const reroutedWrite = tryRerouteEditToWrite(normalizedToolCall, compat2.normalizedArgs, allowedToolNames, toolSchemaMap);
+      if (reroutedWrite) {
+        log13.debug("Rerouting malformed edit call to write (legacy)", {
+          path: reroutedWrite.path,
+          missing: compat2.validation.missing,
+          typeErrors: compat2.validation.typeErrors
+        });
+        normalizedToolCall = reroutedWrite.toolCall;
+      } else if (shouldEmitNonFatalSchemaValidationHint(normalizedToolCall, compat2.validation)) {
+        const hintChunk = createNonFatalSchemaValidationHintChunk(responseMeta, normalizedToolCall, compat2.validation);
+        log13.debug("Emitting non-fatal schema validation hint in legacy and skipping malformed tool execution", {
+          tool: normalizedToolCall.function.name,
+          missing: compat2.validation.missing,
+          typeErrors: compat2.validation.typeErrors
+        });
+        await onToolResult(hintChunk);
+        return { intercepted: false, skipConverter: true };
+      }
+    }
+    const termination = evaluateToolLoopGuard(toolLoopGuard, normalizedToolCall);
     if (termination) {
       return { intercepted: false, skipConverter: true, terminate: termination };
     }
-    await onInterceptedToolCall(interceptedToolCall);
+    await onInterceptedToolCall(normalizedToolCall);
     return { intercepted: true, skipConverter: true };
   }
   const updates = await toolMapper.mapCursorEventToAcp(event, event.session_id ?? toolSessionId);
@@ -16713,7 +16924,7 @@ async function handleToolLoopEventV1(options) {
       rawArgs: safeArgTypeSummary(event),
       normalizedArgs: compat2.normalizedArgs
     } : undefined;
-    log12.debug("Applied tool schema compatibility", {
+    log13.debug("Applied tool schema compatibility", {
       tool: interceptedToolCall.function.name,
       originalArgKeys: compat2.originalArgKeys,
       normalizedArgKeys: compat2.normalizedArgKeys,
@@ -16722,7 +16933,7 @@ async function handleToolLoopEventV1(options) {
       ...editDiag ? { editDiag } : {}
     });
     if (compat2.validation.hasSchema && !compat2.validation.ok) {
-      log12.warn("Tool schema compatibility validation failed", {
+      log13.debug("Tool schema compatibility validation failed", {
         tool: interceptedToolCall.function.name,
         missing: compat2.validation.missing,
         unexpected: compat2.validation.unexpected,
@@ -16739,7 +16950,7 @@ async function handleToolLoopEventV1(options) {
       }
       const reroutedWrite = tryRerouteEditToWrite(interceptedToolCall, compat2.normalizedArgs, allowedToolNames, toolSchemaMap);
       if (reroutedWrite) {
-        log12.info("Rerouting malformed edit call to write", {
+        log13.debug("Rerouting malformed edit call to write", {
           path: reroutedWrite.path,
           missing: compat2.validation.missing,
           typeErrors: compat2.validation.typeErrors
@@ -16759,7 +16970,7 @@ async function handleToolLoopEventV1(options) {
       }
       if (schemaValidationFailureMode === "pass_through" && shouldEmitNonFatalSchemaValidationHint(interceptedToolCall, compat2.validation)) {
         const hintChunk = createNonFatalSchemaValidationHintChunk(responseMeta, interceptedToolCall, compat2.validation);
-        log12.debug("Emitting non-fatal schema validation hint and skipping malformed tool execution", {
+        log13.debug("Emitting non-fatal schema validation hint and skipping malformed tool execution", {
           tool: interceptedToolCall.function.name,
           missing: compat2.validation.missing,
           typeErrors: compat2.validation.typeErrors
@@ -16777,7 +16988,7 @@ async function handleToolLoopEventV1(options) {
           terminate: createSchemaValidationTermination(interceptedToolCall, compat2.validation)
         };
       }
-      log12.debug("Forwarding schema-invalid tool call to OpenCode loop", {
+      log13.debug("Forwarding schema-invalid tool call to OpenCode loop", {
         tool: interceptedToolCall.function.name,
         repairHint: compat2.validation.repairHint
       });
@@ -16856,16 +17067,28 @@ function evaluateToolLoopGuard(toolLoopGuard, toolCall) {
   if (!decision.triggered) {
     return null;
   }
-  log12.warn("Tool loop guard triggered", {
+  log13.debug("Tool loop guard triggered", {
     tool: toolCall.function.name,
     fingerprint: decision.fingerprint,
     repeatCount: decision.repeatCount,
     maxRepeat: decision.maxRepeat,
     errorClass: decision.errorClass
   });
+  if (decision.errorClass === "success") {
+    return {
+      reason: "loop_guard",
+      message: "",
+      tool: toolCall.function.name,
+      fingerprint: decision.fingerprint,
+      repeatCount: decision.repeatCount,
+      maxRepeat: decision.maxRepeat,
+      errorClass: decision.errorClass,
+      silent: true
+    };
+  }
   return {
     reason: "loop_guard",
-    message: decision.errorClass === "success" ? `Tool loop guard stopped repeated successful calls to "${toolCall.function.name}" ` + `after ${decision.repeatCount} attempts (limit ${decision.maxRepeat}). ` + "This likely indicates a model/tool-call loop; adjust prompt or tool strategy and retry." : `Tool loop guard stopped repeated failing calls to "${toolCall.function.name}" ` + `after ${decision.repeatCount} attempts (limit ${decision.maxRepeat}). ` + "Adjust tool arguments and retry.",
+    message: `Tool loop guard stopped repeated failing calls to "${toolCall.function.name}" ` + `after ${decision.repeatCount} attempts (limit ${decision.maxRepeat}). ` + "Adjust tool arguments and retry.",
     tool: toolCall.function.name,
     fingerprint: decision.fingerprint,
     repeatCount: decision.repeatCount,
@@ -16903,7 +17126,7 @@ function evaluateSchemaValidationLoopGuard(toolLoopGuard, toolCall, validation)
   if (!decision.tracked || !decision.triggered) {
     return null;
   }
-  log12.warn("Tool loop guard triggered on schema validation", {
+  log13.warn("Tool loop guard triggered on schema validation", {
     tool: toolCall.function.name,
     fingerprint: decision.fingerprint,
     repeatCount: decision.repeatCount,
@@ -17036,8 +17259,8 @@ function tryRerouteEditToWrite(toolCall, normalizedArgs, allowedToolNames, toolS
   if (!allowedToolNames.has("write") || !toolSchemaMap.has("write")) {
     return null;
   }
-  const path = typeof normalizedArgs.path === "string" && normalizedArgs.path.length > 0 ? normalizedArgs.path : null;
-  if (!path) {
+  const path2 = typeof normalizedArgs.path === "string" && normalizedArgs.path.length > 0 ? normalizedArgs.path : null;
+  if (!path2) {
     return null;
   }
   const content = typeof normalizedArgs.new_string === "string" ? normalizedArgs.new_string : typeof normalizedArgs.content === "string" ? normalizedArgs.content : null;
@@ -17049,12 +17272,12 @@ function tryRerouteEditToWrite(toolCall, normalizedArgs, allowedToolNames, toolS
     return null;
   }
   return {
-    path,
+    path: path2,
     toolCall: {
       ...toolCall,
       function: {
         name: "write",
-        arguments: JSON.stringify({ path, content })
+        arguments: JSON.stringify({ path: path2, content })
       }
     }
   };
@@ -17062,12 +17285,12 @@ function tryRerouteEditToWrite(toolCall, normalizedArgs, allowedToolNames, toolS
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var log12, ToolBoundaryExtractionError;
+var log13, ToolBoundaryExtractionError;
 var init_runtime_interception = __esm(() => {
   init_tool_loop();
   init_logger();
   init_tool_schema_compat();
-  log12 = createLogger("provider:runtime-interception");
+  log13 = createLogger("provider:runtime-interception");
   ToolBoundaryExtractionError = class ToolBoundaryExtractionError extends Error {
     cause;
     constructor(message, cause) {
@@ -17081,11 +17304,11 @@ var init_runtime_interception = __esm(() => {
 // src/provider/tool-loop-guard.ts
 function parseToolLoopMaxRepeat(value) {
   if (value === undefined) {
-    return { value: 3, valid: true };
+    return { value: 2, valid: true };
   }
   const parsed = Number(value);
   if (!Number.isFinite(parsed) || parsed < 1) {
-    return { value: 3, valid: false };
+    return { value: 2, valid: false };
   }
   return { value: Math.floor(parsed), valid: true };
 }
@@ -17314,8 +17537,8 @@ function deriveSuccessCoarseFingerprint(toolName, rawArguments) {
     if (!isRecord4(parsed)) {
       return null;
     }
-    const path = typeof parsed.path === "string" ? parsed.path : "";
-    if (!path) {
+    const path2 = typeof parsed.path === "string" ? parsed.path : "";
+    if (!path2) {
       return null;
     }
     if (lowered === "edit") {
@@ -17324,7 +17547,7 @@ function deriveSuccessCoarseFingerprint(toolName, rawArguments) {
         return null;
       }
     }
-    return `${toolName}|path:${hashString(path)}|success`;
+    return `${toolName}|path:${hashString(path2)}|success`;
   } catch {
     return null;
   }
@@ -17512,6 +17735,7 @@ var UNKNOWN_AS_SUCCESS_TOOLS;
 var init_tool_loop_guard = __esm(() => {
   UNKNOWN_AS_SUCCESS_TOOLS = new Set([
     "bash",
+    "shell",
     "read",
     "write",
     "edit",
@@ -17519,38 +17743,62 @@ var init_tool_loop_guard = __esm(() => {
     "ls",
     "glob",
     "stat",
-    "webfetch"
+    "webfetch",
+    "mkdir",
+    "rm"
   ]);
 });
 
 // src/plugin.ts
 var exports_plugin = {};
 __export(exports_plugin, {
+  shouldProcessModel: () => shouldProcessModel,
   resolveChatParamTools: () => resolveChatParamTools,
   ensurePluginDirectory: () => ensurePluginDirectory,
   default: () => plugin_default,
   CursorPlugin: () => CursorPlugin
 });
-import { realpathSync } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync4, realpathSync } from "fs";
 import { mkdir } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { isAbsolute, join as join2, relative, resolve } from "path";
+import { homedir as homedir4 } from "os";
+import { isAbsolute, join as join4, relative, resolve } from "path";
+function ensureDebugLogDir() {
+  try {
+    if (!existsSync4(DEBUG_LOG_DIR2)) {
+      mkdir(DEBUG_LOG_DIR2, { recursive: true }).catch(() => {});
+    }
+  } catch {}
+}
+function debugLogToFile2(message, data) {
+  try {
+    ensureDebugLogDir();
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}
+`;
+    appendFileSync3(DEBUG_LOG_FILE2, logLine);
+  } catch {}
+}
 async function ensurePluginDirectory() {
-  const configHome = process.env.XDG_CONFIG_HOME ? resolve(process.env.XDG_CONFIG_HOME) : join2(homedir2(), ".config");
-  const pluginDir = join2(configHome, "opencode", "plugin");
+  const configHome = process.env.XDG_CONFIG_HOME ? resolve(process.env.XDG_CONFIG_HOME) : join4(homedir4(), ".config");
+  const pluginDir = join4(configHome, "opencode", "plugin");
   try {
     await mkdir(pluginDir, { recursive: true });
-    log13.debug("Plugin directory ensured", { path: pluginDir });
+    log14.debug("Plugin directory ensured", { path: pluginDir });
   } catch (error45) {
-    log13.warn("Failed to create plugin directory", { error: String(error45) });
+    log14.warn("Failed to create plugin directory", { error: String(error45) });
   }
 }
+function shouldProcessModel(model) {
+  if (!model)
+    return false;
+  return model.startsWith(CURSOR_PROVIDER_PREFIX);
+}
 function getGlobalKey() {
   return "__opencode_cursor_proxy_server__";
 }
 function getOpenCodeConfigPrefix() {
-  const configHome = process.env.XDG_CONFIG_HOME ? resolve(process.env.XDG_CONFIG_HOME) : join2(homedir2(), ".config");
-  return join2(configHome, "opencode");
+  const configHome = process.env.XDG_CONFIG_HOME ? resolve(process.env.XDG_CONFIG_HOME) : join4(homedir4(), ".config");
+  return join4(configHome, "opencode");
 }
 function canonicalizePathForCompare(pathValue) {
   const resolvedPath = resolve(pathValue);
@@ -17713,9 +17961,9 @@ function createBoundaryRuntimeContext(scope) {
       error: toErrorMessage(error45)
     };
     if (!fallbackActive) {
-      log13.warn("Provider boundary v1 failed; switching to legacy for this request", details);
+      log14.warn("Provider boundary v1 failed; switching to legacy for this request", details);
     } else {
-      log13.debug("Provider boundary fallback already active", details);
+      log14.debug("Provider boundary fallback already active", details);
     }
     fallbackActive = true;
     return true;
@@ -17792,7 +18040,7 @@ async function findFirstAllowedToolCallInOutput(output, options) {
     if (result.terminate) {
       return {
         toolCall: null,
-        terminationMessage: result.terminate.message
+        terminationMessage: result.terminate.silent ? null : result.terminate.message
       };
     }
     if (result.intercepted && interceptedToolCall) {
@@ -17849,7 +18097,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             headers: { "Content-Type": "application/json" }
           });
         } catch (err) {
-          log13.error("Failed to list models", { error: String(err) });
+          log14.error("Failed to list models", { error: String(err) });
           return new Response(JSON.stringify({ error: "Failed to fetch models from cursor-agent" }), {
             status: 500,
             headers: { "Content-Type": "application/json" }
@@ -17862,11 +18110,21 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           headers: { "Content-Type": "application/json" }
         });
       }
-      log13.debug("Proxy request (bun)", { method: req.method, path: url2.pathname });
+      log14.debug("Proxy request (bun)", { method: req.method, path: url2.pathname });
       const body = await req.json().catch(() => ({}));
       const messages = Array.isArray(body?.messages) ? body.messages : [];
       const stream = body?.stream === true;
       const tools = Array.isArray(body?.tools) ? body.tools : [];
+      debugLogToFile2("raw_request_body", {
+        model: body?.model,
+        stream,
+        toolCount: tools.length,
+        toolNames: tools.map((t) => t?.function?.name ?? t?.name ?? "unknown"),
+        messageCount: messages.length,
+        messageRoles: messages.map((m) => m?.role),
+        hasMessagesWithToolCalls: messages.some((m) => Array.isArray(m?.tool_calls) && m.tool_calls.length > 0),
+        hasToolResultMessages: messages.some((m) => m?.role === "tool")
+      });
       const allowedToolNames = extractAllowedToolNames(tools);
       const toolSchemaMap = buildToolSchemaMap(tools);
       const toolLoopGuard = createToolLoopGuard(messages, TOOL_LOOP_MAX_REPEAT);
@@ -17879,7 +18137,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         const clen = typeof m?.content === "string" ? m.content.length : Array.isArray(m?.content) ? `arr${m.content.length}` : typeof m?.content;
         return `${i}:${role}${hasTc ? `(tc:${hasTc})` : ""}(clen:${clen})`;
       });
-      log13.debug("Proxy chat request (bun)", {
+      log14.debug("Proxy chat request (bun)", {
         stream,
         model,
         messages: messages.length,
@@ -17925,7 +18183,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         const stdout = (stdoutText || "").trim();
         const stderr = (stderrText || "").trim();
         const exitCode = child.exitCode;
-        log13.debug("cursor-agent completed (bun non-stream)", {
+        log14.debug("cursor-agent completed (bun non-stream)", {
           exitCode,
           stdoutChars: stdout.length,
           stderrChars: stderr.length
@@ -17951,7 +18209,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           });
         }
         if (intercepted.toolCall) {
-          log13.debug("Intercepted OpenCode tool call (non-stream)", {
+          log14.debug("Intercepted OpenCode tool call (non-stream)", {
             name: intercepted.toolCall.function.name,
             callId: intercepted.toolCall.id
           });
@@ -17965,7 +18223,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           const errSource = stderr || stdout || `cursor-agent exited with code ${String(exitCode ?? "unknown")} and no output`;
           const parsed = parseAgentError(errSource);
           const userError = formatErrorForUser(parsed);
-          log13.error("cursor-cli failed", {
+          log14.error("cursor-cli failed", {
             type: parsed.type,
             message: parsed.message,
             code: exitCode
@@ -17999,7 +18257,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             const converter = new StreamToSseConverter(model, { id, created });
             const lineBuffer = new LineBuffer;
             const emitToolCallAndTerminate = (toolCall) => {
-              log13.debug("Intercepted OpenCode tool call (stream)", {
+              log14.debug("Intercepted OpenCode tool call (stream)", {
                 name: toolCall.function.name,
                 callId: toolCall.id
               });
@@ -18082,7 +18340,15 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                     }
                   });
                   if (result.terminate) {
-                    emitTerminalAssistantErrorAndTerminate(result.terminate.message);
+                    if (!result.terminate.silent) {
+                      emitTerminalAssistantErrorAndTerminate(result.terminate.message);
+                    } else {
+                      controller.enqueue(encoder.encode(formatSseDone()));
+                      streamTerminated = true;
+                      try {
+                        child.kill();
+                      } catch {}
+                    }
                     break;
                   }
                   if (result.intercepted) {
@@ -18140,7 +18406,15 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                   }
                 });
                 if (result.terminate) {
-                  emitTerminalAssistantErrorAndTerminate(result.terminate.message);
+                  if (!result.terminate.silent) {
+                    emitTerminalAssistantErrorAndTerminate(result.terminate.message);
+                  } else {
+                    controller.enqueue(encoder.encode(formatSseDone()));
+                    streamTerminated = true;
+                    try {
+                      child.kill();
+                    } catch {}
+                  }
                   break;
                 }
                 if (result.intercepted) {
@@ -18162,7 +18436,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
               const errSource = (stderrText || "").trim() || `cursor-agent exited with code ${String(child.exitCode ?? "unknown")} and no output`;
               const parsed = parseAgentError(errSource);
               const msg = formatErrorForUser(parsed);
-              log13.error("cursor-cli streaming failed", {
+              log14.error("cursor-cli streaming failed", {
                 type: parsed.type,
                 code: child.exitCode
               });
@@ -18173,7 +18447,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
               controller.enqueue(encoder.encode(formatSseDone()));
               return;
             }
-            log13.debug("cursor-agent completed (bun stream)", {
+            log14.debug("cursor-agent completed (bun stream)", {
               exitCode: child.exitCode
             });
             const doneChunk = createChatCompletionChunk(id, created, model, "", true);
@@ -18244,7 +18518,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ object: "list", data: models }));
         } catch (err) {
-          log13.error("Failed to list models", { error: String(err) });
+          log14.error("Failed to list models", { error: String(err) });
           res.writeHead(500, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: "Failed to fetch models" }));
         }
@@ -18255,7 +18529,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         res.end(JSON.stringify({ error: `Unsupported path: ${url2.pathname}` }));
         return;
       }
-      log13.debug("Proxy request (node)", { method: req.method, path: url2.pathname });
+      log14.debug("Proxy request (node)", { method: req.method, path: url2.pathname });
       let body = "";
       for await (const chunk of req) {
         body += chunk;
@@ -18278,7 +18552,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         const contentLen = typeof m?.content === "string" ? m.content.length : Array.isArray(m?.content) ? `arr${m.content.length}` : typeof m?.content;
         return `${i}:${role}${hasTc ? `(tc:${hasTc})` : ""}${role === "tool" ? `(tcid:${tcId},name:${tcName},clen:${contentLen})` : `(clen:${contentLen})`}`;
       });
-      log13.debug("Proxy chat request (node)", {
+      log14.debug("Proxy chat request (node)", {
         stream,
         model,
         messages: messages.length,
@@ -18309,14 +18583,14 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         let spawnErrorText = null;
         child.on("error", (error45) => {
           spawnErrorText = String(error45?.message || error45);
-          log13.error("Failed to spawn cursor-agent", { error: spawnErrorText, model });
+          log14.error("Failed to spawn cursor-agent", { error: spawnErrorText, model });
         });
         child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
         child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
         child.on("close", async (code) => {
           const stdout = Buffer.concat(stdoutChunks).toString().trim();
           const stderr = Buffer.concat(stderrChunks).toString().trim();
-          log13.debug("cursor-agent completed (node non-stream)", {
+          log14.debug("cursor-agent completed (node non-stream)", {
             code,
             stdoutChars: stdout.length,
             stderrChars: stderr.length,
@@ -18342,7 +18616,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             return;
           }
           if (intercepted.toolCall) {
-            log13.debug("Intercepted OpenCode tool call (non-stream)", {
+            log14.debug("Intercepted OpenCode tool call (non-stream)", {
               name: intercepted.toolCall.function.name,
               callId: intercepted.toolCall.id
             });
@@ -18356,7 +18630,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             const errSource = stderr || stdout || spawnErrorText || `cursor-agent exited with code ${String(code ?? "unknown")} and no output`;
             const parsed = parseAgentError(errSource);
             const userError = formatErrorForUser(parsed);
-            log13.error("cursor-cli failed", {
+            log14.error("cursor-cli failed", {
               type: parsed.type,
               message: parsed.message,
               code
@@ -18395,7 +18669,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             return;
           }
           const errSource = String(error45?.message || error45);
-          log13.error("Failed to spawn cursor-agent (stream)", { error: errSource, model });
+          log14.error("Failed to spawn cursor-agent (stream)", { error: errSource, model });
           const parsed = parseAgentError(errSource);
           const msg = formatErrorForUser(parsed);
           const errChunk = createChatCompletionChunk(id, created, model, msg, true);
@@ -18410,7 +18684,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           if (streamTerminated || res.writableEnded) {
             return;
           }
-          log13.debug("Intercepted OpenCode tool call (stream)", {
+          log14.debug("Intercepted OpenCode tool call (stream)", {
             name: toolCall.function.name,
             callId: toolCall.id
           });
@@ -18492,7 +18766,14 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                 }
               });
               if (result.terminate) {
-                emitTerminalAssistantErrorAndTerminate(result.terminate.message);
+                if (!result.terminate.silent) {
+                  emitTerminalAssistantErrorAndTerminate(result.terminate.message);
+                } else {
+                  streamTerminated = true;
+                  try {
+                    child.kill();
+                  } catch {}
+                }
                 break;
               }
               if (result.intercepted) {
@@ -18555,7 +18836,14 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                 }
               });
               if (result.terminate) {
-                emitTerminalAssistantErrorAndTerminate(result.terminate.message);
+                if (!result.terminate.silent) {
+                  emitTerminalAssistantErrorAndTerminate(result.terminate.message);
+                } else {
+                  streamTerminated = true;
+                  try {
+                    child.kill();
+                  } catch {}
+                }
                 break;
               }
               if (result.intercepted) {
@@ -18578,7 +18866,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           perf.mark("request:done");
           perf.summarize();
           const stderrText = Buffer.concat(stderrChunks).toString().trim();
-          log13.debug("cursor-agent completed (node stream)", {
+          log14.debug("cursor-agent completed (node stream)", {
             code,
             stderrChars: stderrText.length
           });
@@ -18793,7 +19081,7 @@ function buildToolHookEntries(registry2, fallbackBaseDir) {
           const normalizedArgs = applyToolContextDefaults(toolName, args, context, fallbackBaseDir, sessionWorkspaceBySession);
           return await handler(normalizedArgs);
         } catch (error45) {
-          log13.warn("Tool hook execution failed", { tool: toolName, error: String(error45?.message || error45) });
+          log14.debug("Tool hook execution failed", { tool: toolName, error: String(error45?.message || error45) });
           throw error45;
         }
       }
@@ -18805,9 +19093,9 @@ function buildToolHookEntries(registry2, fallbackBaseDir) {
   }
   return entries;
 }
-var log13, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROXY_HOST = "127.0.0.1", CURSOR_PROXY_DEFAULT_PORT = 32124, CURSOR_PROXY_DEFAULT_BASE_URL, REUSE_EXISTING_PROXY, SESSION_WORKSPACE_CACHE_LIMIT = 200, FORCE_TOOL_MODE, EMIT_TOOL_UPDATES, FORWARD_TOOL_CALLS, TOOL_LOOP_MODE_RAW, TOOL_LOOP_MODE, TOOL_LOOP_MODE_VALID, PROVIDER_BOUNDARY_MODE_RAW, PROVIDER_BOUNDARY_MODE, PROVIDER_BOUNDARY_MODE_VALID, LEGACY_PROVIDER_BOUNDARY, PROVIDER_BOUNDARY, ENABLE_PROVIDER_BOUNDARY_AUTOFALLBACK, TOOL_LOOP_MAX_REPEAT_RAW, TOOL_LOOP_MAX_REPEAT, TOOL_LOOP_MAX_REPEAT_VALID, PROXY_EXECUTE_TOOL_CALLS, SUPPRESS_CONVERTER_TOOL_EVENTS, SHOULD_EMIT_TOOL_UPDATES, CursorPlugin = async ({ $, directory, worktree, client: client3, serverUrl }) => {
+var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROVIDER_PREFIX, CURSOR_PROXY_HOST = "127.0.0.1", CURSOR_PROXY_DEFAULT_PORT = 32124, CURSOR_PROXY_DEFAULT_BASE_URL, REUSE_EXISTING_PROXY, SESSION_WORKSPACE_CACHE_LIMIT = 200, FORCE_TOOL_MODE, EMIT_TOOL_UPDATES, FORWARD_TOOL_CALLS, TOOL_LOOP_MODE_RAW, TOOL_LOOP_MODE, TOOL_LOOP_MODE_VALID, PROVIDER_BOUNDARY_MODE_RAW, PROVIDER_BOUNDARY_MODE, PROVIDER_BOUNDARY_MODE_VALID, LEGACY_PROVIDER_BOUNDARY, PROVIDER_BOUNDARY, ENABLE_PROVIDER_BOUNDARY_AUTOFALLBACK, TOOL_LOOP_MAX_REPEAT_RAW, TOOL_LOOP_MAX_REPEAT, TOOL_LOOP_MAX_REPEAT_VALID, PROXY_EXECUTE_TOOL_CALLS, SUPPRESS_CONVERTER_TOOL_EVENTS, SHOULD_EMIT_TOOL_UPDATES, CursorPlugin = async ({ $, directory, worktree, client: client3, serverUrl }) => {
   const workspaceDirectory = resolveWorkspaceDirectory(worktree, directory);
-  log13.debug("Plugin initializing", {
+  log14.debug("Plugin initializing", {
     directory,
     worktree,
     workspaceDirectory,
@@ -18815,22 +19103,22 @@ var log13, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROXY_HOST = "127.0.0.1", C
     serverUrl: serverUrl?.toString()
   });
   if (!TOOL_LOOP_MODE_VALID) {
-    log13.warn("Invalid CURSOR_ACP_TOOL_LOOP_MODE; defaulting to opencode", { value: TOOL_LOOP_MODE_RAW });
+    log14.warn("Invalid CURSOR_ACP_TOOL_LOOP_MODE; defaulting to opencode", { value: TOOL_LOOP_MODE_RAW });
   }
   if (!PROVIDER_BOUNDARY_MODE_VALID) {
-    log13.warn("Invalid CURSOR_ACP_PROVIDER_BOUNDARY; defaulting to v1", {
+    log14.warn("Invalid CURSOR_ACP_PROVIDER_BOUNDARY; defaulting to v1", {
       value: PROVIDER_BOUNDARY_MODE_RAW
     });
   }
   if (!TOOL_LOOP_MAX_REPEAT_VALID) {
-    log13.warn("Invalid CURSOR_ACP_TOOL_LOOP_MAX_REPEAT; defaulting to 3", {
+    log14.warn("Invalid CURSOR_ACP_TOOL_LOOP_MAX_REPEAT; defaulting to 3", {
       value: TOOL_LOOP_MAX_REPEAT_RAW
     });
   }
   if (ENABLE_PROVIDER_BOUNDARY_AUTOFALLBACK && PROVIDER_BOUNDARY.mode !== "v1") {
-    log13.debug("Provider boundary auto-fallback is enabled but inactive unless mode=v1");
+    log14.debug("Provider boundary auto-fallback is enabled but inactive unless mode=v1");
   }
-  log13.info("Tool loop mode configured", {
+  log14.info("Tool loop mode configured", {
     mode: TOOL_LOOP_MODE,
     providerBoundary: PROVIDER_BOUNDARY.mode,
     proxyExecToolCalls: PROXY_EXECUTE_TOOL_CALLS,
@@ -18841,9 +19129,9 @@ var log13, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROXY_HOST = "127.0.0.1", C
   const toolsEnabled = process.env.CURSOR_ACP_ENABLE_OPENCODE_TOOLS !== "false";
   const legacyProxyToolPathsEnabled = toolsEnabled && TOOL_LOOP_MODE === "proxy-exec";
   if (toolsEnabled && TOOL_LOOP_MODE === "opencode") {
-    log13.debug("OpenCode mode active; skipping legacy SDK/MCP discovery and proxy-side tool execution");
+    log14.debug("OpenCode mode active; skipping legacy SDK/MCP discovery and proxy-side tool execution");
   } else if (toolsEnabled && TOOL_LOOP_MODE === "off") {
-    log13.debug("Tool loop mode off; proxy-side tool execution disabled");
+    log14.debug("Tool loop mode off; proxy-side tool execution disabled");
   }
   const serverClient = legacyProxyToolPathsEnabled ? createOpencodeClient({ baseUrl: serverUrl.toString(), directory: workspaceDirectory }) : null;
   const discovery = legacyProxyToolPathsEnabled ? new OpenCodeToolDiscovery(serverClient ?? client3) : null;
@@ -18895,7 +19183,7 @@ var log13, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROXY_HOST = "127.0.0.1", C
         discoveredList = await discovery.listTools();
         discoveredList.forEach((t) => toolsByName.set(t.name, t));
       } catch (err) {
-        log13.debug("Tool discovery failed, using local tools only", { error: String(err) });
+        log14.debug("Tool discovery failed, using local tools only", { error: String(err) });
       }
     }
     const allTools = [...localTools, ...discoveredList];
@@ -18925,11 +19213,11 @@ var log13, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROXY_HOST = "127.0.0.1", C
     }
     lastToolNames = toolEntries.map((e) => e.function.name);
     lastToolMap = allTools.map((t) => ({ id: t.id, name: t.name }));
-    log13.debug("Tools refreshed", { local: localTools.length, discovered: discoveredList.length, total: toolEntries.length });
+    log14.debug("Tools refreshed", { local: localTools.length, discovered: discoveredList.length, total: toolEntries.length });
     return toolEntries;
   }
   const proxyBaseURL = await ensureCursorProxyServer(workspaceDirectory, router);
-  log13.debug("Proxy server started", { baseURL: proxyBaseURL });
+  log14.debug("Proxy server started", { baseURL: proxyBaseURL });
   const toolHookEntries = buildToolHookEntries(localRegistry, workspaceDirectory);
   return {
     tool: toolHookEntries,
@@ -18944,9 +19232,9 @@ var log13, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROXY_HOST = "127.0.0.1", C
           type: "oauth",
           async authorize() {
             try {
-              log13.info("Starting OAuth flow");
+              log14.info("Starting OAuth flow");
               const { url: url2, instructions, callback } = await startCursorOAuth();
-              log13.debug("Got OAuth URL", { url: url2.substring(0, 50) + "..." });
+              log14.debug("Got OAuth URL", { url: url2.substring(0, 50) + "..." });
               return {
                 url: url2,
                 instructions,
@@ -18954,7 +19242,7 @@ var log13, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROXY_HOST = "127.0.0.1", C
                 callback
               };
             } catch (error45) {
-              log13.error("OAuth error", { error: error45 });
+              log14.error("OAuth error", { error: error45 });
               throw error45;
             }
           }
@@ -18978,10 +19266,10 @@ var log13, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROXY_HOST = "127.0.0.1", C
             output.options.tools = resolved.tools;
           } else if (resolved.action === "preserve") {
             const count = Array.isArray(existingTools) ? existingTools.length : 0;
-            log13.debug("Using OpenCode-provided tools from chat.params", { count });
+            log14.debug("Using OpenCode-provided tools from chat.params", { count });
           }
         } catch (err) {
-          log13.debug("Failed to refresh tools", { error: String(err) });
+          log14.debug("Failed to refresh tools", { error: String(err) });
         }
       }
     },
@@ -19002,6 +19290,7 @@ var init_plugin = __esm(() => {
   init_parser();
   init_logger();
   init_perf();
+  init_prompt_builder();
   init_tool_loop();
   init_discovery();
   init_schema();
@@ -19015,7 +19304,10 @@ var init_plugin = __esm(() => {
   init_runtime_interception();
   init_tool_schema_compat();
   init_tool_loop_guard();
-  log13 = createLogger("plugin");
+  log14 = createLogger("plugin");
+  DEBUG_LOG_DIR2 = join4(homedir4(), ".config", "opencode", "logs");
+  DEBUG_LOG_FILE2 = join4(DEBUG_LOG_DIR2, "tool-loop-debug.log");
+  CURSOR_PROVIDER_PREFIX = `${CURSOR_PROVIDER_ID}/`;
   CURSOR_PROXY_DEFAULT_BASE_URL = `http://${CURSOR_PROXY_HOST}:${CURSOR_PROXY_DEFAULT_PORT}/v1`;
   REUSE_EXISTING_PROXY = process.env.CURSOR_ACP_REUSE_EXISTING_PROXY !== "false";
   FORCE_TOOL_MODE = process.env.CURSOR_ACP_FORCE !== "false";
@@ -19256,7 +19548,7 @@ init_logger();
 import { execSync } from "node:child_process";
 import { createServer } from "node:net";
 import { platform as platform2 } from "node:os";
-var log14 = createLogger("proxy-server");
+var log15 = createLogger("proxy-server");
 var DEFAULT_PORT = 32124;
 var PORT_RANGE_SIZE = 256;
 async function isPortAvailable(port, host) {
@@ -19275,10 +19567,10 @@ async function isPortAvailable(port, host) {
 }
 function getUsedPortsInRange(minPort, maxPort) {
   const used = new Set;
-  const os = platform2();
+  const os2 = platform2();
   try {
     let out;
-    if (os === "linux") {
+    if (os2 === "linux") {
       out = execSync("ss -tlnH", { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "ignore"] });
       for (const line of out.split(`
 `)) {
@@ -19291,7 +19583,7 @@ function getUsedPortsInRange(minPort, maxPort) {
         if (!Number.isNaN(port) && port >= minPort && port < maxPort)
           used.add(port);
       }
-    } else if (os === "darwin") {
+    } else if (os2 === "darwin") {
       out = execSync("lsof -iTCP -sTCP:LISTEN -nP", { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "ignore"] });
       for (const line of out.split(`
 `)) {
@@ -19303,11 +19595,11 @@ function getUsedPortsInRange(minPort, maxPort) {
         }
       }
     } else {
-      log14.debug(`Port detection not supported on ${os}. Using probe-based discovery.`);
+      log15.debug(`Port detection not supported on ${os2}. Using probe-based discovery.`);
     }
   } catch (error45) {
     const msg = error45 instanceof Error ? error45.message : String(error45);
-    log14.debug(`Port detection failed: ${msg}. Using probe-based discovery.`);
+    log15.debug(`Port detection failed: ${msg}. Using probe-based discovery.`);
   }
   return used;
 }
@@ -19346,8 +19638,8 @@ function createProxyServer(config2) {
         hostname: host,
         fetch(request) {
           const url2 = new URL(request.url);
-          const path = url2.pathname;
-          if (path === healthCheckPath && request.method === "GET") {
+          const path2 = url2.pathname;
+          if (path2 === healthCheckPath && request.method === "GET") {
             return Response.json({ ok: true });
           }
           return new Response("Not Found", { status: 404 });
@@ -19358,7 +19650,7 @@ function createProxyServer(config2) {
       const err = error45 instanceof Error ? error45 : new Error(String(error45));
       const isPortInUse = err.message.includes("EADDRINUSE") || err.message.includes("address already in use") || err.message.includes("port is already in use");
       if (!isPortInUse) {
-        log14.debug(`Unexpected error starting on port ${port}: ${err.message}`);
+        log15.debug(`Unexpected error starting on port ${port}: ${err.message}`);
       }
       return { success: false, error: err };
     }
@@ -19374,13 +19666,13 @@ function createProxyServer(config2) {
         if (result.success) {
           port = requestedPort;
         } else {
-          log14.debug(`Requested port ${requestedPort} unavailable: ${result.error?.message ?? "unknown"}. Falling back to automatic port selection.`);
+          log15.debug(`Requested port ${requestedPort} unavailable: ${result.error?.message ?? "unknown"}. Falling back to automatic port selection.`);
           port = await findAvailablePort(host);
           const fallbackResult = tryStart(port);
           if (!fallbackResult.success) {
             throw new Error(`Failed to start server on port ${requestedPort} (${result.error?.message ?? "unknown"}) ` + `and fallback port ${port} (${fallbackResult.error?.message ?? "unknown"})`);
           }
-          log14.debug(`Server started on fallback port ${port} instead of requested port ${requestedPort}`);
+          log15.debug(`Server started on fallback port ${port} instead of requested port ${requestedPort}`);
         }
       } else {
         port = await findAvailablePort(host);
@@ -19725,12 +20017,12 @@ init_auth();
 // src/commands/status.ts
 init_auth();
 init_logger();
-import { existsSync as existsSync2 } from "fs";
-var log15 = createLogger("status");
+import { existsSync as existsSync5 } from "fs";
+var log16 = createLogger("status");
 function checkAuthStatus() {
   const authFilePath = getAuthFilePath();
-  const exists = existsSync2(authFilePath);
-  log15.debug("Checking auth status", { path: authFilePath });
+  const exists = existsSync5(authFilePath);
+  log16.debug("Checking auth status", { path: authFilePath });
   if (exists) {
     return {
       authenticated: true,