@vibe-forge/mcp 2.0.2-alpha.1 → 3.0.0-alpha.0

package/__tests__/task-manager.spec.ts

@@ -156,6 +156,47 @@ describe('taskManager fatal error scenarios', () => {
     )
   })
 
+  it('forwards task model overrides into query resolution and runtime startup', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+
+    mocks.run.mockResolvedValueOnce({
+      session: {
+        emit: vi.fn(),
+        kill: vi.fn()
+      }
+    })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-model-override',
+      description: 'trigger',
+      adapter: 'codex',
+      model: 'openai,gpt-5.4-mini'
+    })
+
+    expect(mocks.generateAdapterQueryOptions).toHaveBeenCalledWith(
+      undefined,
+      undefined,
+      expect.any(String),
+      expect.objectContaining({
+        adapter: 'codex',
+        model: 'openai,gpt-5.4-mini'
+      })
+    )
+    expect(mocks.run).toHaveBeenCalledWith(
+      expect.objectContaining({
+        adapter: 'codex'
+      }),
+      expect.objectContaining({
+        sessionId: 'task-model-override',
+        model: 'openai,gpt-5.4-mini'
+      })
+    )
+    expect(managedTaskManager.getTask('task-model-override')).toEqual(expect.objectContaining({
+      model: 'openai,gpt-5.4-mini'
+    }))
+  })
+
   it('responds to pending interactions and syncs the response', async () => {
     const { TaskManager } = await import('#~/tools/task/manager.js')
     const respondInteraction = vi.fn()
@@ -265,7 +306,13 @@ describe('taskManager fatal error scenarios', () => {
     })
 
     const task = managedTaskManager.getTask('task-send-synced')
-    expect(emit).toHaveBeenCalledTimes(1)
+    expect(emit).toHaveBeenNthCalledWith(2, {
+      type: 'message',
+      content: [{
+        type: 'text',
+        text: 'keep going'
+      }]
+    })
     expect(mocks.postSessionEvent).toHaveBeenCalledWith('task-send-synced', {
       type: 'message',
       data: expect.objectContaining({
@@ -276,6 +323,84 @@ describe('taskManager fatal error scenarios', () => {
     expect(task?.logs).toContain('User message submitted (direct): keep going')
   })
 
+  it('does not replay stale synced messages after a failed resume attempt', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+    let onEvent: ((event: any) => void) | undefined
+    const resumedEmit = vi.fn()
+    const syncedEvents: Array<{ type: 'message'; message: Record<string, unknown> }> = []
+
+    mocks.postSessionEvent.mockImplementation(async (_sessionId: string, payload: any) => {
+      if (payload?.type === 'message' && payload.data != null) {
+        syncedEvents.push({
+          type: 'message',
+          message: payload.data
+        })
+      }
+    })
+    mocks.fetchSessionMessages.mockImplementation(async () => syncedEvents)
+
+    mocks.run
+      .mockImplementationOnce(async (_options: unknown, adapterOptions: any) => {
+        onEvent = adapterOptions.onEvent
+        return {
+          session: {
+            emit: vi.fn(),
+            kill: vi.fn()
+          }
+        }
+      })
+      .mockRejectedValueOnce(new Error('resume failed to start'))
+      .mockResolvedValueOnce({
+        session: {
+          emit: resumedEmit,
+          kill: vi.fn()
+        }
+      })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-send-synced-retry',
+      description: 'trigger',
+      enableServerSync: true
+    })
+
+    onEvent?.({
+      type: 'stop',
+      data: undefined
+    })
+
+    await expect(managedTaskManager.sendTaskMessage({
+      taskId: 'task-send-synced-retry',
+      message: 'first retry'
+    })).rejects.toThrow('resume failed to start')
+
+    const firstMessage = syncedEvents.at(-1)?.message
+    const taskAfterFailure = managedTaskManager.getTask('task-send-synced-retry')
+    expect(firstMessage).toEqual(expect.objectContaining({
+      id: expect.any(String),
+      role: 'user',
+      content: 'first retry'
+    }))
+    expect(taskAfterFailure?.serverSync?.seenMessageIds.has(String(firstMessage?.id))).toBe(true)
+
+    await managedTaskManager.sendTaskMessage({
+      taskId: 'task-send-synced-retry',
+      message: 'second retry'
+    })
+    await new Promise(resolve => setTimeout(resolve, 0))
+
+    expect(resumedEmit).toHaveBeenCalledTimes(1)
+    expect(resumedEmit).toHaveBeenCalledWith({
+      type: 'message',
+      content: [{
+        type: 'text',
+        text: 'second retry'
+      }]
+    })
+
+    managedTaskManager.stopTask('task-send-synced-retry')
+  })
+
   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
@@ -410,23 +535,81 @@ describe('taskManager fatal error scenarios', () => {
     })).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 () => {
+  it('resumes completed tasks when sending a direct follow-up message', 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 {
+    mocks.run
+      .mockImplementationOnce(async (_options: unknown, adapterOptions: any) => {
+        onEvent = adapterOptions.onEvent
+        return {
+          session: {
+            emit: vi.fn(),
+            kill: vi.fn()
+          }
+        }
+      })
+      .mockResolvedValueOnce({
         session: {
-          emit: vi.fn(),
+          emit: resumedEmit,
           kill: vi.fn()
         }
-      }
+      })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-send-completed-direct',
+      description: 'trigger'
     })
 
+    onEvent?.({
+      type: 'stop',
+      data: undefined
+    })
+
+    await managedTaskManager.sendTaskMessage({
+      taskId: 'task-send-completed-direct',
+      message: 'continue from the final summary'
+    })
+
+    const task = managedTaskManager.getTask('task-send-completed-direct')
+    expect(mocks.run).toHaveBeenCalledTimes(2)
+    expect(resumedEmit).toHaveBeenCalledWith({
+      type: 'message',
+      content: [{
+        type: 'text',
+        text: 'continue from the final summary'
+      }]
+    })
+    expect(task?.logs).toContain('Resuming inactive task (direct): continue from the final summary')
+  })
+
+  it('resumes completed tasks when sending a steer follow-up message', 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-completed',
+      taskId: 'task-send-completed-steer',
       description: 'trigger'
     })
 
@@ -435,11 +618,22 @@ describe('taskManager fatal error scenarios', () => {
       data: undefined
     })
 
-    await expect(managedTaskManager.sendTaskMessage({
-      taskId: 'task-send-completed',
+    await managedTaskManager.sendTaskMessage({
+      taskId: 'task-send-completed-steer',
       message: 'queue this for later',
       mode: 'steer'
-    })).rejects.toThrow('Task task-send-completed is not active. Start a new task instead.')
+    })
+
+    const task = managedTaskManager.getTask('task-send-completed-steer')
+    expect(mocks.run).toHaveBeenCalledTimes(2)
+    expect(resumedEmit).toHaveBeenCalledWith({
+      type: 'message',
+      content: [{
+        type: 'text',
+        text: 'queue this for later'
+      }]
+    })
+    expect(task?.logs).toContain('Resuming inactive task (steer): queue this for later')
   })
 
   it('builds synthetic permission recovery for claude-code and resumes after SubmitTaskInput', async () => {

package/__tests__/task-tool.spec.ts

@@ -119,6 +119,35 @@ describe('task tool integration', () => {
     }))
   })
 
+  it('passes explicit task model overrides to the hook and task manager', async () => {
+    const { createTaskRegister } = await import('#~/tools/task/index.js')
+
+    const tester = createToolTester()
+    createTaskRegister()(tester.mockRegister)
+
+    await tester.callTool('StartTasks', {
+      tasks: [{
+        description: 'investigate flaky tests',
+        type: 'default',
+        model: 'gpt-5.4-mini'
+      }]
+    })
+
+    expect(mocks.callHook).toHaveBeenCalledWith(
+      'StartTasks',
+      expect.objectContaining({
+        tasks: [expect.objectContaining({
+          taskId: 'task-1',
+          model: 'gpt-5.4-mini'
+        })]
+      })
+    )
+    expect(mocks.startTask).toHaveBeenCalledWith(expect.objectContaining({
+      taskId: 'task-1',
+      model: 'gpt-5.4-mini'
+    }))
+  })
+
   it('inherits the parent permission mode when the task does not specify one', async () => {
     process.env.__VF_PROJECT_AI_PERMISSION_MODE__ = 'dontAsk'
     mocks.getParentSessionId.mockReturnValue('parent-session')

package/package.json

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

package/src/tools/task/index.ts

@@ -12,6 +12,7 @@ import {
   SESSION_PERMISSION_MODES,
   START_TASKS_DESCRIPTION,
   TASK_BACKGROUND_DESCRIPTION,
+  TASK_MODEL_DESCRIPTION,
   TASK_PERMISSION_MODE_DESCRIPTION,
   resolveInheritedPermissionMode,
   serializeTaskInfo
@@ -50,6 +51,10 @@ export const createTaskRegister = () => {
                   .string()
                   .describe('The adapter to use for the task (e.g. claude-code)')
                   .optional(),
+                model: z
+                  .string()
+                  .describe(TASK_MODEL_DESCRIPTION)
+                  .optional(),
                 permissionMode: z
                   .enum(SESSION_PERMISSION_MODES)
                   .describe(TASK_PERMISSION_MODE_DESCRIPTION)

package/src/tools/task/manager.ts

@@ -51,6 +51,7 @@ type ManagedTaskSession = McpTaskSession & {
 export interface TaskInfo {
   taskId: string
   adapter?: string
+  model?: string
   description: string
   type?: 'default' | 'spec' | 'entity' | 'workspace'
   name?: string
@@ -143,6 +144,25 @@ const formatPermissionErrorLog = (error: AdapterErrorData) => {
   return parts.length > 0 ? parts.join(' | ') : undefined
 }
 
+const createTaskUserMessageEvent = (taskId: string, message: string) => ({
+  type: 'message' as const,
+  data: {
+    id: `task-user:${taskId}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`,
+    role: 'user' as const,
+    content: message,
+    createdAt: Date.now()
+  }
+})
+
+const createTaskSessionMessageEvent = (message: string, parentUuid?: string) => ({
+  type: 'message' as const,
+  content: [{
+    type: 'text' as const,
+    text: message
+  }],
+  ...(parentUuid != null ? { parentUuid } : {})
+})
+
 export class TaskManager {
   private tasks: Map<string, TaskInfo> = new Map()
   private permissionToolUseCache = new Map<string, Map<string, string>>()
@@ -236,15 +256,27 @@ export class TaskManager {
     name?: string
     permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions'
     adapter?: string
+    model?: string
     background?: boolean
     enableServerSync?: boolean
   }): Promise<{ taskId: string; logs?: string[] }> {
-    const { taskId, adapter, description, type, name, permissionMode, background = true, enableServerSync } = options
+    const {
+      taskId,
+      adapter,
+      model,
+      description,
+      type,
+      name,
+      permissionMode,
+      background = true,
+      enableServerSync
+    } = options
 
     // Initialize Task Info
     const taskInfo: TaskInfo = {
       taskId,
       adapter,
+      model,
       description,
       type,
       name,
@@ -287,7 +319,11 @@ export class TaskManager {
     return { taskId }
   }
 
-  private async launchTask(task: TaskInfo, runType: 'create' | 'resume', resumeMessage?: string) {
+  private async launchTask(
+    task: TaskInfo,
+    runType: 'create' | 'resume',
+    resumeMessage?: string
+  ) {
     try {
       const rootCwd = process.cwd()
       const promptType = task.type !== 'default' ? task.type : undefined
@@ -298,7 +334,8 @@ export class TaskManager {
         promptName,
         promptCWD,
         {
-          adapter: task.adapter
+          adapter: task.adapter,
+          model: task.model
         }
       )
       const taskCwd = resolvedConfig.workspace?.cwd ?? promptCWD
@@ -331,6 +368,7 @@ export class TaskManager {
         runtime: 'mcp',
         mode: 'stream',
         sessionId: task.taskId,
+        model: task.model,
         systemPrompt: mergeSystemPrompts({
           generatedSystemPrompt: resolvedConfig.systemPrompt,
           injectDefaultSystemPrompt
@@ -372,13 +410,11 @@ export class TaskManager {
         )
       }
       this.startServerPolling(task.taskId)
-      session.emit({
-        type: 'message',
-        content: [{
-          type: 'text',
-          text: resumeMessage ?? (runType === 'resume' ? TASK_PERMISSION_CONTINUE_PROMPT : current.description)
-        }]
-      })
+      this.emitTaskUserMessage(
+        current,
+        current.session,
+        resumeMessage ?? (runType === 'resume' ? TASK_PERMISSION_CONTINUE_PROMPT : current.description)
+      )
     } catch (err) {
       const current = this.tasks.get(task.taskId)
       if (current) {
@@ -605,6 +641,27 @@ export class TaskManager {
     return Array.from(this.tasks.values())
   }
 
+  private async syncTaskUserMessage(task: TaskInfo, message: string) {
+    if (task.serverSync == null) {
+      return
+    }
+
+    const event = createTaskUserMessageEvent(task.taskId, message)
+    await postSessionEvent(task.serverSync.sessionId, event)
+    task.serverSync.seenMessageIds.add(event.data.id)
+  }
+
+  private emitTaskUserMessage(task: TaskInfo, session: ManagedTaskSession, message: string) {
+    session.emit(createTaskSessionMessageEvent(message, task.serverSync?.lastAssistantMessageId))
+  }
+
+  private async resumeTaskWithMessage(task: TaskInfo, message: string, logMessage: string) {
+    await this.syncTaskUserMessage(task, message)
+    task.status = 'running'
+    appendTaskLog(task, logMessage)
+    await this.launchTask(task, 'resume', message)
+  }
+
   public async sendTaskMessage(params: {
     taskId: string
     message: string
@@ -627,36 +684,25 @@ export class TaskManager {
 
     if (mode === 'steer') {
       if (task.status === 'completed' || task.status === 'failed') {
-        throw new Error(`Task ${params.taskId} is not active. Start a new task instead.`)
+        await this.resumeTaskWithMessage(task, message, `Resuming inactive task (${mode}): ${message}`)
+        return
       }
       task.queuedSteerMessages.push(message)
       appendTaskLog(task, `Queued task message (${mode}): ${message}`)
       return
     }
 
+    if (task.status === 'completed' || task.status === 'failed') {
+      await this.resumeTaskWithMessage(task, message, `Resuming inactive task (${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
-        }]
-      })
-    }
+    await this.syncTaskUserMessage(task, message)
+    this.emitTaskUserMessage(task, task.session, message)
 
     appendTaskLog(task, `User message submitted (${mode}): ${message}`)
   }
@@ -667,9 +713,7 @@ export class TaskManager {
       return false
     }
 
-    task.status = 'running'
-    appendTaskLog(task, `Resuming task from steer queue: ${nextMessage}`)
-    await this.launchTask(task, 'resume', nextMessage)
+    await this.resumeTaskWithMessage(task, nextMessage, `Resuming task from steer queue: ${nextMessage}`)
     return true
   }
 

package/src/tools/task/presentation.ts

@@ -10,13 +10,13 @@ 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. 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.'
+  '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, use SendTaskMessage: running tasks continue immediately, while completed or failed tasks resume the same conversation instead of forcing 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. 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.'
+  '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 you need to continue the task, call SendTaskMessage with mode "direct" or "steer": active tasks continue immediately, while completed or failed tasks resume the same conversation. 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.'
+  '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. If the task already completed or failed and you still want to keep working in that same conversation, SendTaskMessage resumes the same task session instead of starting a replacement task. Do not use this to answer pendingInput or pendingInteraction; use SubmitTaskInput for that.'
 
 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. 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.'
@@ -33,6 +33,9 @@ export const LIST_TASKS_DESCRIPTION =
 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.'
 
+export const TASK_MODEL_DESCRIPTION =
+  'Model override for the task. Uses the same model selector format as a normal session model setting.'
+
 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.'
 
@@ -75,7 +78,7 @@ const buildTaskGuidance = (task: {
   }
 
   if (task.status === 'failed' && hints.length === 0) {
-    hints.push('Task failed. Inspect logs and lastError, then restart the task if needed.')
+    hints.push('Task failed. Inspect logs and lastError, then use SendTaskMessage to resume it or StartTasks to replace it if needed.')
   }
 
   return hints