@rama_nigg/open-cursor 2.1.6 → 2.2.0

package/dist/index.js

@@ -12848,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) {
@@ -12878,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,
@@ -13004,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();
@@ -13021,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;
@@ -13148,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;
     }
@@ -13163,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;
@@ -13187,7 +13248,7 @@ function getPossibleAuthPaths() {
 function getAuthFilePath() {
   const possiblePaths = getPossibleAuthPaths();
   for (const authPath of possiblePaths) {
-    if (existsSync(authPath)) {
+    if (existsSync2(authPath)) {
       return authPath;
     }
   }
@@ -13302,10 +13363,6 @@ class StreamToSseConverter {
   }
   handleEvent(event) {
     if (isAssistantText(event)) {
-      const hasPartialTimestamp = typeof event.timestamp_ms === "number";
-      if (!hasPartialTimestamp) {
-        return [];
-      }
       const delta = this.tracker.nextText(extractText(event));
       return delta ? [this.chunkWith({ content: delta })] : [];
     }
@@ -13419,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) => {
@@ -13433,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}`);
@@ -13472,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) {
@@ -13501,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,
@@ -13510,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}]`),
@@ -13666,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"],
@@ -13783,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") {
@@ -13795,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;
@@ -13834,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 [];
     }
   }
@@ -13855,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
@@ -13916,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
@@ -13944,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);
   }
@@ -14004,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
@@ -14319,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) {
@@ -14338,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;
       }
@@ -14368,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("?")) {
@@ -15493,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
@@ -15528,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) };
     }
   }
@@ -15541,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
@@ -15571,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) };
     }
   }
@@ -15584,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
@@ -15597,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
@@ -15615,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: {
@@ -15679,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(`
 `);
@@ -15701,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: {
@@ -15718,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;
@@ -15736,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: {
@@ -15757,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;
@@ -15775,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;
@@ -15829,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 });
     };
@@ -15878,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}`;
@@ -15920,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"];
@@ -16049,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) {
@@ -16062,7 +16201,7 @@ function resolveEditArguments(args) {
     oldString = "";
   }
   return {
-    path,
+    path: path2,
     old_string: oldString,
     new_string: newString
   };
@@ -16405,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;
   }
@@ -16448,6 +16604,15 @@ function normalizeBashCommand(value) {
 }
 function normalizeTodoStatus(status) {
   const normalized = status.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  if (normalized === "todo_status_pending") {
+    return "pending";
+  }
+  if (normalized === "todo_status_inprogress" || normalized === "todo_status_in_progress") {
+    return "in_progress";
+  }
+  if (normalized === "todo_status_done" || normalized === "todo_status_complete" || normalized === "todo_status_completed") {
+    return "completed";
+  }
   if (normalized === "todo" || normalized === "pending") {
     return "pending";
   }
@@ -16638,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"],
@@ -16651,7 +16819,7 @@ async function handleToolLoopEventLegacy(options) {
     event,
     toolLoopMode,
     allowedToolNames,
-    toolSchemaMap: _toolSchemaMap,
+    toolSchemaMap,
     toolLoopGuard,
     toolMapper,
     toolSessionId,
@@ -16666,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);
@@ -16723,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,
@@ -16732,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,
@@ -16749,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
@@ -16769,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
@@ -16787,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
       });
@@ -16866,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,
@@ -16913,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,
@@ -17046,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;
@@ -17059,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 })
       }
     }
   };
@@ -17072,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) {
@@ -17091,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 };
 }
@@ -17122,12 +17335,18 @@ function createToolLoopGuard(messages, maxRepeat) {
         const successFingerprint = `${toolCall.function.name}|values:${valueSignature}|success`;
         const repeatCount = (counts.get(successFingerprint) ?? 0) + 1;
         counts.set(successFingerprint, repeatCount);
+        const coarseSuccessFingerprint = deriveSuccessCoarseFingerprint(toolCall.function.name, toolCall.function.arguments);
+        const coarseRepeatCount = coarseSuccessFingerprint ? (coarseCounts.get(coarseSuccessFingerprint) ?? 0) + 1 : 0;
+        if (coarseSuccessFingerprint) {
+          coarseCounts.set(coarseSuccessFingerprint, coarseRepeatCount);
+        }
+        const coarseTriggered = coarseSuccessFingerprint ? coarseRepeatCount > maxRepeat : false;
         return {
-          fingerprint: successFingerprint,
-          repeatCount,
+          fingerprint: coarseTriggered ? coarseSuccessFingerprint : successFingerprint,
+          repeatCount: coarseTriggered ? coarseRepeatCount : repeatCount,
           maxRepeat,
           errorClass,
-          triggered: repeatCount > maxRepeat,
+          triggered: repeatCount > maxRepeat || coarseTriggered,
           tracked: true
         };
       }
@@ -17200,22 +17419,49 @@ function indexToolLoopHistory(messages) {
     }
   }
   for (const call of assistantCalls) {
+    const schemaSignature = deriveSchemaValidationSignature(call.name, call.argKeys);
     const errorClass = normalizeErrorClassForTool(call.name, byCallId.get(call.id) ?? latestByToolName.get(call.name) ?? latest ?? "unknown");
     if (errorClass === "success") {
       incrementCount(initialCounts, `${call.name}|values:${call.argValueSignature}|success`);
+      const coarseSuccessFP = deriveSuccessCoarseFingerprint(call.name, call.rawArguments);
+      if (coarseSuccessFP) {
+        incrementCount(initialCoarseCounts, coarseSuccessFP);
+      }
+      if (schemaSignature) {
+        incrementCount(initialValidationCounts, `${call.name}|schema:${schemaSignature}|validation`);
+        incrementCount(initialValidationCoarseCounts, `${call.name}|validation`);
+      }
       continue;
     }
     const strictFingerprint = `${call.name}|${call.argShape}|${errorClass}`;
     const coarseFingerprint = `${call.name}|${errorClass}`;
     incrementCount(initialCounts, strictFingerprint);
     incrementCount(initialCoarseCounts, coarseFingerprint);
-    const schemaSignature = deriveSchemaValidationSignature(call.name, call.argKeys);
     if (!schemaSignature) {
       continue;
     }
     incrementCount(initialValidationCounts, `${call.name}|schema:${schemaSignature}|validation`);
     incrementCount(initialValidationCoarseCounts, `${call.name}|validation`);
   }
+  const strippedRounds = countStrippedAssistantRounds(messages);
+  if (strippedRounds > 0 && assistantCalls.length > 0) {
+    for (const call of assistantCalls) {
+      const errorClass = normalizeErrorClassForTool(call.name, byCallId.get(call.id) ?? latestByToolName.get(call.name) ?? latest ?? "unknown");
+      if (errorClass !== "success") {
+        continue;
+      }
+      const coarseSuccessFP = deriveSuccessCoarseFingerprint(call.name, call.rawArguments);
+      if (coarseSuccessFP) {
+        for (let i = 0;i < strippedRounds; i++) {
+          incrementCount(initialCoarseCounts, coarseSuccessFP);
+        }
+      }
+      const successFP = `${call.name}|values:${call.argValueSignature}|success`;
+      for (let i = 0;i < strippedRounds; i++) {
+        incrementCount(initialCounts, successFP);
+      }
+    }
+  }
   return {
     byCallId,
     latest,
@@ -17281,6 +17527,31 @@ function deriveArgumentValueSignature(rawArguments) {
     return `invalid:${hashString(rawArguments)}`;
   }
 }
+function deriveSuccessCoarseFingerprint(toolName, rawArguments) {
+  const lowered = toolName.toLowerCase();
+  if (lowered !== "edit" && lowered !== "write") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(rawArguments);
+    if (!isRecord4(parsed)) {
+      return null;
+    }
+    const path2 = typeof parsed.path === "string" ? parsed.path : "";
+    if (!path2) {
+      return null;
+    }
+    if (lowered === "edit") {
+      const oldString = typeof parsed.old_string === "string" ? parsed.old_string : null;
+      if (oldString !== "") {
+        return null;
+      }
+    }
+    return `${toolName}|path:${hashString(path2)}|success`;
+  } catch {
+    return null;
+  }
+}
 function extractAssistantToolCalls(messages) {
   const calls = [];
   for (const message of messages) {
@@ -17301,6 +17572,7 @@ function extractAssistantToolCalls(messages) {
       calls.push({
         id,
         name,
+        rawArguments,
         argShape: deriveArgumentShape(rawArguments),
         argValueSignature: deriveArgumentValueSignature(rawArguments),
         argKeys: extractArgumentKeys(rawArguments)
@@ -17412,6 +17684,23 @@ function normalizeErrorClassForTool(toolName, errorClass) {
   }
   return errorClass;
 }
+function countStrippedAssistantRounds(messages) {
+  let count = 0;
+  for (const message of messages) {
+    if (!isRecord4(message) || message.role !== "assistant") {
+      continue;
+    }
+    if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+      continue;
+    }
+    const content = message.content;
+    const hasContent = typeof content === "string" && content.trim().length > 0 || Array.isArray(content) && content.length > 0;
+    if (!hasContent) {
+      count++;
+    }
+  }
+  return count;
+}
 function toLowerText(content) {
   const rendered = renderContent(content);
   return rendered.trim().toLowerCase();
@@ -17446,38 +17735,102 @@ var UNKNOWN_AS_SUCCESS_TOOLS;
 var init_tool_loop_guard = __esm(() => {
   UNKNOWN_AS_SUCCESS_TOOLS = new Set([
     "bash",
+    "shell",
     "read",
+    "write",
+    "edit",
     "grep",
     "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 { 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, 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 pluginDir = join2(homedir2(), ".config", "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) : join4(homedir4(), ".config");
+  return join4(configHome, "opencode");
+}
+function canonicalizePathForCompare(pathValue) {
+  const resolvedPath = resolve(pathValue);
+  let normalizedPath = resolvedPath;
+  try {
+    normalizedPath = typeof realpathSync.native === "function" ? realpathSync.native(resolvedPath) : realpathSync(resolvedPath);
+  } catch {
+    normalizedPath = resolvedPath;
+  }
+  if (process.platform === "darwin") {
+    return normalizedPath.toLowerCase();
+  }
+  return normalizedPath;
+}
+function isWithinPath(root, candidate) {
+  const normalizedRoot = canonicalizePathForCompare(root);
+  const normalizedCandidate = canonicalizePathForCompare(candidate);
+  const rel = relative(normalizedRoot, normalizedCandidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function resolveCandidate(value) {
+  if (!value || value.trim().length === 0) {
+    return "";
+  }
+  return resolve(value);
+}
+function isNonConfigPath(pathValue) {
+  if (!pathValue) {
+    return false;
+  }
+  return !isWithinPath(getOpenCodeConfigPrefix(), pathValue);
+}
 function resolveWorkspaceDirectory(worktree, directory) {
   const envWorkspace = process.env.CURSOR_ACP_WORKSPACE?.trim();
   if (envWorkspace) {
@@ -17487,18 +17840,17 @@ function resolveWorkspaceDirectory(worktree, directory) {
   if (envProjectDir) {
     return resolve(envProjectDir);
   }
-  const configHome = process.env.XDG_CONFIG_HOME ? resolve(process.env.XDG_CONFIG_HOME) : join2(homedir2(), ".config");
-  const configPrefix = join2(configHome, "opencode");
-  const worktreeCandidate = worktree ? resolve(worktree) : "";
-  if (worktreeCandidate && !worktreeCandidate.startsWith(configPrefix)) {
+  const configPrefix = getOpenCodeConfigPrefix();
+  const worktreeCandidate = resolveCandidate(worktree);
+  if (worktreeCandidate && !isWithinPath(configPrefix, worktreeCandidate)) {
     return worktreeCandidate;
   }
-  const dirCandidate = directory ? resolve(directory) : "";
-  if (dirCandidate && !dirCandidate.startsWith(configPrefix)) {
+  const dirCandidate = resolveCandidate(directory);
+  if (dirCandidate && !isWithinPath(configPrefix, dirCandidate)) {
     return dirCandidate;
   }
-  const cwd = process.cwd();
-  if (cwd && !cwd.startsWith(configPrefix)) {
+  const cwd = resolve(process.cwd());
+  if (cwd && !isWithinPath(configPrefix, cwd)) {
     return cwd;
   }
   return dirCandidate || cwd || configPrefix;
@@ -17609,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;
@@ -17688,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) {
@@ -17745,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" }
@@ -17758,23 +18110,40 @@ 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);
       const boundaryContext = createBoundaryRuntimeContext("bun-handler");
       const prompt = buildPromptFromMessages(messages, tools);
       const model = boundaryContext.run("normalizeRuntimeModel", (boundary) => boundary.normalizeRuntimeModel(body?.model));
-      log13.debug("Proxy chat request (bun)", {
+      const msgSummaryBun = messages.map((m, i) => {
+        const role = m?.role ?? "?";
+        const hasTc = Array.isArray(m?.tool_calls) ? m.tool_calls.length : 0;
+        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})`;
+      });
+      log14.debug("Proxy chat request (bun)", {
         stream,
         model,
         messages: messages.length,
         tools: tools.length,
-        promptChars: prompt.length
+        promptChars: prompt.length,
+        msgRoles: msgSummaryBun.join(",")
       });
       const bunAny = globalThis;
       if (!bunAny.Bun?.spawn) {
@@ -17814,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
@@ -17840,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
           });
@@ -17854,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
@@ -17888,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
               });
@@ -17971,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) {
@@ -18029,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) {
@@ -18051,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
               });
@@ -18062,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);
@@ -18133,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" }));
         }
@@ -18144,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;
@@ -18159,12 +18544,21 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
       const boundaryContext = createBoundaryRuntimeContext("node-handler");
       const prompt = buildPromptFromMessages(messages, tools);
       const model = boundaryContext.run("normalizeRuntimeModel", (boundary) => boundary.normalizeRuntimeModel(bodyData?.model));
-      log13.debug("Proxy chat request (node)", {
+      const msgSummary = messages.map((m, i) => {
+        const role = m?.role ?? "?";
+        const hasTc = Array.isArray(m?.tool_calls) ? m.tool_calls.length : 0;
+        const tcId = m?.tool_call_id ? "yes" : "no";
+        const tcName = m?.name ?? "";
+        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})`}`;
+      });
+      log14.debug("Proxy chat request (node)", {
         stream,
         model,
         messages: messages.length,
         tools: tools.length,
-        promptChars: prompt.length
+        promptChars: prompt.length,
+        msgRoles: msgSummary.join(",")
       });
       const cmd = [
         "cursor-agent",
@@ -18189,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,
@@ -18222,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
             });
@@ -18236,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
@@ -18275,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);
@@ -18290,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
           });
@@ -18372,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) {
@@ -18435,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) {
@@ -18458,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
           });
@@ -18584,19 +18992,39 @@ function jsonSchemaToZod(jsonSchema) {
   }
   return zodShape;
 }
-function resolveToolContextBaseDir(context, fallbackBaseDir) {
-  const configHome = process.env.XDG_CONFIG_HOME ? resolve(process.env.XDG_CONFIG_HOME) : join2(homedir2(), ".config");
-  const configPrefix = join2(configHome, "opencode");
-  const worktree = typeof context?.worktree === "string" ? context.worktree.trim() : "";
-  if (worktree)
+function resolveToolContextBaseDirWithSession(context, fallbackBaseDir, sessionWorkspaceBySession) {
+  const sessionID = typeof context?.sessionID === "string" && context.sessionID.trim().length > 0 ? context.sessionID.trim() : "";
+  const worktree = resolveCandidate(typeof context?.worktree === "string" ? context.worktree : undefined);
+  const directory = resolveCandidate(typeof context?.directory === "string" ? context.directory : undefined);
+  const fallback = resolveCandidate(fallbackBaseDir);
+  const pinned = sessionID && sessionWorkspaceBySession ? resolveCandidate(sessionWorkspaceBySession.get(sessionID)) : "";
+  const pinSession = (candidate) => {
+    if (sessionID && sessionWorkspaceBySession && isNonConfigPath(candidate)) {
+      if (!sessionWorkspaceBySession.has(sessionID) && sessionWorkspaceBySession.size >= SESSION_WORKSPACE_CACHE_LIMIT) {
+        const oldestSession = sessionWorkspaceBySession.keys().next().value;
+        if (typeof oldestSession === "string") {
+          sessionWorkspaceBySession.delete(oldestSession);
+        }
+      }
+      sessionWorkspaceBySession.set(sessionID, candidate);
+    }
+  };
+  if (isNonConfigPath(worktree)) {
+    pinSession(worktree);
     return worktree;
-  const directory = typeof context?.directory === "string" ? context.directory.trim() : "";
-  if (directory && !resolve(directory).startsWith(configPrefix))
+  }
+  if (isNonConfigPath(pinned)) {
+    return pinned;
+  }
+  if (isNonConfigPath(directory)) {
+    pinSession(directory);
     return directory;
-  const fallback = typeof fallbackBaseDir === "string" ? fallbackBaseDir.trim() : "";
-  if (fallback)
+  }
+  if (isNonConfigPath(fallback)) {
+    pinSession(fallback);
     return fallback;
-  return directory || null;
+  }
+  return null;
 }
 function toAbsoluteWithBase(value, baseDir) {
   if (typeof value !== "string") {
@@ -18608,8 +19036,8 @@ function toAbsoluteWithBase(value, baseDir) {
   }
   return resolve(baseDir, trimmed);
 }
-function applyToolContextDefaults(toolName, rawArgs, context, fallbackBaseDir) {
-  const baseDir = resolveToolContextBaseDir(context, fallbackBaseDir);
+function applyToolContextDefaults(toolName, rawArgs, context, fallbackBaseDir, sessionWorkspaceBySession) {
+  const baseDir = resolveToolContextBaseDirWithSession(context, fallbackBaseDir, sessionWorkspaceBySession);
   if (!baseDir) {
     return rawArgs;
   }
@@ -18638,6 +19066,7 @@ function applyToolContextDefaults(toolName, rawArgs, context, fallbackBaseDir) {
 }
 function buildToolHookEntries(registry2, fallbackBaseDir) {
   const entries = {};
+  const sessionWorkspaceBySession = new Map;
   const tools = registry2.list();
   for (const t of tools) {
     const handler = registry2.getHandler(t.name);
@@ -18649,10 +19078,10 @@ function buildToolHookEntries(registry2, fallbackBaseDir) {
       args: zodArgs,
       async execute(args, context) {
         try {
-          const normalizedArgs = applyToolContextDefaults(toolName, args, context, 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;
         }
       }
@@ -18664,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, 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,
@@ -18674,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,
@@ -18700,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;
@@ -18754,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];
@@ -18784,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,
@@ -18803,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,
@@ -18813,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;
             }
           }
@@ -18837,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) });
         }
       }
     },
@@ -18861,6 +19290,7 @@ var init_plugin = __esm(() => {
   init_parser();
   init_logger();
   init_perf();
+  init_prompt_builder();
   init_tool_loop();
   init_discovery();
   init_schema();
@@ -18874,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";
@@ -19113,16 +19546,31 @@ class SimpleCursorClient {
 // src/proxy/server.ts
 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) {
+  return await new Promise((resolve2) => {
+    const server2 = createServer();
+    server2.unref();
+    server2.once("error", () => {
+      resolve2(false);
+    });
+    server2.listen({ port, host }, () => {
+      server2.close(() => {
+        resolve2(true);
+      });
+    });
+  });
+}
 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(`
 `)) {
@@ -19135,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(`
 `)) {
@@ -19147,21 +19595,29 @@ 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;
 }
-async function findAvailablePort() {
+async function findAvailablePort(host = "127.0.0.1") {
   const minPort = DEFAULT_PORT;
   const maxPort = DEFAULT_PORT + PORT_RANGE_SIZE;
   const used = getUsedPortsInRange(minPort, maxPort);
   for (let p = minPort;p < maxPort; p++) {
-    if (!used.has(p))
+    if (used.has(p))
+      continue;
+    if (await isPortAvailable(p, host)) {
       return p;
+    }
+  }
+  for (let p = minPort;p < maxPort; p++) {
+    if (await isPortAvailable(p, host)) {
+      return p;
+    }
   }
   throw new Error(`No available port in range ${minPort}-${maxPort - 1}`);
 }
@@ -19182,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 });
@@ -19194,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 };
     }
@@ -19210,16 +19666,16 @@ 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.`);
-          port = await findAvailablePort();
+          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();
+        port = await findAvailablePort(host);
         const result = tryStart(port);
         if (!result.success) {
           throw new Error(`Failed to start server on port ${port}: ${result.error?.message ?? "unknown"}`);
@@ -19561,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,