@miphamai/cli 0.8.0 → 0.10.0

package/src/tools/exec/enter-worktree.ts

@@ -0,0 +1,142 @@
+import type { ToolDefinition } from '../../shared/index.ts'
+
+export const enterWorktreeTool: ToolDefinition = {
+  name: 'EnterWorktree',
+  description:
+    'Create an isolated git worktree for parallel development. ' +
+    'Creates a new worktree at .claude/worktrees/<name> on its own branch. ' +
+    'Use this when you need to work on a separate task without affecting the main workspace. ' +
+    'Pair with ExitWorktree to clean up when done.',
+  category: 'exec',
+  permission: 'ask',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+        description:
+          'Name for the new worktree. Each "/"-separated segment may contain only letters, digits, dots, underscores, and dashes; max 64 chars total.',
+      },
+      baseRef: {
+        type: 'string',
+        description:
+          'Base branch or ref to create from. Default: the current HEAD. Use "origin/main" or a branch name to start from a specific point.',
+      },
+    },
+    required: ['name'],
+  },
+  async execute(params, ctx) {
+    const name = params.name as string
+    const baseRef = (params.baseRef as string) || 'HEAD'
+
+    // Validate name
+    if (name.length > 64) {
+      return {
+        success: false,
+        content: '',
+        error: 'Worktree name must be 64 characters or fewer.',
+      }
+    }
+    if (!/^[a-zA-Z0-9._/-]+$/.test(name)) {
+      return {
+        success: false,
+        content: '',
+        error:
+          'Worktree name may only contain letters, digits, dots, underscores, dashes, and slashes.',
+      }
+    }
+
+    const cwd = ctx.cwd
+    const worktreePath = `${cwd}/.claude/worktrees/${name}`
+
+    try {
+      // Validate we're in a git repo
+      const gitCheck = Bun.spawn(['git', 'rev-parse', '--git-dir'], {
+        cwd,
+        stdout: 'pipe',
+        stderr: 'pipe',
+      })
+      const gitCheckExit = await gitCheck.exited
+      if (gitCheckExit !== 0) {
+        return {
+          success: false,
+          content: '',
+          error: 'Not in a git repository. EnterWorktree requires a git working directory.',
+        }
+      }
+
+      // Check if worktree already exists
+      const checkProc = Bun.spawn(['git', 'worktree', 'list', '--porcelain'], {
+        cwd,
+        stdout: 'pipe',
+        stderr: 'pipe',
+      })
+      const existingWorktrees = await new Response(checkProc.stdout).text()
+      if (existingWorktrees.includes(worktreePath)) {
+        return {
+          success: true,
+          content:
+            `── Worktree Already Exists ──\n\n` +
+            `Path:    ${worktreePath}\n` +
+            `Name:    ${name}\n\n` +
+            `This worktree already exists. To use it:\n` +
+            `  cd ${worktreePath}\n\n` +
+            `To remove it, use ExitWorktree.`,
+        }
+      }
+
+      // Determine base ref
+      let resolvedBaseRef = baseRef
+      if (baseRef === 'HEAD') {
+        try {
+          const branchProc = Bun.spawn(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], {
+            cwd,
+            stdout: 'pipe',
+            stderr: 'pipe',
+          })
+          const branch = (await new Response(branchProc.stdout).text()).trim()
+          resolvedBaseRef = branch || 'HEAD'
+        } catch {
+          resolvedBaseRef = 'HEAD'
+        }
+      }
+
+      // Create worktree with new branch
+      const branchName = `worktree/${name}`
+      const proc = Bun.spawn(
+        ['git', 'worktree', 'add', '-b', branchName, worktreePath, resolvedBaseRef],
+        { cwd, stdout: 'pipe', stderr: 'pipe' },
+      )
+      const stdout = await new Response(proc.stdout).text()
+      const exitCode = await proc.exited
+
+      if (exitCode !== 0) {
+        const stderr = await new Response(proc.stderr).text()
+        return {
+          success: false,
+          content: '',
+          error: `Failed to create worktree: ${stderr.slice(0, 1000)}`,
+        }
+      }
+
+      return {
+        success: true,
+        content:
+          `── Worktree Created ──\n\n` +
+          `Path:      ${worktreePath}\n` +
+          `Branch:    ${branchName}\n` +
+          `Base:      ${resolvedBaseRef}\n\n` +
+          `The worktree is ready. To switch to it:\n` +
+          `  cd ${worktreePath}\n\n` +
+          `Work in the worktree is isolated — changes on "${branchName}" won't affect your main branch.\n` +
+          `When done, use ExitWorktree to clean up.`,
+      }
+    } catch (err) {
+      return {
+        success: false,
+        content: '',
+        error: `Worktree creation failed: ${String(err)}`,
+      }
+    }
+  },
+}

package/src/tools/exec/exit-worktree.ts

@@ -0,0 +1,162 @@
+import type { ToolDefinition } from '../../shared/index.ts'
+
+export const exitWorktreeTool: ToolDefinition = {
+  name: 'ExitWorktree',
+  description:
+    'Remove a git worktree created by EnterWorktree. ' +
+    'Use action "remove" to delete the worktree and its branch, ' +
+    'or "keep" to leave it intact on disk.',
+  category: 'exec',
+  permission: 'ask',
+  parameters: {
+    type: 'object',
+    properties: {
+      path: {
+        type: 'string',
+        description: 'Absolute path to the worktree to exit. Must be under .claude/worktrees/.',
+      },
+      action: {
+        type: 'string',
+        enum: ['keep', 'remove'],
+        description:
+          '"keep" leaves the worktree and branch on disk. "remove" deletes both the worktree directory and its branch.',
+      },
+      discard_changes: {
+        type: 'boolean',
+        description:
+          'Required true when action is "remove" and the worktree has uncommitted files or unmerged commits. The tool will refuse and list them otherwise.',
+      },
+    },
+    required: ['path', 'action'],
+  },
+  async execute(params, ctx) {
+    const worktreePath = params.path as string
+    const action = params.action as string
+    const discardChanges = params.discard_changes === true
+
+    // Validate the path is under .claude/worktrees
+    const cwd = ctx.cwd
+
+    try {
+      // Verify the worktree exists in git's worktree list
+      const listProc = Bun.spawn(['git', 'worktree', 'list', '--porcelain'], {
+        cwd,
+        stdout: 'pipe',
+        stderr: 'pipe',
+      })
+      const listOutput = await new Response(listProc.stdout).text()
+
+      if (!listOutput.includes(worktreePath)) {
+        return {
+          success: false,
+          content: '',
+          error:
+            `Worktree not found: ${worktreePath}\n\n` +
+            `This path is not in git's worktree list. It may have already been removed, ` +
+            `or it was created outside of EnterWorktree.\n\n` +
+            `Use "git worktree list" to see active worktrees.`,
+        }
+      }
+
+      if (action === 'keep') {
+        return {
+          success: true,
+          content:
+            `── Worktree Kept ──\n\n` +
+            `Path:   ${worktreePath}\n\n` +
+            `The worktree and its branch are preserved on disk.\n` +
+            `To remove later: ExitWorktree with action="remove".`,
+        }
+      }
+
+      // action === 'remove' — check for uncommitted changes
+      if (!discardChanges) {
+        const statusProc = Bun.spawn(['git', '-C', worktreePath, 'status', '--porcelain'], {
+          cwd,
+          stdout: 'pipe',
+          stderr: 'pipe',
+        })
+        const statusOutput = await new Response(statusProc.stdout).text()
+        const changedFiles = statusOutput.trim().split('\n').filter(Boolean)
+
+        if (changedFiles.length > 0) {
+          const preview = changedFiles.slice(0, 10).join('\n')
+          const extra =
+            changedFiles.length > 10 ? `\n... and ${changedFiles.length - 10} more files` : ''
+          return {
+            success: false,
+            content: '',
+            error:
+              `Worktree has ${changedFiles.length} uncommitted file(s):\n\n` +
+              `${preview}${extra}\n\n` +
+              `Set discard_changes: true to force removal and discard these changes.\n` +
+              `Or commit the changes first, then retry.`,
+          }
+        }
+      }
+
+      // Get the branch name from worktree metadata
+      let branchName = ''
+      try {
+        const branchProc = Bun.spawn(
+          ['git', '-C', worktreePath, 'rev-parse', '--abbrev-ref', 'HEAD'],
+          { cwd, stdout: 'pipe', stderr: 'pipe' },
+        )
+        branchName = (await new Response(branchProc.stdout).text()).trim()
+      } catch {
+        // Branch detection is best-effort
+      }
+
+      // Remove the worktree
+      const removeArgs = discardChanges
+        ? ['git', 'worktree', 'remove', '--force', worktreePath]
+        : ['git', 'worktree', 'remove', worktreePath]
+
+      const removeProc = Bun.spawn(removeArgs, {
+        cwd,
+        stdout: 'pipe',
+        stderr: 'pipe',
+      })
+      const removeExit = await removeProc.exited
+
+      if (removeExit !== 0) {
+        const stderr = await new Response(removeProc.stderr).text()
+        return {
+          success: false,
+          content: '',
+          error: `Failed to remove worktree: ${stderr.slice(0, 1000)}`,
+        }
+      }
+
+      // Clean up the branch if we have its name
+      if (branchName && branchName !== 'HEAD') {
+        try {
+          const branchProc = Bun.spawn(['git', 'branch', '-D', branchName], {
+            cwd,
+            stdout: 'pipe',
+            stderr: 'pipe',
+          })
+          await branchProc.exited
+          // Best-effort — branch cleanup failure is not fatal
+        } catch {
+          // Ignore branch cleanup failures
+        }
+      }
+
+      return {
+        success: true,
+        content:
+          `── Worktree Removed ──\n\n` +
+          `Path:    ${worktreePath}\n` +
+          (branchName ? `Branch:  ${branchName} (deleted)\n` : '') +
+          `\nThe worktree has been removed.`,
+      }
+    } catch (err) {
+      return {
+        success: false,
+        content: '',
+        error: `Worktree removal failed: ${String(err)}`,
+      }
+    }
+  },
+}

package/src/tools/exec/task.ts

@@ -4,13 +4,17 @@ interface Task {
   id: string
   subject: string
   description: string
-  status: 'pending' | 'in_progress' | 'completed' | 'deleted'
+  status: 'pending' | 'in_progress' | 'completed' | 'deleted' | 'failed'
   activeForm?: string
   metadata?: Record<string, unknown>
   blocks: string[]
   blockedBy: string[]
   owner?: string
   createdAt: string
+  /** Background task output content (set when a background agent completes). */
+  output?: string
+  /** Background task error message (set when a background agent fails). */
+  outputError?: string
 }
 
 const tasks = new Map<string, Task>()
@@ -20,14 +24,33 @@ function formatTask(t: Task): string {
   const meta = t.metadata ? ` ${JSON.stringify(t.metadata)}` : ''
   const blocks = t.blocks.length ? ` blocks:[${t.blocks.join(',')}]` : ''
   const blocked = t.blockedBy.length ? ` waits:[${t.blockedBy.join(',')}]` : ''
-  return `[${t.status}] #${t.id}: ${t.subject}${blocks}${blocked}${meta}`
+  const owner = t.owner ? ` @${t.owner}` : ''
+  return `[${t.status}] #${t.id}: ${t.subject}${owner}${blocks}${blocked}${meta}`
+}
+
+/** Check if a task is blocked — has unresolved dependencies. */
+function isBlocked(task: Task): boolean {
+  if (task.blockedBy.length === 0) return false
+  return task.blockedBy.some((depId) => {
+    const dep = tasks.get(depId)
+    return dep && dep.status !== 'completed' && dep.status !== 'deleted'
+  })
+}
+
+/** Get the list of blocking task IDs (unresolved dependencies). */
+function getBlockingIds(task: Task): string[] {
+  return task.blockedBy.filter((depId) => {
+    const dep = tasks.get(depId)
+    return dep && dep.status !== 'completed' && dep.status !== 'deleted'
+  })
 }
 
 export const taskTool: ToolDefinition = {
   name: 'Task',
   description:
     'Create and manage structured task lists for tracking progress. ' +
-    'Supports CRUD, dependencies (blocks/blockedBy), metadata, owner assignment, and status workflow: pending → in_progress → completed. ' +
+    'Supports CRUD, dependencies (blocks/blockedBy), metadata, owner assignment, ' +
+    'background task output/stop, and status workflow: pending → in_progress → completed. ' +
     'Use for complex multi-step tasks, session tracking, and organizing work.',
   category: 'exec',
   permission: 'auto',
@@ -36,9 +59,9 @@ export const taskTool: ToolDefinition = {
     properties: {
       action: {
         type: 'string',
-        enum: ['create', 'list', 'update', 'get', 'delete'],
+        enum: ['create', 'list', 'update', 'get', 'delete', 'output', 'stop'],
         description:
-          'Action: create a task, list all, update status/fields, get one by ID, or delete.',
+          'Action: create a task, list all, update status/fields, get one by ID, delete, view output of background task, or stop a running task.',
       },
       subject: { type: 'string', description: 'A brief, actionable title (for create/update).' },
       description: { type: 'string', description: 'What needs to be done (for create/update).' },
@@ -46,21 +69,24 @@ export const taskTool: ToolDefinition = {
         type: 'string',
         description: 'Present continuous form shown during work (for create/update).',
       },
-      taskId: { type: 'string', description: 'Task ID (for update/get/delete).' },
+      taskId: { type: 'string', description: 'Task ID (for update/get/delete/output/stop).' },
       status: {
         type: 'string',
-        enum: ['pending', 'in_progress', 'completed', 'deleted'],
-        description: 'New status. "deleted" permanently removes the task.',
+        enum: ['pending', 'in_progress', 'completed', 'deleted', 'failed'],
+        description:
+          'New status. "deleted" permanently removes the task, "failed" marks as failed.',
       },
       addBlocks: {
         type: 'array',
         items: { type: 'string' },
-        description: 'Task IDs that this task blocks (they depend on this one).',
+        description:
+          'Task IDs that this task blocks (they depend on this one). Use for create or update.',
       },
       addBlockedBy: {
         type: 'array',
         items: { type: 'string' },
-        description: 'Task IDs that block this task (this one depends on them).',
+        description:
+          'Task IDs that block this task (this one depends on them). Use for create or update.',
       },
       owner: { type: 'string', description: 'Agent or user name assigned to this task.' },
       metadata: {
@@ -90,8 +116,24 @@ export const taskTool: ToolDefinition = {
         owner: (params.owner as string) || undefined,
         createdAt: new Date().toISOString(),
       }
+
+      // Accept initial dependencies at creation time
+      if (Array.isArray(params.addBlocks)) {
+        for (const bid of params.addBlocks as string[]) {
+          if (!task.blocks.includes(bid)) task.blocks.push(bid)
+        }
+      }
+      if (Array.isArray(params.addBlockedBy)) {
+        for (const bid of params.addBlockedBy as string[]) {
+          if (!task.blockedBy.includes(bid)) task.blockedBy.push(bid)
+        }
+      }
+
       tasks.set(id, task)
-      return { success: true, content: `Task #${id} created: ${subject}` }
+      const blockedNote = isBlocked(task)
+        ? ` (blocked — waiting on: ${getBlockingIds(task).join(', ')})`
+        : ''
+      return { success: true, content: `Task #${id} created: ${subject}${blockedNote}` }
     }
 
     // ── LIST ──
@@ -99,18 +141,63 @@ export const taskTool: ToolDefinition = {
       const all = Array.from(tasks.values()).filter((t) => t.status !== 'deleted')
       if (all.length === 0) return { success: true, content: '(no tasks)' }
 
-      // Group by status
-      const groups: Record<string, Task[]> = { pending: [], in_progress: [], completed: [] }
-      for (const t of all) groups[t.status]?.push(t)
+      // Sort by availability: in_progress → pending(available) → pending(blocked) → completed
+      const sortOrder: Record<string, number> = {
+        in_progress: 0,
+        pending: 1,
+        completed: 2,
+        failed: 3,
+      }
+
+      const sorted = [...all].sort((a, b) => {
+        const orderA = sortOrder[a.status] ?? 3
+        const orderB = sortOrder[b.status] ?? 3
+        if (orderA !== orderB) return orderA - orderB
+        // Within same status: available before blocked
+        if (a.status === 'pending' && b.status === 'pending') {
+          const aBlocked = isBlocked(a)
+          const bBlocked = isBlocked(b)
+          if (aBlocked !== bBlocked) return aBlocked ? 1 : -1
+        }
+        return 0
+      })
 
       const lines: string[] = []
-      for (const status of ['in_progress', 'pending', 'completed'] as const) {
-        const group = groups[status]!
-        if (group.length === 0) continue
-        const emoji = status === 'in_progress' ? '🔄' : status === 'pending' ? '📋' : '✅'
-        lines.push(`${emoji} ${status.replace('_', ' ')} (${group.length}):`)
-        for (const t of group) lines.push(`  ${formatTask(t)}`)
+      const statusLabels: Record<string, { emoji: string; label: string }> = {
+        in_progress: { emoji: '🔄', label: 'In Progress' },
+        pending: { emoji: '📋', label: 'Pending' },
+        completed: { emoji: '✅', label: 'Completed' },
+        failed: { emoji: '❌', label: 'Failed' },
+      }
+
+      let currentStatus = ''
+      for (const t of sorted) {
+        const statusInfo = statusLabels[t.status]
+        if (!statusInfo) continue
+
+        if (statusInfo.label !== currentStatus) {
+          currentStatus = statusInfo.label
+          // Count tasks in this status group
+          const count = sorted.filter((s) => statusLabels[s.status]?.label === currentStatus).length
+          lines.push(`${statusInfo.emoji} ${currentStatus} (${count}):`)
+        }
+
+        const blocked = isBlocked(t)
+        const prefix = blocked && t.status === 'pending' ? '🚫 ' : '  '
+        const blockingNote = blocked ? ` 🚫 阻塞中 (等待: ${getBlockingIds(t).join(', ')})` : ''
+        lines.push(`${prefix}${formatTask(t)}${blockingNote}`)
       }
+
+      // Summary footer
+      const available = all.filter((t) => t.status === 'pending' && !isBlocked(t)).length
+      const blockedCount = all.filter((t) => t.status === 'pending' && isBlocked(t)).length
+      if (blockedCount > 0) {
+        lines.push('')
+        lines.push(
+          `📊 ${available} available · ${blockedCount} blocked · ${all.filter((t) => t.status === 'completed').length} done`,
+        )
+      }
+
       return { success: true, content: lines.join('\n') }
     }
 
@@ -129,8 +216,27 @@ export const taskTool: ToolDefinition = {
       if (task.activeForm) lines.push(`Active form: ${task.activeForm}`)
       if (task.owner) lines.push(`Owner: ${task.owner}`)
       if (task.blocks.length) lines.push(`Blocks: ${task.blocks.join(', ')}`)
-      if (task.blockedBy.length) lines.push(`Blocked by: ${task.blockedBy.join(', ')}`)
+      if (task.blockedBy.length) {
+        const blocking = getBlockingIds(task)
+        if (blocking.length > 0) {
+          lines.push(
+            `Blocked by: ${task.blockedBy.join(', ')} (active blockers: ${blocking.join(', ')})`,
+          )
+        } else {
+          lines.push(`Blocked by: ${task.blockedBy.join(', ')} (all resolved ✓)`)
+        }
+      }
       if (task.metadata) lines.push(`Metadata: ${JSON.stringify(task.metadata)}`)
+      if (task.output) {
+        lines.push('')
+        lines.push('── Output ──')
+        lines.push(task.output.slice(0, 2000))
+      }
+      if (task.outputError) {
+        lines.push('')
+        lines.push(`── Error ──`)
+        lines.push(task.outputError)
+      }
 
       return { success: true, content: lines.join('\n') }
     }
@@ -167,7 +273,14 @@ export const taskTool: ToolDefinition = {
         }
       }
 
-      return { success: true, content: `Task #${taskId} updated.\n${formatTask(task)}` }
+      const blockedNote = isBlocked(task)
+        ? ` (blocked — waiting on: ${getBlockingIds(task).join(', ')})`
+        : ''
+
+      return {
+        success: true,
+        content: `Task #${taskId} updated.\n${formatTask(task)}${blockedNote}`,
+      }
     }
 
     // ── DELETE ──
@@ -179,6 +292,86 @@ export const taskTool: ToolDefinition = {
       return { success: true, content: `Task #${taskId} deleted.` }
     }
 
+    // ── OUTPUT ──
+    if (action === 'output') {
+      const taskId = params.taskId as string
+      const task = tasks.get(taskId)
+      if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
+
+      if (task.status === 'pending') {
+        return {
+          success: true,
+          content: `Task #${taskId} is still pending — no output yet.\nStatus: ${task.status}\nSubject: ${task.subject}`,
+        }
+      }
+
+      if (task.status === 'in_progress') {
+        return {
+          success: true,
+          content: `Task #${taskId} is still running — output not yet available.\nStatus: in_progress\nSubject: ${task.subject}\n\nUse Task output again once the task completes.`,
+        }
+      }
+
+      if (task.status === 'completed' && task.output) {
+        return {
+          success: true,
+          content: `── Task #${taskId} Output ──\nStatus: completed\nSubject: ${task.subject}\n\n${task.output.slice(0, 5000)}`,
+        }
+      }
+
+      if (task.status === 'failed' && task.outputError) {
+        return {
+          success: false,
+          content: '',
+          error: `Task #${taskId} failed: ${task.outputError}`,
+        }
+      }
+
+      return {
+        success: true,
+        content: `Task #${taskId} — Status: ${task.status}\nSubject: ${task.subject}\n\n(no output recorded)`,
+      }
+    }
+
+    // ── STOP ──
+    if (action === 'stop') {
+      const taskId = params.taskId as string
+      const task = tasks.get(taskId)
+      if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
+
+      if (task.status === 'completed' || task.status === 'deleted') {
+        return {
+          success: true,
+          content: `Task #${taskId} is already ${task.status}. Nothing to stop.`,
+        }
+      }
+
+      if (task.status === 'pending') {
+        // Cancel a pending task
+        task.status = 'deleted'
+        return { success: true, content: `Task #${taskId} cancelled (was pending).` }
+      }
+
+      // For in_progress tasks: mark as failed — actual process termination is handled
+      // by BackgroundAgentRegistry.stop() when wired via the engine context
+      task.status = 'failed'
+      task.outputError = 'Task stopped by user.'
+
+      // If BackgroundAgentRegistry is available in context, try to abort
+      if (_ctx.registry) {
+        // Signal to any background registry that this task should stop
+        // The background registry will be injected via the engine context
+        const bgRegistry = (_ctx as unknown as Record<string, unknown>).backgroundAgentRegistry as
+          | { stop(id: string): boolean }
+          | undefined
+        if (bgRegistry) {
+          bgRegistry.stop(taskId)
+        }
+      }
+
+      return { success: true, content: `Task #${taskId} stopped.` }
+    }
+
     return { success: false, content: '', error: `Unknown action: ${action}` }
   },
 }

package/src/tools/index.ts

@@ -7,9 +7,13 @@ import { grepTool } from './file/grep'
 import { bashTool } from './exec/bash'
 import { gitTool } from './exec/git'
 import { taskTool } from './exec/task'
+import { enterWorktreeTool } from './exec/enter-worktree'
+import { exitWorktreeTool } from './exec/exit-worktree'
 import { agentTool } from './agent/agent'
 import { skillTool } from './agent/skill'
 import { planTool } from './agent/plan'
+import { enterPlanModeTool } from './agent/enter-plan'
+import { exitPlanModeTool } from './agent/exit-plan'
 import { memoryTool } from './agent/memory'
 import { workflowTool } from './agent/workflow'
 import { webFetchTool } from './network/web-fetch'
@@ -17,6 +21,8 @@ import { webSearchTool } from './network/web-search'
 import { configTool } from './system/config'
 import { mcpTool } from './system/mcp'
 import { artifactTool } from './artifact/artifact'
+import { reportFindingsTool } from './agent/report-findings'
+import { sendMessageTool } from './agent/send-message'
 import { computerUseTool } from './computer/computer-use'
 import { scheduleWakeupTool } from './scheduling/schedule-wakeup.js'
 import { cronCreateTool, cronDeleteTool, cronListTool } from './scheduling/cron.js'
@@ -110,12 +116,18 @@ export function createToolRegistry(): Map<string, ToolDefinition> {
     withValidation(bashTool),
     withValidation(gitTool),
     withValidation(taskTool),
+    withValidation(enterWorktreeTool),
+    withValidation(exitWorktreeTool),
     // Agent tools
     withValidation(agentTool),
     withValidation(skillTool),
     withValidation(planTool),
+    withValidation(enterPlanModeTool),
+    withValidation(exitPlanModeTool),
     withValidation(memoryTool),
     withValidation(workflowTool),
+    withValidation(reportFindingsTool),
+    withValidation(sendMessageTool),
     // Network tools
     withValidation(webFetchTool),
     withValidation(webSearchTool),