internaltool-mcp 1.6.27 → 1.6.29

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,71 @@ 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 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 = [
-          `You are a ${st.role || 'builder'} agent for TASK-011 (${task.key}).`,
+          `Use the InternalTool MCP tools to implement subtask "${st.title}" for task ${task.key}.`,
           ``,
-          `## Your subtask (${i + 1} of ${parallelCount} running in parallel)`,
-          `**Title:** ${st.title}`,
-          `**Description:** ${st.description || ''}`,
-          `**Your files:**`,
-          fileList || '  (to be determined)',
+          `Do these steps immediately in order — do not ask for confirmation, do not skip any step:`,
           ``,
-          `## 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`,
+          `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`,
           ``,
-          `Do NOT touch files owned by other parallel agents.`,
+          `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, 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 +2448,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.29",
   "description": "MCP server for InternalTool — connect AI assistants (Claude Code, Cursor) to your project and task management platform",
   "type": "module",
   "main": "index.js",