feat: fix task tool guard threshold and inject subtype values (v2.3.20)

Author: Nomadcxx

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rama_nigg/open-cursor",
-  "version": "2.3.19",
+  "version": "2.3.20",
   "description": "No prompt limits. No broken streams. Full thinking + tool support. Your Cursor subscription, properly integrated.",
   "type": "module",
   "main": "dist/plugin-entry.js",

src/mcp/config.ts

@@ -93,6 +93,55 @@ export function readMcpConfigs(deps: ReadMcpConfigsDeps = {}): McpServerConfig[]
   return configs;
 }
 
+interface ReadSubagentNamesDeps {
+  configJson?: string;
+  existsSync?: (path: string) => boolean;
+  readFileSync?: (path: string, enc: BufferEncoding) => string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export function readSubagentNames(deps: ReadSubagentNamesDeps = {}): string[] {
+  let raw: string;
+
+  if (deps.configJson != null) {
+    raw = deps.configJson;
+  } else {
+    const exists = deps.existsSync ?? nodeExistsSync;
+    const readFile = deps.readFileSync ?? nodeReadFileSync;
+    const configPath = resolveOpenCodeConfigPath(deps.env ?? process.env);
+    if (!exists(configPath)) return ["general-purpose"];
+    try {
+      raw = readFile(configPath, "utf8");
+    } catch {
+      return ["general-purpose"];
+    }
+  }
+
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return ["general-purpose"];
+  }
+
+  const agentSection = parsed.agent;
+  if (!agentSection || typeof agentSection !== "object" || Array.isArray(agentSection)) {
+    return ["general-purpose"];
+  }
+
+  const agents = agentSection as Record<string, unknown>;
+  const names = Object.keys(agents);
+  if (names.length === 0) return ["general-purpose"];
+
+  const subagentNames = names.filter((name) => {
+    const entry = agents[name];
+    return entry && typeof entry === "object" && !Array.isArray(entry)
+      && (entry as Record<string, unknown>).mode === "subagent";
+  });
+
+  return subagentNames.length > 0 ? subagentNames : names;
+}
+
 function isStringRecord(v: unknown): v is Record<string, string> {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }

src/plugin.ts

@@ -25,7 +25,7 @@ import { ToolRouter } from "./tools/router.js";
 import { SkillLoader } from "./tools/skills/loader.js";
 import { SkillResolver } from "./tools/skills/resolver.js";
 import { autoRefreshModels } from "./models/sync.js";
-import { readMcpConfigs } from "./mcp/config.js";
+import { readMcpConfigs, readSubagentNames } from "./mcp/config.js";
 import { McpClientManager } from "./mcp/client-manager.js";
 import { buildMcpToolHookEntries, buildMcpToolDefinitions } from "./mcp/tool-bridge.js";
 import { createOpencodeClient } from "@opencode-ai/sdk";
@@ -92,6 +92,7 @@ export function buildAvailableToolsSystemMessage(
   lastToolMap: Array<{ id: string; name: string }>,
   mcpToolDefs: any[],
   mcpToolSummaries?: McpToolSummary[],
+  subagentNames: string[] = [],
 ): string | null {
   const parts: string[] = [];
 
@@ -132,6 +133,12 @@ export function buildAvailableToolsSystemMessage(
     parts.push(lines.join("\n"));
   }
 
+  if (subagentNames.length > 0) {
+    parts.push(
+      `When calling the task tool, set subagent_type to one of: ${subagentNames.join(", ")}. Do not omit this parameter.`
+    );
+  }
+
   return parts.length > 0 ? parts.join("\n\n") : null;
 }
 
@@ -628,7 +635,8 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       const toolLoopGuard = createToolLoopGuard(messages, TOOL_LOOP_MAX_REPEAT);
       const boundaryContext = createBoundaryRuntimeContext("bun-handler");
 
-      const prompt = buildPromptFromMessages(messages, tools);
+      const subagentNames = readSubagentNames();
+      const prompt = buildPromptFromMessages(messages, tools, subagentNames);
       const model = boundaryContext.run("normalizeRuntimeModel", (boundary) =>
         boundary.normalizeRuntimeModel(body?.model),
       );
@@ -1092,7 +1100,8 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       const toolLoopGuard = createToolLoopGuard(messages, TOOL_LOOP_MAX_REPEAT);
       const boundaryContext = createBoundaryRuntimeContext("node-handler");
 
-      const prompt = buildPromptFromMessages(messages, tools);
+      const subagentNames = readSubagentNames();
+      const prompt = buildPromptFromMessages(messages, tools, subagentNames);
       const model = boundaryContext.run("normalizeRuntimeModel", (boundary) =>
         boundary.normalizeRuntimeModel(bodyData?.model),
       );
@@ -2058,7 +2067,11 @@ export const CursorPlugin: Plugin = async ({ $, directory, worktree, client, ser
 
     async "experimental.chat.system.transform"(input: any, output: { system: string[] }) {
       if (!toolsEnabled) return;
-      const systemMessage = buildAvailableToolsSystemMessage(lastToolNames, lastToolMap, mcpToolDefs, mcpToolSummaries);
+      const subagentNames = readSubagentNames();
+      const systemMessage = buildAvailableToolsSystemMessage(
+        lastToolNames, lastToolMap, mcpToolDefs, mcpToolSummaries,
+        subagentNames,
+      );
       if (!systemMessage) return;
       output.system = output.system || [];
       output.system.push(systemMessage);

src/provider/tool-loop-guard.ts

@@ -44,6 +44,7 @@ const EXPLORATION_TOOLS = new Set([
   "bash",
   "shell",
   "webfetch",
+  "task",
 ]);
 
 export interface ToolLoopGuardDecision {
@@ -511,16 +512,20 @@ function evaluateWithFingerprints(
     };
   }
 
+  const isExplorationTool = EXPLORATION_TOOLS.has(toolName.toLowerCase());
+  const effectiveMaxRepeat = isExplorationTool
+    ? maxRepeat * EXPLORATION_LIMIT_MULTIPLIER
+    : maxRepeat;
+
   const strictRepeatCount = (strictCounts.get(strictFingerprint) ?? 0) + 1;
   strictCounts.set(strictFingerprint, strictRepeatCount);
-  const strictTriggered = strictRepeatCount > maxRepeat;
+  const strictTriggered = strictRepeatCount > effectiveMaxRepeat;
 
-  const isExplorationTool = EXPLORATION_TOOLS.has(toolName.toLowerCase());
   if (isExplorationTool) {
     return {
       fingerprint: strictFingerprint,
       repeatCount: strictRepeatCount,
-      maxRepeat,
+      maxRepeat: effectiveMaxRepeat,
       errorClass,
       triggered: strictTriggered,
       tracked: true,

src/proxy/prompt-builder.ts

@@ -36,7 +36,7 @@ function debugLogToFile(message: string, data: any): void {
  * Handles role:"tool" result messages and assistant tool_calls that
  * plain text flattening would silently drop.
  */
-export function buildPromptFromMessages(messages: Array<any>, tools: Array<any>): string {
+export function buildPromptFromMessages(messages: Array<any>, tools: Array<any>, subagentNames: string[] = []): string {
   // DEBUG: Log incoming message structure to file for root cause analysis
   const messageSummary = messages.map((m: any, i: number) => {
     const role = m?.role ?? "?";
@@ -98,6 +98,15 @@ export function buildPromptFromMessages(messages: Array<any>, tools: Array<any>)
       `SYSTEM: You have access to the following tools. When you need to use one, respond with a tool_call in the standard OpenAI format.\n` +
         `Tool guidance: prefer write/edit for file changes; use bash mainly to run commands/tests.\n\nAvailable tools:\n${toolDescs}`,
     );
+    const hasTaskTool = tools.some((t: any) => {
+      const name = (t?.function?.name ?? t?.name ?? "").toLowerCase();
+      return name === "task";
+    });
+    if (hasTaskTool && subagentNames.length > 0) {
+      lines.push(
+        `When calling the task tool, set subagent_type to one of: ${subagentNames.join(", ")}. Do not omit this parameter.`
+      );
+    }
   }
 
   for (const message of messages) {

tests/unit/mcp-config.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from "bun:test";
+import { readSubagentNames } from "../../src/mcp/config.js";
+
+describe("readSubagentNames", () => {
+  it("returns only mode:subagent agents when some exist", () => {
+    const config = JSON.stringify({
+      agent: {
+        build: { mode: "primary", model: "openai/gpt-5" },
+        codemachine: { mode: "subagent", model: "kimi/kimi-k2" },
+        review: { mode: "subagent", model: "google/gemini" },
+      },
+    });
+    expect(readSubagentNames({ configJson: config })).toEqual(["codemachine", "review"]);
+  });
+
+  it("returns all agents when none have mode:subagent", () => {
+    const config = JSON.stringify({
+      agent: {
+        build: { mode: "primary", model: "openai/gpt-5" },
+        plan: { mode: "primary", model: "zai/glm" },
+      },
+    });
+    expect(readSubagentNames({ configJson: config })).toEqual(["build", "plan"]);
+  });
+
+  it("returns general-purpose when agent section is empty object", () => {
+    const config = JSON.stringify({ agent: {} });
+    expect(readSubagentNames({ configJson: config })).toEqual(["general-purpose"]);
+  });
+
+  it("returns general-purpose when agent section is absent", () => {
+    const config = JSON.stringify({ mcp: {} });
+    expect(readSubagentNames({ configJson: config })).toEqual(["general-purpose"]);
+  });
+
+  it("returns general-purpose when config file is unreadable", () => {
+    expect(readSubagentNames({ configJson: undefined, existsSync: () => false })).toEqual(["general-purpose"]);
+  });
+
+  it("returns general-purpose when config is malformed JSON", () => {
+    expect(readSubagentNames({ configJson: "{ bad json" })).toEqual(["general-purpose"]);
+  });
+});

tests/unit/plugin-system-message.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from "bun:test";
+import { buildAvailableToolsSystemMessage } from "../../src/plugin.js";
+
+describe("buildAvailableToolsSystemMessage — subagentNames injection", () => {
+  it("includes subagent names in task guidance", () => {
+    const msg = buildAvailableToolsSystemMessage(
+      ["task", "read"],
+      [{ id: "task", name: "task" }],
+      [],
+      [],
+      ["codemachine", "review"],
+    );
+    expect(msg).toContain("codemachine");
+    expect(msg).toContain("review");
+    expect(msg).toContain("subagent_type");
+  });
+
+  it("omits task guidance when subagentNames is empty", () => {
+    const msg = buildAvailableToolsSystemMessage(
+      ["task"],
+      [],
+      [],
+      [],
+      [],
+    );
+    expect(msg).not.toContain("subagent_type");
+  });
+
+  it("returns null when no tools and no subagentNames", () => {
+    const msg = buildAvailableToolsSystemMessage([], [], [], [], []);
+    expect(msg).toBeNull();
+  });
+});