internaltool-mcp 1.6.26 → 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 = {
@@ -3782,6 +3830,7 @@ If you have uncommitted tracked changes, it will tell you exactly what to do bef
       if (scopedProjectId && projectId !== scopedProjectId) {
         return errorText(`Access denied: session is scoped to project ${scopedProjectId}`)
       }
+      trackTaskActivity(taskId, 'create_branch', { summary: confirmed ? 'Branch created on GitHub' : 'Branch creation preview' })
 
       const taskRes = await api.get(`/api/tasks/${taskId}`)
       if (!taskRes?.success) return errorText('Task not found')
@@ -4045,6 +4094,7 @@ Set confirmed=false first to preview, then confirmed=true to park the task.`,
       confirmed: z.boolean().optional().default(false).describe('Set true to park the task after reviewing the preview'),
     },
     async ({ taskId, summary = '', reason = '', confirmed = false }) => {
+      trackTaskActivity(taskId, 'stash_changes', { summary: confirmed ? 'Task parked + stash instructions provided' : 'Stash preview' })
       const taskRes = await api.get(`/api/tasks/${taskId}`)
       const task    = taskRes?.data?.task
 
@@ -4104,6 +4154,7 @@ Set confirmed=false first to review the park note, then confirmed=true to unpark
       confirmed:  z.boolean().optional().default(false).describe('Set true to unpark the task after reviewing'),
     },
     async ({ taskId, stashIndex = 0, confirmed = false }) => {
+      trackTaskActivity(taskId, 'pop_stash', { summary: confirmed ? `Stash[${stashIndex}] popped + task unparked` : 'Pop stash preview' })
       const taskRes = await api.get(`/api/tasks/${taskId}`)
       if (!taskRes?.success) return errorText('Task not found')
       const task = taskRes.data.task
@@ -4160,6 +4211,8 @@ Set confirmed=false first to preview the full plan, then confirmed=true to save
       confirmed:     z.boolean().optional().default(false).describe('Set true to park Task B and get the full command sequence'),
     },
     async ({ taskAId, taskBId, confirmed = false }) => {
+      trackTaskActivity(taskAId, 'fix_pr_feedback', { summary: confirmed ? 'PR feedback fix plan confirmed' : 'PR feedback fix preview' })
+      if (taskBId) trackTaskActivity(taskBId, 'fix_pr_feedback', { summary: 'Paused to fix PR feedback on another task' })
       const taskARes = await api.get(`/api/tasks/${taskAId}`)
       if (!taskARes?.success) return errorText('Task A not found')
       const taskA = taskARes.data.task
@@ -4259,6 +4312,7 @@ Set confirmed=false first to preview the full PR content, then confirmed=true to
       if (scopedProjectId && projectId !== scopedProjectId) {
         return errorText(`Access denied: session is scoped to project ${scopedProjectId}`)
       }
+      trackTaskActivity(taskId, 'raise_pr', { summary: confirmed ? `PR raised: ${headBranch}${draft ? ' (draft)' : ''}` : 'PR preview' })
 
       let taskRes
       try { taskRes = await apiWithRetry(() => api.get(`/api/tasks/${taskId}`)) }
@@ -4404,6 +4458,7 @@ branchAction values (only needed when current branch ≠ task branch):
                      .describe('Required when confirmed=true and current branch ≠ task branch'),
     },
     async ({ taskId, repoPath, confirmed = false, branchAction }) => {
+      if (taskId) trackTaskActivity(taskId, 'commit_helper', { summary: confirmed ? 'Commit command generated' : 'Commit preview' })
       const cwd = repoPath || process.cwd()
 
       // ── Read local git state ──────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "internaltool-mcp",
-  "version": "1.6.26",
+  "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",