internaltool-mcp 1.6.24 → 1.6.26

package/index.js

@@ -391,11 +391,16 @@ Set confirmed=false first to preview, then confirmed=true to execute everything.
       // ── Save park note + server-side comment & notifications ──────────────
       await api.patch(`/api/tasks/${taskId}/park`, { summary, remaining, blockers })
 
-      // ── Delete cursor rules file ───────────────────────────────────────────
+      // ── Delete cursor rules file + task-scoped workspace files ───────────────
       let cursorRulesCleared = null
       if (task?.cursorRules?.trim()) {
         cursorRulesCleared = deleteCursorRulesFile(task.key, repoPath)
       }
+      deleteCursorWorkspace(task?.agentRole || null, repoPath)
+      // Mark workspace as cleared in DB so UI shows "not active"
+      api.patch(`/api/tasks/${taskId}`, {
+        agentWorkspace: { clearedAt: new Date().toISOString() }
+      }).catch(() => {/* non-fatal */})
 
       // ── #9 Capture last commit for handoff metadata ───────────────────────
       const lastCommit = getLastCommitMeta(repoRoot)
@@ -438,6 +443,7 @@ Set confirmed=false first to read everything, then confirmed=true to execute.`,
         .describe('Set the agent role for this task session. Role-specific behavioral constraints are injected into cursor rules.'),
     },
     async ({ taskId, confirmed = false, repoPath, autoStash = false, agentRole }) => {
+      trackTaskActivity(taskId, 'unpark_task')
       const taskRes = await api.get(`/api/tasks/${taskId}`)
       const task    = taskRes?.data?.task
       const branch  = task?.github?.headBranch || null
@@ -613,6 +619,7 @@ Roles: BUILDER agents MUST call this before editing. Coordinators call this as p
       files:  z.array(z.string()).min(1).describe('List of file paths this task will exclusively edit (e.g. ["server/routes/tasks.js", "client/src/App.jsx"])'),
     },
     async ({ taskId, files }) => {
+      trackTaskActivity(taskId, 'claim_files')
       const res = await api.post(`/api/tasks/${taskId}/files/claim`, { files })
       if (!res?.success) {
         if (res?.conflicts) {
@@ -693,6 +700,7 @@ Call confirmed=false to preview the decomposition, confirmed=true to save it.`,
       confirmed:     z.boolean().optional().default(false).describe('Set true to save the decomposition and create subtasks on the board'),
     },
     async ({ taskId, subtaskPlan, confirmed = false }) => {
+      trackTaskActivity(taskId, 'decompose_task')
       const taskRes = await apiWithRetry(() => api.get(`/api/tasks/${taskId}`))
       if (!taskRes?.success) return errorText('Task not found')
       const task = taskRes.data.task
@@ -820,6 +828,7 @@ Scouts MUST NOT modify any source code files or create branches.`,
       report:    z.string().optional().default('').describe('Your structured scout findings in markdown (required when confirmed=true)'),
     },
     async ({ taskId, confirmed = false, report = '' }) => {
+      trackTaskActivity(taskId, 'scout_task')
       const taskRes = await apiWithRetry(() => api.get(`/api/tasks/${taskId}`))
       if (!taskRes?.success) return errorText('Task not found')
       const task = taskRes.data.task
@@ -891,6 +900,7 @@ Returns systemPrompt ready to use as a Claude system prompt.`,
         .describe('Agent role for this session. Falls back to task.agentRole if omitted.'),
     },
     async ({ taskId, role }) => {
+      trackTaskActivity(taskId, 'get_agent_context')
       const qs = role ? `?role=${role}` : ''
       const res = await apiWithRetry(() => api.get(`/api/tasks/${taskId}/agent-context${qs}`))
       if (!res?.success) return errorText(res?.message || 'Failed to get agent context')
@@ -1500,6 +1510,152 @@ Flow:
       })
     }
   )
+
+  // ── log_session_event ─────────────────────────────────────────────────────────
+  server.tool(
+    'log_session_event',
+    `Log a skill invocation, subagent start, rule activation, or informational note to the task's session timeline.
+Call this whenever you:
+  - Invoke a skill (type="skill", name=skill file name e.g. "scout-codebase")
+  - Spawn a subagent (type="subagent", name=subagent name)
+  - Activate a rule (type="rule", name=rule name)
+  - Want to note a significant step (type="info", name=short label)
+The log is visible in InternalTool under the task's Session tab — gives the human full visibility into what the agent is doing.`,
+    {
+      taskId:  z.string().describe("Task's MongoDB ObjectId"),
+      type:    z.enum(['skill', 'subagent', 'rule', 'info']).describe('Event type'),
+      name:    z.string().describe('Name of the skill / subagent / rule / step'),
+      summary: z.string().optional().default('').describe('Optional one-line description of what this event does'),
+      role:    z.string().optional().describe('Active agent role at this point (builder, scout, reviewer, coordinator)'),
+    },
+    async ({ taskId, type, name, summary = '', role }) => {
+      trackTaskActivity(taskId, 'log_session_event', { role, summary: `[${type}] ${name}` })
+      // Also push a dedicated entry with the correct event type
+      api.post(`/api/tasks/${taskId}/session/log`, {
+        type, name, role: role || null, summary,
+      }).catch(() => {})
+      return text({ logged: true, type, name, summary })
+    }
+  )
+
+  // ── 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.
+
+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
+
+Cursor cannot spawn agent windows automatically. This tool generates the prompts;
+the human opens the windows. Each builder agent then runs independently.`,
+    {
+      taskId: z.string().describe("Task's MongoDB ObjectId"),
+    },
+    async ({ taskId }) => {
+      trackTaskActivity(taskId, 'get_parallel_kickoffs')
+      const taskRes = await apiWithRetry(() => api.get(`/api/tasks/${taskId}`))
+      if (!taskRes?.success) return errorText('Task not found')
+      const task = taskRes.data.task
+
+      if (!task.decomposition?.trim()) {
+        return text({
+          error: true,
+          message: 'No decomposition plan found. Call decompose_task first to break the task into subtasks.',
+        })
+      }
+
+      let dec
+      try { dec = JSON.parse(task.decomposition) } catch {
+        return errorText('Decomposition JSON is malformed — call decompose_task again.')
+      }
+
+      const subtasks   = dec.subtasks || []
+      const execOrder  = dec.executionOrder || []
+
+      // Determine which group to run next: first group that has at least one
+      // subtask not yet reflected in the board subtasks as done.
+      const boardSubtasks = task.subtasks || []
+      // Board subtask titles may carry a role prefix like "[BUILDER] Auth hardening..."
+      // Match on bare title OR prefixed title
+      const isDone = (title) => boardSubtasks.some(s => s.done && (s.title === title || s.title.endsWith(title)))
+
+      let nextGroup = null
+      let nextGroupIndex = -1
+      for (let i = 0; i < execOrder.length; i++) {
+        const group = execOrder[i]
+        const allDone = group.every(t => isDone(t))
+        if (!allDone) {
+          // Also check all prior groups are fully done (respects dependsOn)
+          const priorAllDone = execOrder.slice(0, i).every(g => g.every(t => isDone(t)))
+          if (priorAllDone) {
+            nextGroup = group
+            nextGroupIndex = i + 1
+            break
+          }
+        }
+      }
+
+      if (!nextGroup) {
+        return text({
+          allDone: true,
+          message: 'All subtask groups are complete. Move to the final review or run coverage tests.',
+        })
+      }
+
+      // Only kick off subtasks that aren't done yet
+      const pendingInGroup = nextGroup.filter(t => !isDone(t))
+      const parallelCount  = pendingInGroup.length
+      const isParallel     = parallelCount > 1
+
+      if (parallelCount === 0) {
+        return text({
+          group: nextGroupIndex,
+          allDone: true,
+          message: `All subtasks in Group ${nextGroupIndex} are already done. Call get_parallel_kickoffs again to get the next group.`,
+        })
+      }
+
+      // Build one ready-to-paste prompt per pending subtask in this group
+      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 prompt = [
+          `You are a ${st.role || 'builder'} agent for TASK-011 (${task.key}).`,
+          ``,
+          `## Your subtask (${i + 1} of ${parallelCount} running in parallel)`,
+          `**Title:** ${st.title}`,
+          `**Description:** ${st.description || ''}`,
+          `**Your files:**`,
+          fileList || '  (to be determined)',
+          ``,
+          `## 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`,
+          ``,
+          `Do NOT touch files owned by other parallel agents.`,
+        ].join('\n')
+        return { subtask: st.title, role: st.role, files: st.files, prompt }
+      })
+
+      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,
+      })
+    }
+  )
 }
 
 // ── Standup activity formatter ────────────────────────────────────────────────
@@ -1998,6 +2154,7 @@ Use this when a developer says "start task", "brief me on", or "what do I need t
         .describe('Set the agent role for this task session. Role-specific behavioral constraints are injected into cursor rules. builder=implements code, scout=reads/analyzes only, reviewer=reviews PRs only, coordinator=decomposes work.'),
     },
     async ({ taskId, confirmed = false, repoPath, agentRole }) => {
+      trackTaskActivity(taskId, 'kickoff_task')
       const taskRes = await api.get(`/api/tasks/${taskId}`)
       if (!taskRes?.success) return errorText('Task not found')
       const task = taskRes.data.task
@@ -2028,6 +2185,7 @@ Use this when a developer says "start task", "brief me on", or "what do I need t
       // ── Preview: show the full plan before touching anything ──
       const pendingApv = (task.approvals || []).find(a => a.state === 'pending') || null
       const hasApprovedApv = (task.approvals || []).some(a => a.state === 'approved')
+      const approvalState = pendingApv ? 'pending' : hasApprovedApv ? 'approved' : 'none'
       const approvalBlocks = ['backlog', 'todo'].includes(task.column) && !hasApprovedApv
 
       // Build the next-step roadmap so developer knows exactly what comes after reading the plan
@@ -2227,11 +2385,18 @@ Use this when a developer says "start task", "brief me on", or "what do I need t
 
       // ── Confirmed: move to in_progress and fetch recent commits ──
       let recentCommits = []
+      let projectAgentConfig = null
       try {
         const commitsRes = await api.get(`/api/projects/${task.project}/github/commits?per_page=10`)
         if (commitsRes?.success) recentCommits = commitsRes.data.commits || []
       } catch { /* GitHub may not be linked */ }
 
+      // Fetch project agentConfig for custom role generation
+      try {
+        const projRes = await api.get(`/api/projects/${task.project}`)
+        if (projRes?.success) projectAgentConfig = projRes.data.project?.agentConfig || null
+      } catch { /* non-fatal */ }
+
       // If the task already has a branch linked, it's safe to move to in_progress now.
       // If not, create_branch will do the move once the branch is created.
       const alreadyHasBranch = !!task.github?.headBranch
@@ -2252,10 +2417,21 @@ Use this when a developer says "start task", "brief me on", or "what do I need t
         cursorRulesFile = writeCursorRulesFile(task.key, '(No task-specific rules — follow role constraints above.)', repoPath, agentRole)
       }
 
-      // Persist agentRole to server so board shows the active role
-      if (agentRole) {
-        api.patch(`/api/tasks/${taskId}`, { agentRole }).catch(() => {/* non-fatal */})
+      // 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())
+
+      // Persist agentRole + workspace status to server
+      const workspacePatch = {
+        ...(agentRole ? { agentRole } : {}),
+        agentWorkspace: {
+          kickedOffAt: new Date().toISOString(),
+          clearedAt:   null,
+          role:        agentRole || task.agentRole || null,
+          files:       workspaceResult?.written?.map(f => f.replace(workspaceResult.repoRoot, '').replace(/^\//, '')) || [],
+        },
       }
+      api.patch(`/api/tasks/${taskId}`, workspacePatch).catch(() => {/* non-fatal */})
 
       return text({
         started: {
@@ -2282,6 +2458,9 @@ Use this when a developer says "start task", "brief me on", or "what do I need t
         cursorRulesFile: cursorRulesFile
           ? { written: true, path: cursorRulesFile, note: 'Rules file written to your repo. Cursor enforces it automatically on every prompt.' }
           : (hasCursorRules || agentRole) ? { written: false, note: 'Could not write rules file — not inside a git repo.' } : null,
+        cursorWorkspace: workspaceResult
+          ? { written: true, files: workspaceResult.written.map(f => f.replace(workspaceResult.repoRoot, '')), note: 'Agent, skill, and command files generated dynamically from task data. Reload Cursor Settings → Rules, Skills, Subagents to see them.' }
+          : { written: false, note: 'Could not generate workspace files — not inside a git repo.' },
         recentCommits: recentCommits.slice(0, 5).map(c => ({
           sha:     c.sha?.slice(0, 7),
           message: c.commit?.message?.split('\n')[0],
@@ -2824,6 +3003,202 @@ function writeCursorRulesFile(taskKey, rulesMarkdown, startPath, role = null) {
   }
 }
 
+/**
+ * Dynamically generate .cursor/ workspace files from live InternalTool data.
+ *
+ * Sources (in priority order):
+ *  1. project.agentConfig.subagents[]  → .cursor/agents/<name>.md
+ *  2. project.agentConfig.skills[]     → .cursor/skills/<name>.md
+ *  3. project.agentConfig.rules[]      → .cursor/rules/<name>.mdc  (project-level, alwaysApply)
+ *  4. Built-in ROLE_RULES / default skill templates (fallback when DB arrays are empty)
+ *
+ * Task-specific agent file (.cursor/agents/active-agent.md) is always written
+ * from the task's role + claimed files + task ID so Cursor knows exactly what to do.
+ * It is deleted by deleteCursorWorkspace() when the task is parked or completed.
+ */
+function writeCursorWorkspace(task, projectAgentConfig, startPath) {
+  try {
+    const repoRoot = findRepoRoot(startPath)
+    if (!repoRoot) return null
+
+    const role         = task.agentRole || null
+    const taskId       = String(task._id)
+    const taskKey      = task.key || 'TASK-???'
+    const taskTitle    = task.title || ''
+    const claimedFiles = task.claimedFiles || []
+    const hasScout     = !!(task.scoutReport?.trim())
+    const hasDec       = !!(task.decomposition?.trim())
+    const cfg          = projectAgentConfig || {}
+
+    const agentsDir   = join(repoRoot, '.cursor', 'agents')
+    const skillsDir   = join(repoRoot, '.cursor', 'skills')
+    const commandsDir = join(repoRoot, '.cursor', 'commands')
+    const rulesDir    = join(repoRoot, '.cursor', 'rules')
+    mkdirSync(agentsDir,   { recursive: true })
+    mkdirSync(skillsDir,   { recursive: true })
+    mkdirSync(commandsDir, { recursive: true })
+    mkdirSync(rulesDir,    { recursive: true })
+
+    const written = []
+
+    // ── 1. Project-level rules from DB → .cursor/rules/<name>.mdc ─────────────
+    const projectRules = cfg.rules || []
+    for (const r of projectRules) {
+      if (!r.name || !r.body) continue
+      const content = `---\ndescription: ${r.description || r.name} — project rule managed in InternalTool. Do not edit manually.\nalwaysApply: ${r.alwaysApply ? 'true' : 'false'}\n---\n\n${r.body}\n`
+      const f = join(rulesDir, `${r.name}.mdc`)
+      writeFileSync(f, content, 'utf8')
+      written.push(f)
+    }
+
+    // ── 2. Subagents from DB → .cursor/agents/<name>.md ───────────────────────
+    //    If DB has subagents defined, write them verbatim (admin-authored markdown)
+    const dbSubagents = cfg.subagents || []
+    for (const s of dbSubagents) {
+      if (!s.name || !s.body) continue
+      const header = `---\nname: ${s.name}\ndescription: ${s.description || s.name}\n---\n\n`
+      const f = join(agentsDir, `${s.name}.md`)
+      writeFileSync(f, header + s.body, 'utf8')
+      written.push(f)
+    }
+
+    // ── 3. Task-specific active-agent.md — always written, deleted on done ────
+    //    Uses DB subagent body as template if one matches the role; falls back to
+    //    built-in ROLE_RULES template with task-specific data injected.
+    if (role) {
+      const dbMatch = dbSubagents.find(s => s.name === `${role}-agent` || s.name === role)
+      let agentBody
+      if (dbMatch?.body) {
+        // Admin wrote a custom body — inject task data into placeholder tokens
+        agentBody = dbMatch.body
+          .replace(/\{\{taskId\}\}/g, taskId)
+          .replace(/\{\{taskKey\}\}/g, taskKey)
+          .replace(/\{\{taskTitle\}\}/g, taskTitle)
+          .replace(/\{\{claimedFiles\}\}/g, claimedFiles.map(f => `- \`${f}\``).join('\n') || '(none)')
+      } else {
+        // Built-in fallback template
+        const fileLine = claimedFiles.length
+          ? claimedFiles.map(f => `- \`${f}\``).join('\n')
+          : '- (no files claimed yet — call claim_files first)'
+        const scoutLine = hasScout ? '✅ Scout report available — call `get_agent_context` to read it.' : '⚠️  No scout report yet.'
+        const decLine   = hasDec   ? '✅ Execution plan exists — follow the decomposition order.' : ''
+
+        const BUILT_IN = {
+          scout: `# Scout Agent — ${taskKey}\n\n**Task ID:** \`${taskId}\`\n**Task:** ${taskTitle}\n\n## Constraints\n- READ ONLY — do not write or modify any file\n- You CAN read files, run tests, and use MCP tools\n\n## Workflow\n1. Call \`get_agent_context\` with taskId \`${taskId}\`\n2. Read every source file systematically\n3. Call \`scout_task\` with confirmed=false, then confirmed=true + your report\n`,
+          builder: `# Builder Agent — ${taskKey}\n\n**Task ID:** \`${taskId}\`\n**Task:** ${taskTitle}\n\n**Claimed files:**\n${fileLine}\n\n${scoutLine}\n${decLine}\n\n## Constraints\n- Only modify your claimed files\n- Every change needs a test update\n- Run tests before marking done\n\n## Workflow\n1. Call \`get_agent_context\` with taskId \`${taskId}\`\n2. Implement the feature\n3. Use the \`run-tests\` skill to verify\n4. Call \`commit_helper\` then \`raise_pr\`\n`,
+          coordinator: `# Coordinator Agent — ${taskKey}\n\n**Task ID:** \`${taskId}\`\n**Task:** ${taskTitle}\n\n## Constraints\n- Do NOT write code — plan and delegate only\n- Each subtask must have exclusive file ownership\n- Cursor CANNOT auto-spawn agents — you generate prompts, the human opens windows\n\n## Workflow\n1. Call \`get_agent_context\` with taskId \`${taskId}\` to read the scout report\n2. Call \`decompose_task\` with taskId \`${taskId}\` to break work into parallel groups\n3. Call \`get_parallel_kickoffs\` with taskId \`${taskId}\` — this returns one ready-to-paste prompt per parallel subtask\n4. Tell the user exactly:\n   - How many new Cursor Agent windows to open\n   - Which prompt to paste in each window (copy verbatim from the kickoffs output)\n5. After all groups in a parallel batch are done, call \`get_parallel_kickoffs\` again for the next group\n\n## Important\nParallel = multiple Cursor Agent windows open at the same time.\nEach window is an independent builder — it claims its own files, implements, commits.\nYou (coordinator) do not implement anything — only plan and hand off.\n`,
+          reviewer: `# Reviewer Agent — ${taskKey}\n\n**Task ID:** \`${taskId}\`\n**Task:** ${taskTitle}\n\n## Constraints\n- Read the full diff before approving\n- Post specific, file-level comments\n\n## Workflow\n1. Call \`get_agent_context\` with taskId \`${taskId}\`\n2. Call \`review_pr\` to fetch the diff\n3. Call \`post_pr_review\` with your verdict\n`,
+        }
+        agentBody = BUILT_IN[role] || `# ${role} Agent — ${taskKey}\n\n**Task ID:** \`${taskId}\`\n**Task:** ${taskTitle}\n`
+      }
+
+      const activeAgentContent = `---\nname: active-agent\ndescription: ${role} agent for ${taskKey} — auto-generated by InternalTool MCP on kickoff. Deleted when task is parked or done.\n---\n\n${agentBody}`
+      writeFileSync(join(agentsDir, 'active-agent.md'), activeAgentContent, 'utf8')
+      written.push(join(agentsDir, 'active-agent.md'))
+    }
+
+    // ── 4. Custom role agents from project.agentConfig.roles (non-subagent) ───
+    for (const cr of (cfg.roles || [])) {
+      if (!cr.name || dbSubagents.some(s => s.name === `${cr.name}-agent`)) continue
+      const content = `---\nname: ${cr.name}-agent\ndescription: ${cr.label || cr.name}${cr.promptHint ? ' — ' + cr.promptHint.slice(0, 80) : ''}\n---\n\n# ${cr.label || cr.name} Agent\n\n**Role:** \`${cr.name}\`\n${cr.promptHint ? `\n## Instructions\n${cr.promptHint}\n` : ''}${cr.allowedTools?.length ? `\n## Allowed tools\n${cr.allowedTools.map(t => `- ${t}`).join('\n')}\n` : ''}`
+      const f = join(agentsDir, `${cr.name}-agent.md`)
+      writeFileSync(f, content, 'utf8')
+      written.push(f)
+    }
+
+    // ── 5. Skills from DB → .cursor/skills/<name>.md ──────────────────────────
+    //    If DB is empty, write built-in defaults so Cursor always has something useful.
+    const dbSkills = cfg.skills || []
+    if (dbSkills.length > 0) {
+      for (const s of dbSkills) {
+        if (!s.name || !s.body) continue
+        const header = `---\nname: ${s.name}\ndescription: ${s.description || s.name}\n---\n\n`
+        const f = join(skillsDir, `${s.name}.md`)
+        writeFileSync(f, header + s.body, 'utf8')
+        written.push(f)
+      }
+    } else {
+      // Built-in default skills
+      const defaults = [
+        {
+          name: 'scout-codebase',
+          description: 'Read every source file and save a scout report to InternalTool.',
+          body: `1. Read all source files: routes, models, middleware, utils, tests, README, .cursorrules\n2. Write a report: Auth Flow, Data Model, API Surface, Utilities, Test Coverage, Gaps & Risks\n3. Call \`scout_task\` with taskId \`${taskId}\` confirmed=false (preview), then confirmed=true + report\n\n**READ ONLY — do not modify any file.**`,
+        },
+        {
+          name: 'run-tests',
+          description: 'Run the test suite and fix any failures before marking done.',
+          body: `1. Run \`npm test\`\n2. Report: passed / failed / skipped\n3. For each failure: identify root cause, fix source (not the test)\n4. Re-run until 0 failures\n5. Do NOT mark done until tests are green`,
+        },
+      ]
+      for (const s of defaults) {
+        const content = `---\nname: ${s.name}\ndescription: ${s.description}\n---\n\n${s.body}\n`
+        const f = join(skillsDir, `${s.name}.md`)
+        writeFileSync(f, content, 'utf8')
+        written.push(f)
+      }
+    }
+
+    // ── 6. Command — start-task pre-filled with this task ─────────────────────
+    const startCmd = `---\nname: start-task\ndescription: Start a task from InternalTool — brief, role rules, moves to In Progress.\n---\n\nDefault task: \`${taskId}\` (${taskKey} — ${taskTitle})\n\n1. Ask the user to confirm the task ID or use the default above\n2. Call \`kickoff_task\` with confirmed=false to show the brief\n3. Present: role, description, claimedFiles, cursorRules\n4. Ask "Ready to confirm and move to In Progress?"\n5. If yes, call \`kickoff_task\` again with confirmed=true\n`
+    writeFileSync(join(commandsDir, 'start-task.md'), startCmd, 'utf8')
+    written.push(join(commandsDir, 'start-task.md'))
+
+    return { repoRoot, written }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Delete task-specific workspace files written at kickoff.
+ * Project-level rules (.cursor/rules/<project-rule>.mdc) and skills are kept.
+ * Only the active-agent and start-task command are removed (they are task-scoped).
+ */
+function deleteCursorWorkspace(role, startPath) {
+  const deleted = []
+  try {
+    const repoRoot = findRepoRoot(startPath)
+    if (!repoRoot) return deleted
+    const toDelete = [
+      join(repoRoot, '.cursor', 'agents', 'active-agent.md'),
+      join(repoRoot, '.cursor', 'commands', 'start-task.md'),
+    ]
+    for (const f of toDelete) {
+      try {
+        if (existsSync(f)) { unlinkSync(f); deleted.push(f) }
+      } catch { /* non-fatal */ }
+    }
+  } catch { /* non-fatal */ }
+  return deleted
+}
+
+/**
+ * Record that a specific MCP tool was called for a task.
+ * 1. Updates agentWorkspace.lastActivityAt + lastTool (fast summary for overview card)
+ * 2. Appends to agentSessionLog (the ordered call history shown in Session tab)
+ * Fire-and-forget: never blocks the tool response.
+ */
+function trackTaskActivity(taskId, toolName, opts = {}) {
+  if (!taskId) return
+  // Fast summary update
+  api.patch(`/api/tasks/${taskId}`, {
+    agentWorkspace: {
+      lastActivityAt: new Date().toISOString(),
+      lastTool:       toolName,
+      _incCallCount:  true,
+      ...(opts.role ? { role: opts.role } : {}),
+    },
+  }).catch(() => {})
+  // Ordered session log entry
+  api.post(`/api/tasks/${taskId}/session/log`, {
+    type:    'tool',
+    name:    toolName,
+    role:    opts.role    || null,
+    summary: opts.summary || '',
+  }).catch(() => {})
+}
+
 /** Delete the task-specific cursor rules file when work is complete. */
 function deleteCursorRulesFile(taskKey, startPath) {
   try {
@@ -3278,6 +3653,7 @@ Use this when returning to a task after a break, or when Claude needs the full p
       repoPath: z.string().optional().describe('Absolute path to the local git repo (defaults to MCP process working directory)'),
     },
     async ({ taskId, repoPath }) => {
+      trackTaskActivity(taskId, 'get_task_context')
       let taskRes, activityRes
       try {
         [taskRes, activityRes] = await Promise.all([
@@ -3414,7 +3790,9 @@ If you have uncommitted tracked changes, it will tell you exactly what to do bef
       // ── Approval gate check ───────────────────────────────────────────────────
       // The server blocks non-admins from moving todo → in_progress without approval.
       // Detect this early and guide the developer instead of failing silently after branch creation.
+      const pendingApv2 = (task.approvals || []).find(a => a.state === 'pending') || null
       const hasApprovedApv2 = (task.approvals || []).some(a => a.state === 'approved')
+      const approvalState = pendingApv2 ? 'pending' : hasApprovedApv2 ? 'approved' : 'none'
       const PLANNING_COLS = ['backlog', 'todo']
       const needsApproval = PLANNING_COLS.includes(task.column) && !hasApprovedApv2
       if (needsApproval && !confirmed) {

package/package.json

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