internaltool-mcp 1.6.29 → 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"),
     },
@@ -1651,19 +1650,45 @@ the human opens the windows. Each builder agent then runs independently.`,
         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/`,
+        ``,
+        `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`,
         ``,
-        ...kickoffs.map((k, i) => `Window ${i + 1}: paste the prompt for subtask "${k.subtask}"`),
+        ...writtenFiles.map(f => `  • Builder ${f.index}: "${f.subtask}"  →  ${f.file}`),
         ``,
-        `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.`,
+        `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 BOTH windows finish and commit, come back to this coordinator window and call:`,
-        `  get_parallel_kickoffs(taskId="${taskId}")`,
+        `After all builders finish, come back here and call get_parallel_kickoffs again`,
         `to get the next group's prompts.`,
       ].join('\n')
 
@@ -1672,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,
       })
     }
   )
@@ -3009,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.29",
+  "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",