elanous 0.2.41 → 0.2.43

package/src/core-turn/run-goal-loop.ts

@@ -389,6 +389,8 @@ export interface GoalLoopOptions {
   contextPressureRatio?: number;
   /** 테스트 seam — runCoreTurn 주입(모듈 mock 오염 회피). 기본 = 실제 runCoreTurn. */
   runTurn?: (ctx: CoreTurnContext) => Promise<CoreTurnResult>;
+  /** Drain evidence that arrived while the previous iteration was running. */
+  drainIterationMessages?: () => readonly LLMMessage[];
   /** Test seam — process-owned lifecycle bridge attach. */
   attachLifecycleBridge?: (bus: ChannelBus, runId: string) => () => void;
   /** Test seam — snapshot the child worktree at successful completion. */
@@ -817,6 +819,22 @@ export async function runGoalLoop(
         }, { level: 'info' });
       }
     }
+    // Child results can arrive while runCoreTurn is active. Harvest them at this live
+    // iteration boundary so the next model call sees them without waiting for a new turn.
+    try {
+      const arrived = opts.drainIterationMessages?.() ?? [];
+      if (arrived.length > 0) {
+        messages.push(...arrived);
+        debug.log('goal.loop', 'iteration-messages-drained', {
+          sessionId: ctx.sessionId, ...runAttribution, iteration: iterations + 1, count: arrived.length,
+        }, { level: 'info' });
+      }
+    } catch (error) {
+      debug.log('goal.loop', 'iteration-message-drain-failed', {
+        sessionId: ctx.sessionId, ...runAttribution, iteration: iterations + 1,
+        error: error instanceof Error ? error.message : String(error),
+      }, { level: 'warn' });
+    }
     iterations += 1;
 
     // 이 turn 이 누적한 메시지(assistant 텍스트 + tool_use/result)를 회수해 다음

package/src/core-turn/types.ts

@@ -84,6 +84,8 @@ export interface CoreTurnCallbacks {
   /** Streaming text delta — `full` is the accumulated text across the
    *  entire turn (not just the current round). */
   onText?(delta: string, full: string): void;
+  /** Replace a provisional visible answer after staged synthesis succeeds. */
+  onReplaceText?(full: string): void;
   /** Transient runtime status (for example, a stream retry notice). */
   onStatus?(line: string): void;
   /** The final answer came back enriched with a runtime verification
@@ -147,6 +149,8 @@ export interface CoreTurnContext {
   /** Optional provider request-size hook. Only providers with a measured
    *  serializer consume it; all others retain their existing request path. */
   requestSizeGuard?: LLMOpts['requestSizeGuard'];
+  /** Optional per-turn reasoning effort; high/xhigh/max also opts into the default deep Bloom frame. */
+  reasoningEffort?: LLMOpts['reasoningEffort'];
   /** Tool catalog the model may call this turn. Empty array means
    *  "text-only" — the loop delegates to plain `streamLLM`. */
   tools: LLMToolSpec[];

package/src/dashboard/chat/acp-chat.ts

@@ -89,6 +89,8 @@ export interface AcpChatHandlers {
   /** Append streamed assistant text. Caller accumulates + redraws.
    *  Receives each chunk exactly as the ACP agent emits it. */
   appendChunk: (delta: string) => void;
+  /** Replace the current streamed assistant answer with its authoritative final text. */
+  replaceText?: (fullText: string) => void;
   /** A goal iteration ended; fold only that interim reply in the visible pane. */
   foldGoalInterim?: (text: string) => void;
   /** Called once per tool_call event with a rendered label like
@@ -441,6 +443,14 @@ export class DashboardAcpChat {
         }
         const c = update.content;
         if (c.type === 'text') {
+          const meta = (update as typeof update & { _meta?: { elanous?: { textOperation?: unknown } } })._meta;
+          if (meta?.elanous?.textOperation === 'replace') {
+            this.closeStreamBuffer(sess, 'flush');
+            if (handlers.replaceText) handlers.replaceText(c.text);
+            else handlers.appendChunk(c.text);
+            handlers.redraw?.();
+            return;
+          }
           this.routeText(sess, c.text, handlers);
         }
         return;

package/src/dashboard/classic-sidetab-mission-job.ts

@@ -0,0 +1,161 @@
+import type { PendingTaskNotification } from '../agent/task-notification.js';
+import { debug } from '../debug/log.js';
+import { redactMissionResultPath, type StartedClassicMissionCliJob } from './mission-cli-consumer.js';
+import type { ClassicSidetabMissionResult } from './classic-sidetab-mission.js';
+
+export type ClassicMissionNotificationEnqueue = (notification: PendingTaskNotification) => void;
+export const CLASSIC_SIDETAB_MISSION_LABEL = 'sidetab mission';
+const CLASSIC_SIDETAB_PAIR_TIMEOUT_MS = 60 * 60 * 1_000;
+const MAX_PAIR_ANSWER_CHARS = 12_000;
+export interface ClassicSidetabMissionPairCompletionResult {
+  codex: ClassicSidetabMissionResult;
+  claude: ClassicSidetabMissionResult;
+  status: 'done' | 'error';
+  finishedAt: number;
+}
+type ClassicSidetabPairOutcome = ClassicSidetabMissionResult;
+interface ClassicSidetabMissionPairJob {
+  missionId?: string;
+  taskId: string;
+  parentSessionId?: string;
+  startedAt: number;
+  completion: Promise<ClassicSidetabPairOutcome>;
+}
+
+/** Deliver one eventual sidetab result through the parent's existing task-notification input path. */
+export function enqueueClassicSidetabMissionCompletion(
+  job: StartedClassicMissionCliJob,
+  agent: 'codex' | 'claude',
+  enqueue: ClassicMissionNotificationEnqueue,
+  now: () => number = Date.now,
+): void {
+  let deliveryAttempted = false;
+  const enqueueOnce = (notification: PendingTaskNotification): void => {
+    if (deliveryAttempted) return;
+    deliveryAttempted = true;
+    try {
+      enqueue(notification);
+    } catch {
+      debug.log('classic-sidetab.mission', 'completion-enqueue-failed', {
+        interactionId: job.interactionId,
+        retry: false,
+      });
+    }
+  };
+  const deliver = (result: Awaited<StartedClassicMissionCliJob['completion']>): void => {
+    const finishedAt = now();
+    const state = result.ok ? 'done' : result.status === 'cancelled' ? 'aborted' : 'error';
+    const body = result.ok
+      ? redactMissionResultPath(result.content ?? '', result.path)
+      : redactMissionResultPath(result.error ?? 'Sidetab mission failed; no result was returned', result.path);
+    enqueueOnce({
+      taskId: job.interactionId,
+      agentName: agent === 'codex' ? 'Codex' : 'Claude Code',
+      label: CLASSIC_SIDETAB_MISSION_LABEL,
+      state,
+      output: JSON.stringify({ status: state, body, artifacts: [], id: job.interactionId }),
+      truncated: false,
+      durationMs: Math.max(0, finishedAt - job.startedAt),
+      finishedAt,
+    });
+  };
+  void job.completion.then(deliver).catch(() => {
+    const finishedAt = now();
+    enqueueOnce({
+      taskId: job.interactionId,
+      agentName: agent === 'codex' ? 'Codex' : 'Claude Code',
+      label: CLASSIC_SIDETAB_MISSION_LABEL,
+      state: 'error',
+      output: JSON.stringify({ status: 'error', body: 'Sidetab mission failed before a result was available', artifacts: [], id: job.interactionId }),
+      truncated: false,
+      durationMs: Math.max(0, finishedAt - job.startedAt),
+      finishedAt,
+    });
+  });
+}
+
+/** Deliver a single combined parent notification after both parallel agents finish. */
+export function enqueueClassicSidetabMissionPairCompletion(
+  pair: { codex: ClassicSidetabMissionPairJob; claude: ClassicSidetabMissionPairJob },
+  enqueue: ClassicMissionNotificationEnqueue,
+  now: () => number = Date.now,
+  options: { timeoutMs?: number; onTimeout?: () => void; onComplete?: (result: ClassicSidetabMissionPairCompletionResult) => void } = {},
+): Promise<ClassicSidetabMissionPairCompletionResult> {
+  const taskId = pair.codex.taskId;
+  const startedAt = Math.min(pair.codex.startedAt, pair.claude.startedAt);
+  const timeoutMs = options.timeoutMs ?? CLASSIC_SIDETAB_PAIR_TIMEOUT_MS;
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  const timedOut = new Promise<[ClassicSidetabPairOutcome, ClassicSidetabPairOutcome]>((resolve) => {
+    timeout = setTimeout(() => {
+      try { options.onTimeout?.(); } catch { /* timeout cleanup cannot suppress the receipt */ }
+      const failure = (member: string): ClassicSidetabPairOutcome => ({ ok: false, status: 'failed', error: `${member} sidetab mission exceeded the one-hour safety timeout` });
+      resolve([failure('Codex'), failure('Claude')]);
+    }, Math.max(1, timeoutMs));
+  });
+  return Promise.race([Promise.all([pair.codex.completion, pair.claude.completion]), timedOut]).then(([codex, claude]) => {
+    const finishedAt = now();
+    const ok = codex.ok && claude.ok && Boolean(codex.content?.trim()) && Boolean(claude.content?.trim());
+    const result = { codex, claude, status: ok ? 'done' as const : 'error' as const, finishedAt };
+    try { options.onComplete?.(result); }
+    catch { debug.log('classic-sidetab.mission-pair', 'completion-callback-failed', { taskId, retry: false }); }
+    let truncated = false;
+    const body = (name: string, result: ClassicSidetabPairOutcome): string => {
+      const content = result.content?.trim();
+      const text = result.ok
+        ? content ? redactMissionResultPath(content, result.path) : 'completed without an answer'
+        : redactMissionResultPath(result.error ?? 'no result returned', result.path);
+      if (text.length > MAX_PAIR_ANSWER_CHARS) truncated = true;
+      const bounded = text.length > MAX_PAIR_ANSWER_CHARS
+        ? `${text.slice(0, MAX_PAIR_ANSWER_CHARS)}\n[answer truncated]`
+        : text;
+      return result.ok ? `${name} answer:\n${bounded}` : `${name} failed: ${bounded}`;
+    };
+    const output = JSON.stringify({
+      status: ok ? 'done' : 'error',
+      body: `Concurrent Codex + Claude mission pair (${pair.codex.missionId ?? 'Codex unavailable'} / ${pair.claude.missionId ?? 'Claude unavailable'})\n\n${body('Codex', codex)}\n\n${body('Claude', claude)}`,
+      artifacts: [],
+      id: pair.codex.missionId ?? pair.claude.missionId ?? taskId,
+    });
+    try {
+      enqueue({
+        taskId,
+        ...(pair.codex.parentSessionId ? { parentSessionId: pair.codex.parentSessionId } : {}),
+        agentName: 'Codex + Claude',
+        label: CLASSIC_SIDETAB_MISSION_LABEL,
+        state: ok ? 'done' : 'error',
+        output,
+        truncated,
+        durationMs: Math.max(0, finishedAt - startedAt),
+        finishedAt,
+      });
+    } catch {
+      debug.log('classic-sidetab.mission-pair', 'completion-enqueue-failed', { taskId, retry: false });
+    }
+    return result;
+  }).catch(() => {
+    const finishedAt = now();
+    const failure = (error: string): ClassicSidetabMissionResult => ({ ok: false, status: 'failed', error });
+    const result: ClassicSidetabMissionPairCompletionResult = {
+      codex: failure('Codex/Claude pair failed before results were available'),
+      claude: failure('Codex/Claude pair failed before results were available'),
+      status: 'error', finishedAt,
+    };
+    try { options.onComplete?.(result); } catch { debug.log('classic-sidetab.mission-pair', 'completion-callback-failed', { taskId, retry: false }); }
+    try {
+      enqueue({
+        taskId,
+        ...(pair.codex.parentSessionId ? { parentSessionId: pair.codex.parentSessionId } : {}),
+        agentName: 'Codex + Claude',
+        label: CLASSIC_SIDETAB_MISSION_LABEL,
+        state: 'error',
+        output: JSON.stringify({ status: 'error', body: 'Concurrent Codex/Claude missions failed before results were available', artifacts: [], id: pair.codex.missionId ?? pair.claude.missionId ?? taskId }),
+        truncated: false,
+        durationMs: Math.max(0, finishedAt - startedAt),
+        finishedAt,
+      });
+    } catch {
+      debug.log('classic-sidetab.mission-pair', 'completion-enqueue-failed', { taskId, retry: false });
+    }
+    return result;
+  }).finally(() => { if (timeout) clearTimeout(timeout); });
+}

package/src/dashboard/classic-sidetab-mission-pair.ts

@@ -0,0 +1,81 @@
+import { randomUUID } from 'node:crypto';
+import type { ClassicSidetabMissionPairResult, ClassicSidetabMissionPairSessionRegistry, ClassicSidetabMissionResult, ClassicSidetabMissionDispatchContext } from './classic-sidetab-mission.js';
+import { enqueueClassicSidetabMissionPairCompletion, type ClassicMissionNotificationEnqueue, type ClassicSidetabMissionPairCompletionResult } from './classic-sidetab-mission-job.js';
+
+interface ClassicSidetabPairSession {
+  id: string;
+  cwd: string;
+}
+
+export interface StartClassicSidetabMissionPairDeps<Session extends ClassicSidetabPairSession> {
+  agent: 'codex' | 'claude';
+  mission: string;
+  parallelMission: string;
+  context?: ClassicSidetabMissionDispatchContext;
+  spawnVisible: (agent: 'codex' | 'claude', missionId: string, attemptId: string) => Session | null;
+  runVisible: (agent: 'codex' | 'claude', prompt: string, session: Session | null, missionId?: string) => Promise<ClassicSidetabMissionResult>;
+  registry: ClassicSidetabMissionPairSessionRegistry;
+  hasSession: (sessionId: string) => boolean;
+  killSession: (sessionId: string) => void;
+  enqueue: ClassicMissionNotificationEnqueue;
+  now?: () => number;
+  createId?: () => string;
+  timeoutMs?: number;
+  onComplete?: (result: ClassicSidetabMissionPairCompletionResult) => void;
+}
+
+/** Production seam: start both visible PTYs, bind IDs/cancellation, and deliver one parent-linked completion receipt. */
+export function startClassicSidetabMissionPair<Session extends ClassicSidetabPairSession>(
+  deps: StartClassicSidetabMissionPairDeps<Session>,
+): { result: ClassicSidetabMissionPairResult; completion: Promise<ClassicSidetabMissionPairCompletionResult> } {
+  // Keep Codex as the last-opened PTY regardless of which mission prompt is
+  // primary. The dashboard closes each popup after spawn, detaching its modal
+  // while preserving the session in the sidetab registry. On the tested
+  // Codex-first demo path, opening Codex last avoids a missed follow-up
+  // completion marker; this is a sequencing workaround, not a fix for
+  // background PTY marker detection (tracked by SIDETAB-MARKER-BACKGROUND-DETECT).
+  const createId = deps.createId ?? randomUUID;
+  const codexMissionId = createId();
+  const claudeMissionId = createId();
+  const codexAttemptId = createId();
+  const claudeAttemptId = createId();
+  const claudeSession = deps.spawnVisible('claude', claudeMissionId, claudeAttemptId);
+  const codexSession = deps.spawnVisible('codex', codexMissionId, codexAttemptId);
+  const missionIds = [codexSession ? codexMissionId : undefined, claudeSession ? claudeMissionId : undefined].filter((id): id is string => Boolean(id));
+  const activeCodexMissionId = codexSession ? codexMissionId : undefined;
+  const activeClaudeMissionId = claudeSession ? claudeMissionId : undefined;
+  const sessionIds = [codexSession?.id, claudeSession?.id].filter((id): id is string => Boolean(id));
+  deps.registry.register(missionIds, sessionIds);
+
+  const codexPrompt = deps.agent === 'codex' ? deps.mission : deps.parallelMission;
+  const claudePrompt = deps.agent === 'claude' ? deps.mission : deps.parallelMission;
+  const startedAt = (deps.now ?? Date.now)();
+  const codexCompletion = deps.runVisible('codex', codexPrompt, codexSession, activeCodexMissionId);
+  const claudeCompletion = deps.runVisible('claude', claudePrompt, claudeSession, activeClaudeMissionId);
+  // callId is the parent tool invocation identity; falling back to a mission id
+  // preserves queue uniqueness for embedders that do not expose a call id.
+  const taskId = deps.context?.callId || activeCodexMissionId || activeClaudeMissionId || createId();
+  const completion = missionIds.length
+    ? enqueueClassicSidetabMissionPairCompletion({
+      codex: { missionId: activeCodexMissionId, taskId, parentSessionId: deps.context?.parentSessionId, startedAt, completion: codexCompletion },
+      claude: { missionId: activeClaudeMissionId, taskId, parentSessionId: deps.context?.parentSessionId, startedAt, completion: claudeCompletion },
+    }, deps.enqueue, deps.now, {
+      timeoutMs: deps.timeoutMs,
+      onTimeout: () => { for (const sessionId of sessionIds) if (deps.hasSession(sessionId)) deps.killSession(sessionId); },
+      ...(deps.onComplete ? { onComplete: deps.onComplete } : {}),
+    }).finally(() => deps.registry.clear(missionIds))
+    : Promise.resolve<ClassicSidetabMissionPairCompletionResult>({
+      codex: { ok: false, status: 'failed' as const, error: 'Codex sidetab PTY could not start' },
+      claude: { ok: false, status: 'failed' as const, error: 'Claude sidetab PTY could not start' },
+      status: 'error' as const, finishedAt: (deps.now ?? Date.now)(),
+    });
+
+  return {
+    result: {
+      pairId: `${activeCodexMissionId ?? 'codex-unavailable'}+${activeClaudeMissionId ?? 'claude-unavailable'}`,
+      codex: codexSession ? { ok: true, status: 'running', path: '', interactionId: activeCodexMissionId } : { ok: false, status: 'failed', error: 'Codex sidetab PTY could not start' },
+      claude: claudeSession ? { ok: true, status: 'running', path: '', interactionId: activeClaudeMissionId } : { ok: false, status: 'failed', error: 'Claude sidetab PTY could not start' },
+    },
+    completion,
+  };
+}

package/src/dashboard/classic-sidetab-mission-trio.ts

@@ -0,0 +1,219 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ClassicSidetabMissionDispatchContext, ClassicSidetabMissionPairSessionRegistry, ClassicSidetabMissionResult } from './classic-sidetab-mission.js';
+import { redactMissionResultPath } from './mission-cli-consumer.js';
+import type { ClassicMissionNotificationEnqueue } from './classic-sidetab-mission-job.js';
+
+export type ClassicMissionAgent = 'codex' | 'claude' | 'grok';
+
+interface TrioSession { id: string; cwd: string }
+interface MissionOutcome extends ClassicSidetabMissionResult { content?: string }
+const MAX_FINAL_SCREEN_CHARS = 4_000;
+
+export interface StartClassicSidetabMissionTrioDeps<Session extends TrioSession> {
+  mission: string;
+  context?: ClassicSidetabMissionDispatchContext;
+  checkGrokAuth: () => { ok: boolean; reason?: string } | Promise<{ ok: boolean; reason?: string }>;
+  spawnVisible: (agent: ClassicMissionAgent, missionId: string, attemptId: string) => Session | null;
+  runVisible: (agent: ClassicMissionAgent, mission: string, session: Session | null, missionId?: string) => Promise<MissionOutcome>;
+  registry: ClassicSidetabMissionPairSessionRegistry;
+  hasSession: (sessionId: string) => boolean;
+  killSession: (sessionId: string) => void;
+  enqueue: ClassicMissionNotificationEnqueue;
+  now?: () => number;
+  createId?: () => string;
+  timeoutMs?: number;
+}
+
+export interface ClassicSidetabMissionTrioStart {
+  trioId: string;
+  members: Record<ClassicMissionAgent, ClassicSidetabMissionResult>;
+  grokFallback?: string;
+}
+
+const DEFAULT_TIMEOUT_MS = 60 * 60 * 1_000;
+const MAX_ANSWER_CHARS = 8_000;
+
+function markdownCell(value: string | undefined): string {
+  return (value ?? '—').replaceAll('|', '\\|').replace(/\r?\n/g, '<br>');
+}
+
+function fenced(value: string): string {
+  const longest = Math.max(0, ...[...value.matchAll(/`+/g)].map((match) => match[0].length));
+  const fence = '`'.repeat(Math.max(3, longest + 1));
+  return `${fence}text\n${value}\n${fence}`;
+}
+
+function renderTrioSynthesis(mission: string, results: Record<ClassicMissionAgent, MissionOutcome>): string {
+  const agents: ClassicMissionAgent[] = ['codex', 'claude', 'grok'];
+  const rows = agents.map((agent) => {
+    const result = results[agent];
+    return `| ${agent} | ${markdownCell(mission)} | ${markdownCell(result.path)} | ${result.ok ? '완료' : markdownCell(result.error ?? result.status ?? '실패')} |  |`;
+  });
+  const candidates = agents.map((agent) => {
+    const result = results[agent];
+    return [`### ${agent}`, `- 결과 경로: ${result.path ?? '없음'}`, `- 상태: ${result.ok ? '완료' : result.error ?? result.status ?? '실패'}`, '', result.content?.trim() ? fenced(result.content.trim()) : '_결과 내용 없음_'].join('\n');
+  });
+  return [
+    '# Sidetab mission synthesis record',
+    '',
+    '## 요청',
+    fenced(mission),
+    '',
+    '## 손별 귀속',
+    '| 손 | 맡은 일 | 결과 파일 | 결과 상태 | 채택 여부 |',
+    '| --- | --- | --- | --- | --- |',
+    ...rows,
+    '',
+    '## 후보 결과',
+    ...candidates,
+    '',
+    '## 채택 결과',
+    '_부모 응답에서 확정_',
+    '',
+    '## 채택 근거',
+    '_부모 응답에서 확정_',
+    '',
+  ].join('\n');
+}
+
+function persistTrioSynthesis(cwd: string, trioId: string, mission: string, results: Record<ClassicMissionAgent, MissionOutcome>): string {
+  const safeId = trioId.replace(/[^a-zA-Z0-9._-]/g, '-').slice(0, 120) || randomUUID();
+  const dir = join(cwd, '.elanous', 'mission-results');
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `classic-trio-synthesis-${safeId}.md`);
+  writeFileSync(path, renderTrioSynthesis(mission, results), { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+  return path;
+}
+
+/** Starts three visible PTYs with one verbatim goal; an unavailable Grok degrades to Codex + Claude. */
+export async function startClassicSidetabMissionTrio<Session extends TrioSession>(
+  deps: StartClassicSidetabMissionTrioDeps<Session>,
+): Promise<{ result: ClassicSidetabMissionTrioStart; completion: Promise<void> }> {
+  const createId = deps.createId ?? randomUUID;
+  const now = deps.now ?? Date.now;
+  const startedAt = now();
+  // Start the first hand before the bounded subscribed-access probe. The
+  // probe may need a network round-trip, but must not consume the whole
+  // 30-second three-hand startup budget before any visible work begins.
+  const ids = new Map<ClassicMissionAgent, string>();
+  const sessions = new Map<ClassicMissionAgent, Session | null>();
+  const agents: ClassicMissionAgent[] = [];
+  const spawn = (agent: ClassicMissionAgent): Session | null => {
+    const missionId = createId();
+    ids.set(agent, missionId);
+    agents.push(agent);
+    const session = deps.spawnVisible(agent, missionId, createId());
+    if (!session) {
+      ids.delete(agent);
+      agents.pop();
+      return null;
+    }
+    sessions.set(agent, session);
+    return session;
+  };
+  spawn('claude');
+  spawn('codex');
+  const grokAuth = await deps.checkGrokAuth();
+  let grokFallback = grokAuth.ok ? undefined : grokAuth.reason ?? 'Grok login unavailable';
+  if (grokAuth.ok && !spawn('grok')) {
+    grokFallback = 'Grok sidetab PTY could not start';
+  }
+  const sessionIds = [...sessions.values()].flatMap((session) => session ? [session.id] : []);
+  const missionIds = [...ids.values()];
+  deps.registry.register(missionIds, sessionIds);
+  const outcomes = new Map<ClassicMissionAgent, Promise<MissionOutcome>>();
+  for (const agent of agents) {
+    const session = sessions.get(agent) ?? null;
+    if (agent === 'grok' && !session) continue;
+    outcomes.set(agent, Promise.resolve().then(() => deps.runVisible(agent, deps.mission, session, ids.get(agent))).catch((error) => ({
+      ok: false, status: 'failed', error: error instanceof Error ? error.message : String(error),
+    })));
+  }
+  const members: Record<ClassicMissionAgent, ClassicSidetabMissionResult> = {
+    codex: sessions.get('codex') ? { ok: true, status: 'running', interactionId: ids.get('codex') } : { ok: false, status: 'failed', error: 'Codex sidetab PTY could not start' },
+    claude: sessions.get('claude') ? { ok: true, status: 'running', interactionId: ids.get('claude') } : { ok: false, status: 'failed', error: 'Claude sidetab PTY could not start' },
+    grok: sessions.get('grok') ? { ok: true, status: 'running', interactionId: ids.get('grok') } : { ok: false, status: 'failed', error: grokFallback ?? 'Grok sidetab PTY could not start' },
+  };
+  const taskId = deps.context?.callId || ids.get('codex') || ids.get('claude') || createId();
+  const timeoutMs = Math.max(1, deps.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  const timedOut = new Promise<void>((resolve) => {
+    timeout = setTimeout(() => {
+      for (const sessionId of sessionIds) if (deps.hasSession(sessionId)) deps.killSession(sessionId);
+      resolve();
+    }, timeoutMs);
+  });
+  const settled = Promise.all([...outcomes].map(async ([agent, promise]) => [agent, await promise] as const));
+  const completion = Promise.race([settled.then((results) => ({ didTimeout: false, results })), timedOut.then(() => ({ didTimeout: true, results: [] as const }))]).then(({ didTimeout, results }) => {
+    const finishedAt = now();
+    const all: Record<ClassicMissionAgent, MissionOutcome> = {
+      codex: { ...members.codex, ...(members.codex.status === 'running' ? { error: undefined } : {}) },
+      claude: { ...members.claude, ...(members.claude.status === 'running' ? { error: undefined } : {}) },
+      grok: { ...members.grok, ...(members.grok.status === 'running' ? { error: undefined } : {}) },
+    };
+    for (const [agent, outcome] of results) all[agent] = outcome;
+    let synthesisPath: string | undefined;
+    let synthesisError: string | undefined;
+    const artifactCwd = [...sessions.values()].find((session): session is Session => Boolean(session))?.cwd;
+    if (artifactCwd) {
+      try {
+        const trioId = `trio-${ids.get('codex') ?? ids.get('claude') ?? createId()}`;
+        synthesisPath = persistTrioSynthesis(artifactCwd, trioId, deps.mission, all);
+        debug.log('classic-sidetab.mission-trio', 'synthesis-record-written', {
+          taskId,
+          trioId,
+          resultPath: synthesisPath,
+          candidateCount: Object.values(all).filter((result) => Boolean(result.path || result.content)).length,
+        });
+      } catch (error) {
+        synthesisError = error instanceof Error ? error.message : String(error);
+      }
+    } else {
+      synthesisError = 'no sidetab workspace was available for the synthesis record';
+    }
+    const timeoutReason = didTimeout ? 'mission exceeded the one-hour safety timeout' : undefined;
+    const answer = (agent: ClassicMissionAgent): string => {
+      const result = all[agent];
+      const screen = result.finalScreen?.trim();
+      const screenRecord = screen ? `\n\n${agent} final raw PTY screen:\n${screen.length > MAX_FINAL_SCREEN_CHARS ? `${screen.slice(-MAX_FINAL_SCREEN_CHARS)}\n[screen tail truncated]` : screen}` : '';
+      const initial = result.initialScreen?.trim();
+      const initialRecord = initial ? `\n\n${agent} first PTY snapshot:\n${initial.length > 1_200 ? `${initial.slice(-1_200)}\n[first screen tail truncated]` : initial}` : '';
+      if (timeoutReason && (result.status === 'running' || result.error === undefined)) return `${agent}: ${timeoutReason}${initialRecord}${screenRecord}`;
+      if (!result.ok) return `${agent}: ${result.error ?? 'failed; no answer returned'}${initialRecord}${screenRecord}`;
+      const content = result.content?.trim();
+      if (!content) return `${agent}: completed without an answer${screenRecord}`;
+      const safe = redactMissionResultPath(content, result.path);
+      return `${agent} candidate:\n${safe.length > MAX_ANSWER_CHARS ? `${safe.slice(0, MAX_ANSWER_CHARS)}\n[answer truncated]` : safe}${initialRecord}${screenRecord}`;
+    };
+    const grokFailed = !all.grok.ok;
+    const body = [
+      `Three-hand comparison · same goal · ${grokFailed ? `Grok unavailable; continued with Codex + Claude (${all.grok.error ?? 'failed'})` : 'Codex + Claude + Grok results'}`,
+      synthesisPath ? `Synthesis record: ${synthesisPath}` : `Synthesis record unavailable: ${synthesisError ?? 'unknown write failure'}`,
+      'The record contains the candidate results and attribution table; fill its adoption and rationale sections with the selected synthesis.',
+      '', answer('codex'), '', answer('claude'), '', answer('grok'), '',
+      'Compare the available candidates, select or combine the strongest answer, and present the adopted result with a short reason. Do not claim an unavailable or failed candidate succeeded.',
+    ].join('\n');
+    try {
+      deps.enqueue({
+        taskId,
+        ...(deps.context?.parentSessionId ? { parentSessionId: deps.context.parentSessionId } : {}),
+        agentName: grokFailed ? 'Codex + Claude (Grok fallback)' : 'Codex + Claude + Grok',
+        label: 'sidetab mission comparison',
+        state: all.codex.ok && all.claude.ok ? 'done' : 'error',
+        output: JSON.stringify({ status: grokFailed ? 'partial' : 'done', body, artifacts: synthesisPath ? [synthesisPath] : [], id: ids.get('codex') ?? ids.get('claude') ?? taskId, grokFallback: grokFailed ? all.grok.error : undefined }),
+        ...(synthesisPath ? { resultPath: synthesisPath } : {}),
+        truncated: body.includes('[answer truncated]'),
+        durationMs: Math.max(0, finishedAt - startedAt),
+        finishedAt,
+      });
+    } catch { /* notification delivery cannot interrupt the missions */ }
+  }).finally(() => {
+    if (timeout) clearTimeout(timeout);
+    for (const sessionId of sessionIds) if (deps.hasSession(sessionId)) deps.killSession(sessionId);
+    deps.registry.clear(missionIds);
+  });
+
+  return { result: { trioId: `trio-${ids.get('codex') ?? ids.get('claude') ?? createId()}`, members, ...(grokFallback ? { grokFallback } : {}) }, completion };
+}