internaltool-mcp 1.6.27 → 1.6.28

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
-          ? `Start with parallel group 1: ${parallelGroups[0].join(', ')}. Each builder agent should call kickoff_task with agentRole="builder" and claim_files before coding.`
-          : 'Start the subtasks in order. Each builder should call kickoff_task with agentRole="builder" and claim_files.',
+          ? `⚡ 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.`,
       })
     }
   )
@@ -1618,41 +1618,86 @@ the human opens the windows. Each builder agent then runs independently.`,
         })
       }
 
-      // Build one ready-to-paste prompt per pending subtask in this group
+      // Build one ready-to-paste prompt per pending subtask in this group.
+      // These prompts are designed to be pasted verbatim into a NEW Cursor Agent window.
+      // They begin with explicit MCP calls so the agent has no ambiguity about what to do first.
       const kickoffs = pendingInGroup.map((subtaskTitle, i) => {
         const st = subtasks.find(s => s.title === subtaskTitle) || { title: subtaskTitle, role: 'builder', files: [], description: '' }
-        const fileList = (st.files || []).map(f => `  - ${f}`).join('\n')
+        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
         const prompt = [
-          `You are a ${st.role || 'builder'} agent for TASK-011 (${task.key}).`,
+          `## Builder Agent — ${task.key} · Subtask ${i + 1} of ${parallelCount}`,
+          ``,
+          `**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 THIS NOW — in order, no skipping:`,
+          ``,
+          `**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'}")`,
           ``,
-          `## Your subtask (${i + 1} of ${parallelCount} running in parallel)`,
-          `**Title:** ${st.title}`,
-          `**Description:** ${st.description || ''}`,
-          `**Your files:**`,
-          fileList || '  (to be determined)',
+          `**Step 4** — Implement the subtask`,
+          `  Modify ONLY your claimed files listed above.`,
+          `  Do NOT read or write files owned by another builder.`,
           ``,
-          `## Steps`,
-          `1. Call \`get_agent_context\` with taskId \`${taskId}\``,
-          `2. Call \`claim_files\` with taskId \`${taskId}\` and files: [${(st.files || []).map(f => `"${f}"`).join(', ')}]`,
-          `3. Implement the subtask — only modify your claimed files`,
-          `4. Run tests to verify nothing is broken`,
-          `5. Commit your changes with a clear message referencing ${task.key}`,
-          `6. Mark the subtask done in InternalTool by calling \`update_task\` to tick off "${st.title}" in the subtasks list`,
+          `**Step 5** — Verify`,
+          `  Run \`npm test\` — all tests must pass before committing.`,
           ``,
-          `Do NOT touch files owned by other parallel agents.`,
+          `**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.`,
         ].join('\n')
-        return { subtask: st.title, role: st.role, files: st.files, prompt }
+
+        return { subtask: st.title, role: st.role || 'builder', files: st.files || [], prompt }
       })
 
+      // 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"`,
+        ``,
+        ...kickoffs.map((k, i) => `Window ${i + 1}: paste the prompt for subtask "${k.subtask}"`),
+        ``,
+        `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.`,
+        ``,
+        `After BOTH windows finish and commit, come back to this coordinator window and call:`,
+        `  get_parallel_kickoffs(taskId="${taskId}")`,
+        `to get the next group's prompts.`,
+      ].join('\n')
+
       return text({
         group:         nextGroupIndex,
         totalGroups:   execOrder.length,
         isParallel,
         parallelCount,
-        instruction: isParallel
-          ? `⚡ GROUP ${nextGroupIndex} runs ${parallelCount} subtasks IN PARALLEL.\n\nTell the user:\n"Please open ${parallelCount} new Cursor Agent windows (Cmd+Shift+P → New Agent Session or open a new Composer tab set to Agent mode).\nPaste prompt 1 in window 1, prompt 2 in window 2. They will run independently."`
-          : `GROUP ${nextGroupIndex} has 1 sequential subtask. Paste the prompt below in a new Agent window (or handle it yourself).`,
-        kickoffs,
+        READ_THIS_FIRST: '👇 READ THIS BEFORE DOING ANYTHING',
+        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,
+        })),
       })
     }
   )
@@ -2418,8 +2463,11 @@ Use this when a developer says "start task", "brief me on", or "what do I need t
       }
 
       // Dynamically generate .cursor/agents, .cursor/skills, .cursor/commands
-      // based on live task data — so every agent gets the right task ID, files, and role
-      const workspaceResult = writeCursorWorkspace(task, projectAgentConfig, repoPath || process.cwd())
+      // based on live task data — so every agent gets the right task ID, files, and role.
+      // IMPORTANT: inject the NEW agentRole from this kickoff call (not the stale task.agentRole)
+      // so active-agent.md reflects the role being kicked off, not the previous session's role.
+      const taskForWorkspace = agentRole ? { ...task, agentRole } : task
+      const workspaceResult = writeCursorWorkspace(taskForWorkspace, projectAgentConfig, repoPath || process.cwd())
 
       // Persist agentRole + workspace status to server
       const workspacePatch = {

package/package.json

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