@vibe-forge/mcp 2.0.1 → 2.0.2-alpha.0

package/__tests__/task-manager.spec.ts

@@ -208,6 +208,240 @@ describe('taskManager fatal error scenarios', () => {
     })
   })
 
+  it('sends a follow-up message directly to a running task without server sync', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+    const emit = vi.fn()
+
+    mocks.run.mockResolvedValueOnce({
+      session: {
+        emit,
+        kill: vi.fn()
+      }
+    })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-send-local',
+      description: 'trigger'
+    })
+
+    await managedTaskManager.sendTaskMessage({
+      taskId: 'task-send-local',
+      message: 'keep going'
+    })
+
+    const task = managedTaskManager.getTask('task-send-local')
+    expect(emit).toHaveBeenNthCalledWith(2, {
+      type: 'message',
+      content: [{
+        type: 'text',
+        text: 'keep going'
+      }]
+    })
+    expect(task?.logs).toContain('User message submitted (direct): keep going')
+  })
+
+  it('syncs follow-up messages through the child session when server sync is enabled', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+    const emit = vi.fn()
+
+    mocks.run.mockResolvedValueOnce({
+      session: {
+        emit,
+        kill: vi.fn()
+      }
+    })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-send-synced',
+      description: 'trigger',
+      enableServerSync: true
+    })
+
+    await managedTaskManager.sendTaskMessage({
+      taskId: 'task-send-synced',
+      message: 'keep going'
+    })
+
+    const task = managedTaskManager.getTask('task-send-synced')
+    expect(emit).toHaveBeenCalledTimes(1)
+    expect(mocks.postSessionEvent).toHaveBeenCalledWith('task-send-synced', {
+      type: 'message',
+      data: expect.objectContaining({
+        role: 'user',
+        content: 'keep going'
+      })
+    })
+    expect(task?.logs).toContain('User message submitted (direct): keep going')
+  })
+
+  it('queues steer follow-up messages and resumes the same task after natural completion', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+    let onEvent: ((event: any) => void) | undefined
+    const resumedEmit = vi.fn()
+
+    mocks.run
+      .mockImplementationOnce(async (_options: unknown, adapterOptions: any) => {
+        onEvent = adapterOptions.onEvent
+        return {
+          session: {
+            emit: vi.fn(),
+            kill: vi.fn()
+          }
+        }
+      })
+      .mockResolvedValueOnce({
+        session: {
+          emit: resumedEmit,
+          kill: vi.fn()
+        }
+      })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-send-steer',
+      description: 'trigger'
+    })
+
+    await managedTaskManager.sendTaskMessage({
+      taskId: 'task-send-steer',
+      message: 'after you finish, summarize blockers',
+      mode: 'steer'
+    })
+
+    onEvent?.({
+      type: 'stop',
+      data: undefined
+    })
+    await new Promise(resolve => setTimeout(resolve, 0))
+
+    const task = managedTaskManager.getTask('task-send-steer')
+    expect(mocks.run).toHaveBeenCalledTimes(2)
+    expect(resumedEmit).toHaveBeenCalledWith({
+      type: 'message',
+      content: [{
+        type: 'text',
+        text: 'after you finish, summarize blockers'
+      }]
+    })
+    expect(task?.logs).toContain('Queued task message (steer): after you finish, summarize blockers')
+    expect(task?.logs).toContain('Resuming task from steer queue: after you finish, summarize blockers')
+  })
+
+  it('rejects follow-up messages when a task is waiting for input', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+
+    mocks.run.mockImplementationOnce(async (_options: unknown, adapterOptions: any) => {
+      const session = {
+        emit: vi.fn(() => {
+          adapterOptions.onEvent({
+            type: 'interaction_request',
+            data: {
+              id: 'interaction-send-blocked',
+              payload: {
+                sessionId: 'task-send-blocked',
+                kind: 'permission',
+                question: 'Allow editing files?',
+                options: [
+                  { label: 'Allow once', value: 'allow_once' }
+                ]
+              }
+            }
+          })
+        }),
+        kill: vi.fn(),
+        respondInteraction: vi.fn()
+      }
+      return { session }
+    })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-send-blocked',
+      description: 'trigger',
+      background: false
+    })
+
+    await expect(managedTaskManager.sendTaskMessage({
+      taskId: 'task-send-blocked',
+      message: 'continue'
+    })).rejects.toThrow('Task task-send-blocked is waiting for input. Use SubmitTaskInput instead.')
+  })
+
+  it('rejects steer follow-up messages when a task is waiting for input', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+
+    mocks.run.mockImplementationOnce(async (_options: unknown, adapterOptions: any) => {
+      const session = {
+        emit: vi.fn(() => {
+          adapterOptions.onEvent({
+            type: 'interaction_request',
+            data: {
+              id: 'interaction-send-steer-blocked',
+              payload: {
+                sessionId: 'task-send-steer-blocked',
+                kind: 'permission',
+                question: 'Allow editing files?',
+                options: [
+                  { label: 'Allow once', value: 'allow_once' }
+                ]
+              }
+            }
+          })
+        }),
+        kill: vi.fn(),
+        respondInteraction: vi.fn()
+      }
+      return { session }
+    })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-send-steer-blocked',
+      description: 'trigger',
+      background: false
+    })
+
+    await expect(managedTaskManager.sendTaskMessage({
+      taskId: 'task-send-steer-blocked',
+      message: 'summarize blockers after this',
+      mode: 'steer'
+    })).rejects.toThrow('Task task-send-steer-blocked is waiting for input. Use SubmitTaskInput instead.')
+  })
+
+  it('rejects steer follow-up messages after a task has already completed', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+    let onEvent: ((event: any) => void) | undefined
+
+    mocks.run.mockImplementationOnce(async (_options: unknown, adapterOptions: any) => {
+      onEvent = adapterOptions.onEvent
+      return {
+        session: {
+          emit: vi.fn(),
+          kill: vi.fn()
+        }
+      }
+    })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-send-completed',
+      description: 'trigger'
+    })
+
+    onEvent?.({
+      type: 'stop',
+      data: undefined
+    })
+
+    await expect(managedTaskManager.sendTaskMessage({
+      taskId: 'task-send-completed',
+      message: 'queue this for later',
+      mode: 'steer'
+    })).rejects.toThrow('Task task-send-completed is not active. Start a new task instead.')
+  })
+
   it('builds synthetic permission recovery for claude-code and resumes after SubmitTaskInput', async () => {
     const { TaskManager } = await import('#~/tools/task/manager.js')
     const resumedEmit = vi.fn()

package/__tests__/task-tool.spec.ts

@@ -8,6 +8,7 @@ const mocks = vi.hoisted(() => {
     createChildSession: vi.fn(),
     getParentSessionId: vi.fn(),
     startTask: vi.fn(),
+    sendTaskMessage: vi.fn(),
     submitTaskInput: vi.fn(),
     respondToTaskInteraction: vi.fn(),
     getTask: vi.fn(),
@@ -33,6 +34,7 @@ vi.mock('#~/sync.js', () => ({
 vi.mock('#~/tools/task/manager.js', () => ({
   TaskManager: class {
     startTask = mocks.startTask
+    sendTaskMessage = mocks.sendTaskMessage
     submitTaskInput = mocks.submitTaskInput
     respondToTaskInteraction = mocks.respondToTaskInteraction
     getTask = mocks.getTask
@@ -52,6 +54,7 @@ describe('task tool integration', () => {
     mocks.getParentSessionId.mockReturnValue(undefined)
     mocks.createChildSession.mockResolvedValue({})
     mocks.startTask.mockResolvedValue(undefined)
+    mocks.sendTaskMessage.mockResolvedValue(undefined)
     mocks.submitTaskInput.mockResolvedValue(undefined)
     mocks.respondToTaskInteraction.mockResolvedValue(undefined)
     mocks.getTask.mockImplementation((taskId: string) => ({
@@ -181,15 +184,96 @@ describe('task tool integration', () => {
     const tester = createToolTester()
     createTaskRegister()(tester.mockRegister)
 
+    expect(tester.getRegisteredTools()).toContain('SendTaskMessage')
     expect(tester.getRegisteredTools()).toContain('SubmitTaskInput')
     expect(tester.getRegisteredTools()).toContain('RespondTaskInteraction')
     expect(tester.getToolInfo('StartTasks')?.description).toContain('GetTaskInfo')
-    expect(tester.getToolInfo('GetTaskInfo')?.description).toContain('SubmitTaskInput')
+    expect(tester.getToolInfo('StartTasks')?.description).toContain('SendTaskMessage')
+    expect(tester.getToolInfo('GetTaskInfo')?.description).toContain('10 most recent logs')
+    expect(tester.getToolInfo('GetTaskInfo')?.description).toContain('logOrder')
+    expect(tester.getToolInfo('GetTaskInfo')?.description).toContain('SendTaskMessage')
+    expect(tester.getToolInfo('SendTaskMessage')?.description).toContain('mode "direct"')
+    expect(tester.getToolInfo('SendTaskMessage')?.description).toContain('mode "steer"')
+    expect(tester.getToolInfo('ListTasks')?.description).toContain('10 most recent logs')
+    expect(tester.getToolInfo('ListTasks')?.description).toContain('SendTaskMessage')
     expect(tester.getToolInfo('ListTasks')?.description).toContain('pendingInput')
+    expect(tester.getToolInfo('SubmitTaskInput')?.description).toContain('SendTaskMessage')
     expect(tester.getToolInfo('SubmitTaskInput')?.description).toContain('allow_once')
     expect(tester.getToolInfo('RespondTaskInteraction')?.description).toContain('Deprecated alias')
   })
 
+  it('returns the 10 most recent logs in descending order by default', async () => {
+    mocks.getTask.mockReturnValue({
+      taskId: 'task-1',
+      status: 'running',
+      logs: Array.from({ length: 12 }, (_, index) => `log-${index + 1}`)
+    })
+
+    const { createTaskRegister } = await import('#~/tools/task/index.js')
+
+    const tester = createToolTester()
+    createTaskRegister()(tester.mockRegister)
+
+    const result = await tester.callTool('GetTaskInfo', {
+      taskId: 'task-1'
+    }) as { content: Array<{ text: string }> }
+    const [task] = JSON.parse(result.content[0].text) as Array<{ logs: string[] }>
+
+    expect(task.logs).toEqual([
+      'log-12',
+      'log-11',
+      'log-10',
+      'log-9',
+      'log-8',
+      'log-7',
+      'log-6',
+      'log-5',
+      'log-4',
+      'log-3'
+    ])
+  })
+
+  it('supports custom log windows and ascending order in ListTasks', async () => {
+    mocks.getAllTasks.mockReturnValue([
+      {
+        taskId: 'task-1',
+        status: 'running',
+        logs: ['a', 'b', 'c', 'd']
+      },
+      {
+        taskId: 'task-2',
+        status: 'completed',
+        logs: ['1', '2', '3']
+      }
+    ])
+
+    const { createTaskRegister } = await import('#~/tools/task/index.js')
+
+    const tester = createToolTester()
+    createTaskRegister()(tester.mockRegister)
+
+    const result = await tester.callTool('ListTasks', {
+      logLimit: 2,
+      logOrder: 'asc'
+    }) as { content: Array<{ text: string }> }
+    const tasks = JSON.parse(result.content[0].text) as Array<{ taskId: string; logs: string[] }>
+
+    expect(tasks).toEqual([
+      {
+        taskId: 'task-1',
+        status: 'running',
+        logs: ['c', 'd'],
+        guidance: []
+      },
+      {
+        taskId: 'task-2',
+        status: 'completed',
+        logs: ['2', '3'],
+        guidance: []
+      }
+    ])
+  })
+
   it('forwards SubmitTaskInput to the task manager', async () => {
     mocks.getTask.mockReturnValue({
       taskId: 'task-1',
@@ -214,6 +298,31 @@ describe('task tool integration', () => {
     })
   })
 
+  it('forwards SendTaskMessage to the task manager', async () => {
+    mocks.getTask.mockReturnValue({
+      taskId: 'task-1',
+      status: 'running',
+      logs: ['Queued task message (steer): keep checking logs']
+    })
+
+    const { createTaskRegister } = await import('#~/tools/task/index.js')
+
+    const tester = createToolTester()
+    createTaskRegister()(tester.mockRegister)
+
+    await tester.callTool('SendTaskMessage', {
+      taskId: 'task-1',
+      message: 'keep checking logs',
+      mode: 'steer'
+    })
+
+    expect(mocks.sendTaskMessage).toHaveBeenCalledWith({
+      taskId: 'task-1',
+      message: 'keep checking logs',
+      mode: 'steer'
+    })
+  })
+
   it('keeps RespondTaskInteraction as a deprecated alias', async () => {
     mocks.getTask.mockReturnValue({
       taskId: 'task-1',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-forge/mcp",
-  "version": "2.0.1",
+  "version": "2.0.2-alpha.0",
   "description": "Vibe Forge MCP server",
   "imports": {
     "#~/*.js": {
@@ -34,12 +34,12 @@
     "@vibe-forge/config": "^2.0.2",
     "commander": "^12.1.0",
     "zod": "^3.24.1",
-    "@vibe-forge/hooks": "^2.0.1",
-    "@vibe-forge/register": "^2.0.1",
-    "@vibe-forge/cli-helper": "^2.0.1",
-    "@vibe-forge/utils": "^2.0.1",
-    "@vibe-forge/types": "^2.0.1",
-    "@vibe-forge/task": "^2.0.1"
+    "@vibe-forge/cli-helper": "^2.0.0",
+    "@vibe-forge/hooks": "^2.0.0",
+    "@vibe-forge/task": "2.0.1-alpha.3",
+    "@vibe-forge/types": "^2.0.2",
+    "@vibe-forge/register": "^2.0.0",
+    "@vibe-forge/utils": "2.0.4-alpha.1"
   },
   "scripts": {
     "test": "pnpm -C ../.. exec vitest run --workspace vitest.workspace.ts --project bundler packages/mcp/__tests__"

package/src/tools/task/manager.ts

@@ -61,6 +61,7 @@ export interface TaskInfo {
   exitCode?: number
   logs: string[]
   permissionState: SessionPermissionState
+  queuedSteerMessages: string[]
   pendingInteraction?: PendingTaskInteraction
   lastError?: AdapterErrorData
   session?: ManagedTaskSession
@@ -252,6 +253,7 @@ export class TaskManager {
       status: 'running',
       logs: [],
       permissionState: createEmptySessionPermissionState(),
+      queuedSteerMessages: [],
       createdAt: Date.now()
     }
     if (enableServerSync) {
@@ -285,7 +287,7 @@ export class TaskManager {
     return { taskId }
   }
 
-  private async launchTask(task: TaskInfo, runType: 'create' | 'resume') {
+  private async launchTask(task: TaskInfo, runType: 'create' | 'resume', resumeMessage?: string) {
     try {
       const rootCwd = process.cwd()
       const promptType = task.type !== 'default' ? task.type : undefined
@@ -374,7 +376,7 @@ export class TaskManager {
         type: 'message',
         content: [{
           type: 'text',
-          text: runType === 'resume' ? TASK_PERMISSION_CONTINUE_PROMPT : current.description
+          text: resumeMessage ?? (runType === 'resume' ? TASK_PERMISSION_CONTINUE_PROMPT : current.description)
         }]
       })
     } catch (err) {
@@ -467,6 +469,17 @@ export class TaskManager {
         task.status = 'completed'
         task.pendingInteraction = undefined
         this.stopServerPolling(taskId)
+        if (task.queuedSteerMessages.length > 0) {
+          void this.dispatchQueuedSteerMessage(task).catch((error) => {
+            task.status = 'failed'
+            appendTaskLog(
+              task,
+              `Failed to resume steer-queued task: ${error instanceof Error ? error.message : String(error)}`
+            )
+            task.onStop?.()
+          })
+          break
+        }
         task.onStop?.()
         break
       }
@@ -489,6 +502,17 @@ export class TaskManager {
         task.pendingInteraction = undefined
         appendTaskLog(task, `Process exited with code ${event.data.exitCode}`)
         this.stopServerPolling(taskId)
+        if (task.status === 'completed' && task.queuedSteerMessages.length > 0) {
+          void this.dispatchQueuedSteerMessage(task).catch((error) => {
+            task.status = 'failed'
+            appendTaskLog(
+              task,
+              `Failed to resume steer-queued task: ${error instanceof Error ? error.message : String(error)}`
+            )
+            task.onStop?.()
+          })
+          break
+        }
         task.onStop?.()
         break
       default:
@@ -581,6 +605,74 @@ export class TaskManager {
     return Array.from(this.tasks.values())
   }
 
+  public async sendTaskMessage(params: {
+    taskId: string
+    message: string
+    mode?: 'direct' | 'steer'
+  }): Promise<void> {
+    const task = this.tasks.get(params.taskId)
+    if (task == null) {
+      throw new Error(`Task ${params.taskId} not found.`)
+    }
+
+    const message = params.message.trim()
+    const mode = params.mode ?? 'direct'
+    if (message === '') {
+      throw new Error('Task message cannot be empty.')
+    }
+
+    if (task.pendingInteraction != null || task.status === 'waiting_input') {
+      throw new Error(`Task ${params.taskId} is waiting for input. Use SubmitTaskInput instead.`)
+    }
+
+    if (mode === 'steer') {
+      if (task.status === 'completed' || task.status === 'failed') {
+        throw new Error(`Task ${params.taskId} is not active. Start a new task instead.`)
+      }
+      task.queuedSteerMessages.push(message)
+      appendTaskLog(task, `Queued task message (${mode}): ${message}`)
+      return
+    }
+
+    if (task.status !== 'running' || task.session == null) {
+      throw new Error(`Task ${params.taskId} is not running. Start a new task instead.`)
+    }
+
+    if (task.serverSync != null) {
+      await postSessionEvent(task.serverSync.sessionId, {
+        type: 'message',
+        data: {
+          id: `task-user:${task.taskId}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`,
+          role: 'user',
+          content: message,
+          createdAt: Date.now()
+        }
+      })
+    } else {
+      task.session.emit({
+        type: 'message',
+        content: [{
+          type: 'text',
+          text: message
+        }]
+      })
+    }
+
+    appendTaskLog(task, `User message submitted (${mode}): ${message}`)
+  }
+
+  private async dispatchQueuedSteerMessage(task: TaskInfo) {
+    const nextMessage = task.queuedSteerMessages.shift()
+    if (nextMessage == null || nextMessage.trim() === '') {
+      return false
+    }
+
+    task.status = 'running'
+    appendTaskLog(task, `Resuming task from steer queue: ${nextMessage}`)
+    await this.launchTask(task, 'resume', nextMessage)
+    return true
+  }
+
   public async submitTaskInput(params: {
     taskId: string
     interactionId?: string

package/src/tools/task/presentation.ts

@@ -5,15 +5,21 @@ import type { SessionPermissionMode } from '@vibe-forge/types'
 import type { TaskInfo } from './manager'
 
 export const SESSION_PERMISSION_MODES = ['default', 'acceptEdits', 'plan', 'dontAsk', 'bypassPermissions'] as const
+export const TASK_LOG_ORDERS = ['asc', 'desc'] as const
+export const DEFAULT_TASK_LOG_LIMIT = 10
+export type TaskLogsOrder = typeof TASK_LOG_ORDERS[number]
 
 export const START_TASKS_DESCRIPTION =
-  'Start multiple tasks in background or foreground. Use type "workspace" plus name to run in a configured workspace. If a task stalls, fails, or asks for permission/input, call GetTaskInfo. If GetTaskInfo returns pendingInput or pendingInteraction, resolve it with SubmitTaskInput. If logs show permission_required, you can answer the recovery prompt with SubmitTaskInput instead of restarting manually.'
+  'Start multiple tasks in background or foreground. Use type "workspace" plus name to run in a configured workspace. If a task stalls, fails, or asks for permission/input, call GetTaskInfo. GetTaskInfo returns the 10 most recent logs by default in descending order, so newer log lines appear earlier in the logs array. If you need to add another instruction to a task that is still running, use SendTaskMessage instead of starting a replacement task. If GetTaskInfo returns pendingInput or pendingInteraction, resolve it with SubmitTaskInput. If logs show permission_required, you can answer the recovery prompt with SubmitTaskInput instead of restarting manually.'
 
 export const GET_TASK_INFO_DESCRIPTION =
-  'Get the detailed status, logs, pendingInput, pendingInteraction, lastError, and guidance for a task. Use this when a task seems stuck, is waiting for permission/input, or has failed. If pendingInput is present, answer it with SubmitTaskInput.'
+  'Get the detailed status, logs, pendingInput, pendingInteraction, lastError, and guidance for a task. By default this returns the 10 most recent logs in descending order, so newer log lines appear earlier in the logs array. Use logLimit to inspect a different number of recent logs, and set logOrder to "asc" when you want the selected log window in oldest-to-newest order. If the task is still active and you need to continue it, call SendTaskMessage with mode "direct" or "steer" depending on timing. If pendingInput is present, answer it with SubmitTaskInput.'
+
+export const SEND_TASK_MESSAGE_DESCRIPTION =
+  'Send a follow-up user message to a managed task. Use mode "direct" (default) to continue the current running task immediately. Use mode "steer" to queue a follow-up that should run after the current task finishes naturally. Do not use this to answer pendingInput or pendingInteraction; use SubmitTaskInput for that. If the task already completed or failed, start a new task instead.'
 
 export const SUBMIT_TASK_INPUT_DESCRIPTION =
-  'Submit input for a task that is blocked waiting for permission or user input. First call GetTaskInfo or ListTasks, then use taskId plus one of pendingInput.payload.options[].value when available. Common permission answers are allow_once, allow_session, allow_project, deny_once, deny_session, or deny_project.'
+  'Submit input for a task that is blocked waiting for permission or user input. First call GetTaskInfo or ListTasks, then use taskId plus one of pendingInput.payload.options[].value when available. Do not use this for ordinary follow-up instructions to a running task or queued steer messages; use SendTaskMessage instead. Common permission answers are allow_once, allow_session, allow_project, deny_once, deny_session, or deny_project.'
 
 export const RESPOND_TASK_INTERACTION_DESCRIPTION =
   'Deprecated alias of SubmitTaskInput. Use SubmitTaskInput for both permission prompts and generic task input.'
@@ -22,7 +28,7 @@ export const STOP_TASK_DESCRIPTION =
   'Stop a running or blocked task. Use this when the task is no longer needed or cannot recover cleanly.'
 
 export const LIST_TASKS_DESCRIPTION =
-  'List all managed tasks with status, pendingInput, pendingInteraction, lastError, and guidance. Use this first to find which tasks are blocked; then call GetTaskInfo for one task or SubmitTaskInput if it is waiting for input.'
+  'List all managed tasks with status, logs, pendingInput, pendingInteraction, lastError, and guidance. Each task returns the 10 most recent logs by default in descending order, so newer log lines appear earlier in the logs array. Use logLimit and logOrder to adjust the recent log window for every listed task. If a listed task needs another instruction, call SendTaskMessage with mode "direct" or "steer". If it is waiting for input, call GetTaskInfo for details or SubmitTaskInput to answer it.'
 
 export const TASK_PERMISSION_MODE_DESCRIPTION =
   'Permission mode for the task. If omitted, inherits the parent session. Raise it only when the task is blocked by permission errors.'
@@ -30,6 +36,12 @@ export const TASK_PERMISSION_MODE_DESCRIPTION =
 export const TASK_BACKGROUND_DESCRIPTION =
   'Whether to run in background (default: true). If false, waits until the task completes, fails, or becomes blocked waiting for input, then returns the current logs.'
 
+export const TASK_LOG_LIMIT_DESCRIPTION =
+  `How many recent log entries to include. Defaults to ${DEFAULT_TASK_LOG_LIMIT}.`
+
+export const TASK_LOG_ORDER_DESCRIPTION =
+  'Order of the selected log window. Defaults to "desc", which returns newer log lines first. Use "asc" for oldest-to-newest order.'
+
 export const resolveInheritedPermissionMode = (): SessionPermissionMode | undefined => {
   const value = process.env.__VF_PROJECT_AI_PERMISSION_MODE__?.trim()
   if (value == null || value === '') return undefined
@@ -74,20 +86,33 @@ export const serializeTaskInfo = (params: {
   description?: string
   status?: TaskInfo['status']
   info?: TaskInfo
+  logLimit?: number
+  logOrder?: TaskLogsOrder
 }) => {
   const info = params.info
   const safeInfo = (() => {
     if (info == null) {
       return undefined
     }
-    const { session, onStop, serverSync, createdAt, ...rest } = info
+    const { session, onStop, serverSync, createdAt, logs, ...rest } = info
     return rest
   })()
+  const selectedLogs = (() => {
+    const logs = info?.logs ?? []
+    const limit = params.logLimit
+    const windowedLogs = limit == null
+      ? logs
+      : logs.slice(Math.max(0, logs.length - limit))
+    return params.logOrder === 'desc'
+      ? [...windowedLogs].reverse()
+      : windowedLogs
+  })()
+
   return {
     taskId: params.taskId,
     description: params.description ?? info?.description,
     status: info?.status ?? params.status,
-    logs: info?.logs ?? [],
+    logs: selectedLogs,
     pendingInput: safeInfo?.pendingInteraction,
     ...safeInfo,
     guidance: buildTaskGuidance(safeInfo ?? {})

package/src/tools/task/register-task-runtime-tools.ts

@@ -3,11 +3,16 @@ import { z } from 'zod'
 import type { Register } from '../types'
 import type { TaskManager } from './manager'
 import {
+  DEFAULT_TASK_LOG_LIMIT,
   GET_TASK_INFO_DESCRIPTION,
   LIST_TASKS_DESCRIPTION,
   RESPOND_TASK_INTERACTION_DESCRIPTION,
+  SEND_TASK_MESSAGE_DESCRIPTION,
   STOP_TASK_DESCRIPTION,
   SUBMIT_TASK_INPUT_DESCRIPTION,
+  TASK_LOG_LIMIT_DESCRIPTION,
+  TASK_LOG_ORDER_DESCRIPTION,
+  TASK_LOG_ORDERS,
   serializeTaskInfo
 } from './presentation'
 
@@ -21,10 +26,20 @@ export const registerTaskRuntimeTools = (
       title: 'Get Task Info',
       description: GET_TASK_INFO_DESCRIPTION,
       inputSchema: z.object({
-        taskId: z.string().describe('The ID of the task to check')
+        taskId: z.string().describe('The ID of the task to check'),
+        logLimit: z
+          .number()
+          .int()
+          .min(1)
+          .describe(TASK_LOG_LIMIT_DESCRIPTION)
+          .default(DEFAULT_TASK_LOG_LIMIT),
+        logOrder: z
+          .enum(TASK_LOG_ORDERS)
+          .describe(TASK_LOG_ORDER_DESCRIPTION)
+          .default('desc')
       })
     },
-    async ({ taskId }) => {
+    async ({ taskId, logLimit, logOrder }) => {
       const task = taskManager.getTask(taskId)
       if (!task) {
         return {
@@ -35,7 +50,46 @@ export const registerTaskRuntimeTools = (
       return {
         content: [{
           type: 'text',
-          text: JSON.stringify([serializeTaskInfo({ taskId, info: task })])
+          text: JSON.stringify([serializeTaskInfo({ taskId, info: task, logLimit, logOrder })])
+        }]
+      }
+    }
+  )
+
+  server.registerTool(
+    'SendTaskMessage',
+    {
+      title: 'Send Task Message',
+      description: SEND_TASK_MESSAGE_DESCRIPTION,
+      inputSchema: z.object({
+        taskId: z.string().describe('The ID of the running task to continue'),
+        message: z
+          .string()
+          .trim()
+          .min(1)
+          .describe('The follow-up instruction to send to the task'),
+        mode: z
+          .enum(['direct', 'steer'])
+          .describe('How to deliver the message: direct (default) or steer')
+          .default('direct')
+      })
+    },
+    async ({ taskId, message, mode }) => {
+      await taskManager.sendTaskMessage({
+        taskId,
+        message,
+        mode
+      })
+      const task = taskManager.getTask(taskId)
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify([serializeTaskInfo({
+            taskId,
+            info: task,
+            logLimit: DEFAULT_TASK_LOG_LIMIT,
+            logOrder: 'desc'
+          })])
         }]
       }
     }
@@ -67,7 +121,12 @@ export const registerTaskRuntimeTools = (
       return {
         content: [{
           type: 'text',
-          text: JSON.stringify([serializeTaskInfo({ taskId, info: task })])
+          text: JSON.stringify([serializeTaskInfo({
+            taskId,
+            info: task,
+            logLimit: DEFAULT_TASK_LOG_LIMIT,
+            logOrder: 'desc'
+          })])
         }]
       }
     }
@@ -99,7 +158,12 @@ export const registerTaskRuntimeTools = (
       return {
         content: [{
           type: 'text',
-          text: JSON.stringify([serializeTaskInfo({ taskId, info: task })])
+          text: JSON.stringify([serializeTaskInfo({
+            taskId,
+            info: task,
+            logLimit: DEFAULT_TASK_LOG_LIMIT,
+            logOrder: 'desc'
+          })])
         }]
       }
     }
@@ -130,14 +194,30 @@ export const registerTaskRuntimeTools = (
     {
       title: 'List Tasks',
       description: LIST_TASKS_DESCRIPTION,
-      inputSchema: z.object({})
+      inputSchema: z.object({
+        logLimit: z
+          .number()
+          .int()
+          .min(1)
+          .describe(TASK_LOG_LIMIT_DESCRIPTION)
+          .default(DEFAULT_TASK_LOG_LIMIT),
+        logOrder: z
+          .enum(TASK_LOG_ORDERS)
+          .describe(TASK_LOG_ORDER_DESCRIPTION)
+          .default('desc')
+      })
     },
-    async () => {
+    async ({ logLimit, logOrder }) => {
       const tasks = taskManager.getAllTasks()
       return {
         content: [{
           type: 'text',
-          text: JSON.stringify(tasks.map(task => serializeTaskInfo({ taskId: task.taskId, info: task })))
+          text: JSON.stringify(tasks.map(task => serializeTaskInfo({
+            taskId: task.taskId,
+            info: task,
+            logLimit,
+            logOrder
+          })))
         }]
       }
     }