feat: relay mcp_question from serve-mode jobs back to launching session

Add two-way question relay so when a background job's agent asks a
question via mcp_question, it is detected over SSE, formatted with task
context, and forwarded to the launching session as an interactive picker.
The user can answer inline via mc_answer or attach directly to the job.

- New mc_answer tool for responding to pending questions
- SSE detection of question tool calls (running/completed states)
- Backfill on SSE connect for questions fired before subscription
- Toast notifications for questions, completions, and failures
- Session label lookup before title annotation to show correct name

Author: nigel-dev

src/hooks/notifications.ts

@@ -2,12 +2,13 @@ import type { PluginInput } from '@opencode-ai/plugin';
 import type { Job } from '../lib/job-state';
 import { readReport } from '../lib/reports';
 import { formatElapsed } from '../lib/utils';
+import { type PendingQuestion, buildQuestionRelayMessage } from '../lib/question-relay';
 
 type Client = PluginInput['client'];
-type NotificationEvent = 'complete' | 'failed' | 'blocked' | 'needs_review' | 'awaiting_input';
+type NotificationEvent = 'complete' | 'failed' | 'blocked' | 'needs_review' | 'awaiting_input' | 'question';
 
 interface JobMonitorLike {
-  on(event: NotificationEvent, handler: (job: Job) => void): void;
+  on(event: NotificationEvent, handler: (job: Job, ...extra: unknown[]) => void): void;
 }
 
 interface SetupNotificationsOptions {
@@ -105,12 +106,12 @@ export function _getTitleStateForTesting(): Map<string, SessionTitleState> {
   return titleState;
 }
 
-async function sendMessage(client: Client, sessionID: string, text: string): Promise<void> {
+async function sendMessage(client: Client, sessionID: string, text: string, expectReply = false): Promise<void> {
   await client.session.prompt({
     path: { id: sessionID },
     body: {
-      noReply: true,
-      parts: [{ type: 'text' as const, text, ignored: true }],
+      noReply: !expectReply,
+      parts: [{ type: 'text' as const, text, ...(!expectReply && { ignored: true }) }],
     },
   });
 }
@@ -130,9 +131,12 @@ export function setupNotifications(options: SetupNotificationsOptions): void {
   const sent = new Set<string>();
   let pending: Promise<void> = Promise.resolve();
 
-  const notify = async (event: NotificationEvent, job: Job): Promise<void> => {
+  const notify = async (event: NotificationEvent, job: Job, extra?: unknown): Promise<void> => {
     const report = event === 'blocked' || event === 'needs_review' ? await readReport(job.id) : null;
-    const dedupKey = getDedupKey(event, job, report?.timestamp);
+    const questionData = event === 'question' ? extra as PendingQuestion | undefined : undefined;
+    const dedupKey = event === 'question' && questionData
+      ? `question:${job.id}:${questionData.partId}`
+      : getDedupKey(event, job, report?.timestamp);
     if (sent.has(dedupKey)) {
       return;
     }
@@ -152,7 +156,9 @@ export function setupNotifications(options: SetupNotificationsOptions): void {
     const duration = formatElapsed(job.createdAt);
     let message = '';
 
-    if (event === 'complete') {
+    if (event === 'question' && questionData) {
+      message = buildQuestionRelayMessage(questionData);
+    } else if (event === 'complete') {
       message = `🟢 Job '${job.name}' completed in ${duration}. Branch: ${job.branch}. Next: run mc_diff(name: '${job.name}') to review changes, then mc_pr or mc_merge.`;
     } else if (event === 'failed') {
       message = `🔴 Job '${job.name}' failed after ${duration}. Branch: ${job.branch}. Next: run mc_capture(name: '${job.name}') for logs, then mc_attach(name: '${job.name}') to investigate.`;
@@ -166,27 +172,62 @@ export function setupNotifications(options: SetupNotificationsOptions): void {
       message = `👀 Job '${job.name}' needs review (${duration} elapsed). Branch: ${job.branch}.${detail} Next: run mc_diff(name: '${job.name}') and mc_capture(name: '${job.name}') before approving next steps.`;
     }
 
-    await sendMessage(client, sessionID, message);
-    sent.add(dedupKey);
+    let sessionLabel = sessionID;
+    try {
+      const sessionInfo = await client.session.get({ path: { id: sessionID } });
+      const data = (sessionInfo as any)?.data ?? sessionInfo;
+      sessionLabel = data?.title ?? data?.slug ?? sessionID;
+    } catch {
+      // Fall back to raw session ID
+    }
 
     const titleAnnotationMap: Partial<Record<NotificationEvent, string>> = {
       complete: 'done',
       failed: 'failed',
       awaiting_input: 'needs input',
+      question: 'has question',
     };
     const statusText = titleAnnotationMap[event];
     if (statusText) {
       await annotateSessionTitle(client, sessionID, job.name, statusText);
     }
+
+    const toastMap: Partial<Record<NotificationEvent, { variant: 'info' | 'success' | 'warning' | 'error'; title: string }>> = {
+      complete: { variant: 'success', title: `Job "${job.name}" completed` },
+      failed: { variant: 'error', title: `Job "${job.name}" failed` },
+      blocked: { variant: 'warning', title: `Job "${job.name}" is blocked` },
+      awaiting_input: { variant: 'warning', title: `Job "${job.name}" needs input` },
+      needs_review: { variant: 'info', title: `Job "${job.name}" needs review` },
+      question: { variant: 'warning', title: `Job "${job.name}" has a question` },
+    };
+    const toast = toastMap[event];
+    if (toast) {
+      try {
+        await client.tui.showToast({
+          body: {
+            title: toast.title,
+            message: `Switch to session "${sessionLabel}" to respond`,
+            variant: toast.variant,
+            duration: event === 'question' ? 10000 : 5000,
+          },
+        });
+      } catch {
+        // Toast may not be available in all environments
+      }
+    }
+
+    await sendMessage(client, sessionID, message, event === 'question');
+    sent.add(dedupKey);
   };
 
-  const enqueue = (event: NotificationEvent, job: Job): void => {
-    pending = pending.then(() => notify(event, job)).catch(() => {});
+  const enqueue = (event: NotificationEvent, job: Job, extra?: unknown): void => {
+    pending = pending.then(() => notify(event, job, extra)).catch(() => {});
   };
 
   monitor.on('complete', (job) => enqueue('complete', job));
   monitor.on('failed', (job) => enqueue('failed', job));
   monitor.on('blocked', (job) => enqueue('blocked', job));
   monitor.on('needs_review', (job) => enqueue('needs_review', job));
   monitor.on('awaiting_input', (job) => enqueue('awaiting_input', job));
+  monitor.on('question', (job, questionData) => enqueue('question', job, questionData));
 }

src/index.ts

@@ -27,6 +27,7 @@ import { mc_plan_cancel } from './tools/plan-cancel';
 import { mc_plan_approve } from './tools/plan-approve';
 import { mc_report } from './tools/report';
 import { mc_overview } from './tools/overview';
+import { mc_answer } from './tools/answer';
 
 interface SessionWithID {
   id?: string;
@@ -252,7 +253,7 @@ export const MissionControl: Plugin = async ({ client }) => {
     },
     tool: isJobAgent 
       ? { mc_report, mc_status } as any
-      : { mc_launch, mc_jobs, mc_status, mc_diff, mc_pr, mc_merge, mc_sync, mc_cleanup, mc_kill, mc_attach, mc_capture, mc_plan, mc_plan_status, mc_plan_cancel, mc_plan_approve, mc_report, mc_overview },
+      : { mc_launch, mc_jobs, mc_status, mc_diff, mc_pr, mc_merge, mc_sync, mc_cleanup, mc_kill, mc_attach, mc_capture, mc_plan, mc_plan_status, mc_plan_cancel, mc_plan_approve, mc_report, mc_overview, mc_answer },
     event: async ({ event }) => {
       const sessionID = extractSessionIDFromEvent(event);
       if (sessionID) {

src/lib/monitor.ts

@@ -4,13 +4,21 @@ import { isPaneRunning, capturePane, captureExitStatus } from './tmux.js';
 import { loadConfig } from './config.js';
 import { readReport } from './reports.js';
 import { createJobClient } from './sdk-client.js';
-import { QuestionRelay, type PermissionRequest } from './question-relay.js';
+import {
+  QuestionRelay,
+  type PermissionRequest,
+  type PendingQuestion,
+  addPendingQuestion,
+  removePendingQuestion,
+  buildQuestionRelayMessage,
+  clearPendingQuestionsForJob,
+  buildTaskSummary,
+} from './question-relay.js';
 import { loadPlan } from './plan-state.js';
 import { PermissionPolicy, type PermissionPolicyConfig } from './permission-policy.js';
 import type { OpencodeClient } from '@opencode-ai/sdk';
 
-type JobEventType = 'complete' | 'failed' | 'blocked' | 'needs_review' | 'awaiting_input' | 'agent_report';
-type JobEventHandler = (job: Job) => void;
+type JobEventType = 'complete' | 'failed' | 'blocked' | 'needs_review' | 'awaiting_input' | 'agent_report' | 'question';
 
 interface IdleTracker {
   lastOutputHash: string;
@@ -144,9 +152,10 @@ export class JobMonitor extends EventEmitter {
       this.sseSubscriptions.delete(jobId);
       this.questionRelay.cleanup(jobId);
     }
+    clearPendingQuestionsForJob(jobId);
   }
 
-  on(event: JobEventType, handler: JobEventHandler): this {
+  on(event: JobEventType, handler: (job: Job, ...extra: unknown[]) => void): this {
     return super.on(event, handler);
   }
 
@@ -212,11 +221,36 @@ export class JobMonitor extends EventEmitter {
       reconnectAttempts: 0,
     });
 
+    this.backfillPendingQuestions(job, client).catch(() => {});
+
     this.processSSEStream(job, client, abortController).catch((error) => {
       console.error(`[Monitor] SSE stream error for job ${job.name}:`, error);
     });
   }
 
+  private async backfillPendingQuestions(job: Job, client: OpencodeClient): Promise<void> {
+    if (!job.remoteSessionID) return;
+
+    try {
+      const result = await client.session.messages({ path: { id: job.remoteSessionID } });
+      const messages = (result.data ?? result) as Array<{ parts?: Array<Record<string, unknown>> }>;
+      if (!Array.isArray(messages)) return;
+
+      for (const msg of messages) {
+        for (const part of msg.parts ?? []) {
+          if (part.type === 'tool' && part.tool === 'question') {
+            const state = part.state as { status?: string } | undefined;
+            if (state?.status === 'running') {
+              this.handleQuestionToolUpdate(job, part);
+            }
+          }
+        }
+      }
+    } catch {
+      // Non-fatal: backfill failure shouldn't block SSE subscription
+    }
+  }
+
   private async processSSEStream(
     job: Job,
     client: OpencodeClient,
@@ -295,6 +329,10 @@ export class JobMonitor extends EventEmitter {
       }
 
       case 'message.part.updated': {
+        const part = event.properties?.part;
+        if (part?.type === 'tool' && part.tool === 'question') {
+          this.handleQuestionToolUpdate(job, part);
+        }
         this.updateEventAccumulator(job.id, { currentTool: 'streaming' });
         break;
       }
@@ -317,6 +355,47 @@ export class JobMonitor extends EventEmitter {
     }
   }
 
+  private handleQuestionToolUpdate(job: Job, part: any): void {
+    const state = part.state;
+    if (!state) return;
+
+    if (state.status === 'running') {
+      const input = state.input ?? {};
+      const questions = (input.questions ?? []) as Array<{
+        question?: string;
+        header?: string;
+        options?: Array<{ label: string; description?: string }>;
+        multiple?: boolean;
+      }>;
+
+      if (questions.length === 0) return;
+      if (!job.remoteSessionID || !job.port) return;
+
+      const first = questions[0];
+      const pending: PendingQuestion = {
+        jobId: job.id,
+        jobName: job.name,
+        taskSummary: buildTaskSummary(job.prompt),
+        partId: part.id,
+        callID: part.callID,
+        remoteSessionID: job.remoteSessionID,
+        port: job.port,
+        question: first.question ?? '',
+        options: first.options ?? [],
+        header: first.header,
+        multiple: first.multiple,
+        detectedAt: Date.now(),
+      };
+
+      const isNew = addPendingQuestion(pending);
+      if (isNew) {
+        this.emit('question', job, pending);
+      }
+    } else if (state.status === 'completed' || state.status === 'error') {
+      removePendingQuestion(job.id, part.id);
+    }
+  }
+
   private inferPermissionType(event: any): PermissionRequest['type'] {
     const eventData = event.properties || event;
     const metadata = eventData.metadata ?? {};