internaltool-mcp 1.6.28 → 1.6.30

package/index.js

@@ -798,8 +798,8 @@ Call confirmed=false to preview the decomposition, confirmed=true to save it.`,
         subtasksCreated: subtaskPlan.length,
         message: `Decomposition saved. ${subtaskPlan.length} subtask(s) added to the board.`,
         nextStep: parallelGroups.length > 0
-          ? `⚡ COORDINATOR: Call get_parallel_kickoffs with taskId="${taskId}" NOW. It returns ready-to-paste prompts for each builder window. DO NOT implement code yourself — your job is to coordinate only.`
-          : `Call get_parallel_kickoffs with taskId="${taskId}" to get the builder prompt. DO NOT implement code yourself.`,
+          ? `⚡ COORDINATOR: Call get_parallel_kickoffs with taskId="${taskId}" NOW. It writes Cursor Background Agent files for each parallel builder automatically. Then tell the user to open Background Agents panel (⌘⇧J) and click Start. DO NOT implement code yourself.`
+          : `Call get_parallel_kickoffs with taskId="${taskId}". It writes a Cursor Background Agent file for the builder. Tell the user to open Background Agents panel (⌘⇧J) and start it.`,
       })
     }
   )
@@ -1541,16 +1541,15 @@ The log is visible in InternalTool under the task's Session tab — gives the hu
   // ── get_parallel_kickoffs ─────────────────────────────────────────────────────
   server.tool(
     'get_parallel_kickoffs',
-    `Read the decomposition plan and return ready-to-paste Cursor Agent prompts for the next group of parallel subtasks.
+    `Read the decomposition plan, write Cursor Background Agent files for each parallel subtask, and return instructions.
 
 COORDINATOR WORKFLOW:
 1. Call decompose_task to create the plan
-2. Call get_parallel_kickoffs to get one paste-ready prompt per parallel subtask
-3. Tell the user exactly how many new Cursor Agent windows to open
-4. Give them each prompt to paste — one window per subtask
+2. Call get_parallel_kickoffs — it writes .cursor/agents/builder-N.md files automatically
+3. Open the Cursor Background Agents panel (⌘⇧J or ⌘⇧P → "Background Agents")
+4. Click "Start" for each builder agent — they run in parallel in the background
 
-Cursor cannot spawn agent windows automatically. This tool generates the prompts;
-the human opens the windows. Each builder agent then runs independently.`,
+The agent files are fully self-contained: each builder knows exactly what MCP tools to call.`,
     {
       taskId: z.string().describe("Task's MongoDB ObjectId"),
     },
@@ -1626,59 +1625,70 @@ the human opens the windows. Each builder agent then runs independently.`,
         const filesArg = (st.files || []).map(f => `"${f}"`).join(', ')
         const fileList = (st.files || []).map(f => `  - \`${f}\``).join('\n')
 
-        // Prompt is structured as a direct agent instruction — no ambiguity, explicit MCP calls first
+        // Prompt is a short, direct imperative Cursor immediately executes.
+        // Key: start with "Use the InternalTool MCP" so Cursor knows to call tools.
+        // Avoid pseudocode like fn(arg=val) — use plain English with quoted values.
+        const fileListPlain = (st.files || []).join(', ')
         const prompt = [
-          `## Builder Agent — ${task.key} · Subtask ${i + 1} of ${parallelCount}`,
+          `Use the InternalTool MCP tools to implement subtask "${st.title}" for task ${task.key}.`,
           ``,
-          `**Subtask:** ${st.title}`,
-          `**Description:** ${st.description || '(see task description)'}`,
-          `**Your exclusive files (do NOT touch any other file):**`,
-          fileList || '  (none pre-assigned — use your judgement)',
+          `Do these steps immediately in order — do not ask for confirmation, do not skip any step:`,
           ``,
-          `## DO THIS NOW — in order, no skipping:`,
+          `1. Call kickoff_task with taskId "${taskId}", agentRole "builder", confirmed true`,
+          `2. Call claim_files with taskId "${taskId}" and files [${filesArg}]`,
+          `3. Call get_agent_context with taskId "${taskId}" to read the full task plan`,
+          `4. Implement the subtask: ${st.description || st.title}`,
+          `   - You may ONLY modify these files: ${fileListPlain}`,
+          `   - Do NOT touch any other file`,
+          `5. Run npm test — all tests must pass before continuing`,
+          `6. Call commit_helper with taskId "${taskId}"`,
+          `7. Call update_task with taskId "${taskId}" and mark the subtask "${st.title}" as done`,
           ``,
-          `**Step 1** — Call this MCP tool immediately:`,
-          `  kickoff_task(taskId="${taskId}", agentRole="${st.role || 'builder'}", confirmed=true)`,
-          ``,
-          `**Step 2** — Lock your files (prevents conflicts with the other parallel agent):`,
-          `  claim_files(taskId="${taskId}", files=[${filesArg}])`,
-          ``,
-          `**Step 3** — Get full context:`,
-          `  get_agent_context(taskId="${taskId}", role="${st.role || 'builder'}")`,
-          ``,
-          `**Step 4** — Implement the subtask`,
-          `  Modify ONLY your claimed files listed above.`,
-          `  Do NOT read or write files owned by another builder.`,
-          ``,
-          `**Step 5** — Verify`,
-          `  Run \`npm test\` — all tests must pass before committing.`,
-          ``,
-          `**Step 6** — Commit`,
-          `  commit_helper(taskId="${taskId}")`,
-          ``,
-          `**Step 7** — Mark done`,
-          `  Call update_task to tick the subtask checkbox for "${st.title}"`,
-          ``,
-          `⚠️  You are 1 of ${parallelCount} parallel builders. Another agent is working simultaneously on different files.`,
-          `   Conflict prevention: claim_files will BLOCK you if another agent has already claimed your files.`,
+          `You are builder ${i + 1} of ${parallelCount} running in parallel. Another builder is working on different files at the same time.`,
         ].join('\n')
 
         return { subtask: st.title, role: st.role || 'builder', files: st.files || [], prompt }
       })
 
+      // Write each builder prompt as a Cursor Background Agent file in .cursor/agents/
+      // Cursor Background Agents panel reads these files and lets you start each one independently.
+      const repoRoot = process.cwd()
+      const agentsDir = join(repoRoot, '.cursor', 'agents')
+      mkdirSync(agentsDir, { recursive: true })
+
+      const writtenFiles = []
+      kickoffs.forEach((k, i) => {
+        const safeName = k.subtask.replace(/[^a-zA-Z0-9-_]/g, '-').replace(/-+/g, '-').slice(0, 40)
+        const fileName = `builder-${i + 1}-${safeName}.md`
+        const filePath = join(agentsDir, fileName)
+
+        const agentFileContent = [
+          `---`,
+          `description: Builder ${i + 1} of ${parallelCount} — ${k.subtask} (${task.key})`,
+          `---`,
+          ``,
+          k.prompt,
+        ].join('\n')
+
+        writeFileSync(filePath, agentFileContent, 'utf8')
+        writtenFiles.push({ index: i + 1, file: `.cursor/agents/${fileName}`, subtask: k.subtask })
+      })
+
       // Build the human-facing instruction block
-      const howToOpen = [
-        `In Cursor, open ${parallelCount} new Agent windows:`,
-        `  • Mac:     Cmd+Shift+P → "New Agent" (or click "+" in the Composer panel)`,
-        `  • Windows: Ctrl+Shift+P → "New Agent"`,
+      const howToStart = [
+        `✅ ${parallelCount} builder agent file(s) written to .cursor/agents/`,
         ``,
-        ...kickoffs.map((k, i) => `Window ${i + 1}: paste the prompt for subtask "${k.subtask}"`),
+        `TO START PARALLEL BUILDERS IN CURSOR:`,
+        `  1. Open Background Agents panel: ⌘⇧J  (or ⌘⇧P → "Background Agents")`,
+        `  2. You'll see ${parallelCount} new builder agent(s) listed`,
+        `  3. Click "Start" for each one — they run in parallel automatically`,
         ``,
-        `Each window will independently call kickoff_task → claim_files → implement → commit.`,
-        `They run at the same time — you don't need to wait for one to finish before starting the other.`,
+        ...writtenFiles.map(f => `  • Builder ${f.index}: "${f.subtask}"  →  ${f.file}`),
         ``,
-        `After BOTH windows finish and commit, come back to this coordinator window and call:`,
-        `  get_parallel_kickoffs(taskId="${taskId}")`,
+        `Each builder calls kickoff_task → claim_files → implements → runs tests → commits.`,
+        `They work on different files simultaneously — no need to wait for one before starting the other.`,
+        ``,
+        `After all builders finish, come back here and call get_parallel_kickoffs again`,
         `to get the next group's prompts.`,
       ].join('\n')
 
@@ -1687,17 +1697,11 @@ the human opens the windows. Each builder agent then runs independently.`,
         totalGroups:   execOrder.length,
         isParallel,
         parallelCount,
-        READ_THIS_FIRST: '👇 READ THIS BEFORE DOING ANYTHING',
+        READ_THIS_FIRST: '⚡ BUILDER AGENT FILES WRITTEN — SEE INSTRUCTIONS BELOW',
         COORDINATOR_INSTRUCTION: isParallel
-          ? `⚡ GROUP ${nextGroupIndex} of ${execOrder.length}: ${parallelCount} subtasks run IN PARALLEL.\n\n${howToOpen}`
-          : `GROUP ${nextGroupIndex} of ${execOrder.length}: 1 sequential subtask.\nOpen 1 new Agent window and paste the prompt below.`,
-        kickoffs: kickoffs.map((k, i) => ({
-          window:  i + 1,
-          subtask: k.subtask,
-          role:    k.role,
-          files:   k.files,
-          PASTE_THIS_IN_NEW_AGENT_WINDOW: k.prompt,
-        })),
+          ? `⚡ GROUP ${nextGroupIndex} of ${execOrder.length}: ${parallelCount} builders written as Cursor Background Agents.\n\n${howToStart}`
+          : `GROUP ${nextGroupIndex} of ${execOrder.length}: 1 sequential builder written as a Cursor Background Agent.\n\n${howToStart}`,
+        agentFilesWritten: writtenFiles,
       })
     }
   )
@@ -3024,11 +3028,18 @@ You are a COORDINATOR agent. Your behavioral constraints for this session:
 - Bypass the decomposition step — always decompose before builders start
 - Start coding without a scout report when the codebase is unfamiliar
 
+**PARALLEL BUILDER WORKFLOW:**
+1. Call decompose_task — creates subtasks with file ownership
+2. Call get_parallel_kickoffs — writes .cursor/agents/builder-N.md files automatically
+3. Tell the user: "Open Background Agents panel (⌘⇧J) and click Start for each builder"
+4. Wait for builders to finish, then call get_parallel_kickoffs again for the next group
+
 **WORK STYLE:**
 - Start with decompose_task to get the structured execution plan
 - Ensure no two builder subtasks claim the same file
 - Scout report must exist before builders begin
-- Each builder subtask must have explicit file ownership and a clear scope`,
+- Each builder subtask must have explicit file ownership and a clear scope
+- NEVER implement code yourself — your job ends after get_parallel_kickoffs writes the agent files`,
 }
 
 /** Write task-specific cursor rules to .cursor/rules/<taskKey>.mdc in the local repo root.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "internaltool-mcp",
-  "version": "1.6.28",
+  "version": "1.6.30",
   "description": "MCP server for InternalTool — connect AI assistants (Claude Code, Cursor) to your project and task management platform",
   "type": "module",
   "main": "index.js",