elanous 0.2.11 → 0.2.13

package/skills/omni-digest/src/media.ts

@@ -8,11 +8,11 @@
  * X 는 media.variants 로 MP4 직링크를 주므로 yt-dlp 없이 curl 로 바로 받는다.
  */
 
-import { execFile as execFileCb, execFileSync } from 'node:child_process';
+import { execFile as execFileCb } from 'node:child_process';
 import { mkdir, readdir, readFile, rm } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
+import { accessSync, constants, existsSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, delimiter } from 'node:path';
 import { promisify } from 'node:util';
 import { env } from './env.js';
 import type { TweetMedia } from './types.js';
@@ -25,10 +25,22 @@ const MAX_DURATION_MS = Number(env('OMNI_DIGEST_MEDIA_MAX_MS', String(20 * 60 *
 const CHUNK_SECONDS = 600;
 
 function has(bin: string): boolean {
-  try {
-    execFileSync('which', [bin], { stdio: 'ignore' });
-    return true;
-  } catch { return false; }
+  for (const dir of (process.env.PATH ?? '').split(delimiter).filter(Boolean)) {
+    try { accessSync(join(dir, bin), constants.X_OK); return true; } catch { /* try next directory */ }
+  }
+  return false;
+}
+
+const missingEngines = new Set<string>();
+
+export function mediaEngineAvailable(engine: 'ffmpeg' | 'whisper'): boolean {
+  if (has(engine)) return true;
+  if (!missingEngines.has(engine)) {
+    missingEngines.add(engine);
+    if (engine === 'ffmpeg') console.error('ffmpeg 없음 — 영상 오디오 추출·전사 빠짐 · 설치하면 영상 전사 켜짐');
+    else console.error('whisper 없음 — 로컬 음성 전사 빠짐 · 설치하면 오프라인 전사 켜짐 (youtube-master 폴백은 계속)');
+  }
+  return false;
 }
 
 async function run(bin: string, args: string[]): Promise<string> {
@@ -47,7 +59,7 @@ export async function downloadVideo(url: string, outdir: string): Promise<string
 
 /** 영상에서 16kHz 모노 mp3 를 추출한다 (STT 엔진 공통 입력 규격). */
 export async function extractAudio(videoPath: string, outdir: string): Promise<string> {
-  if (!has('ffmpeg')) throw new Error('ffmpeg 가 필요합니다 (brew install ffmpeg)');
+  if (!mediaEngineAvailable('ffmpeg')) throw new Error('ffmpeg 가 필요합니다 (brew install ffmpeg)');
   const out = join(outdir, 'audio.mp3');
   await run('ffmpeg', [
     '-hide_banner', '-loglevel', 'error', '-y',
@@ -61,7 +73,7 @@ export async function extractAudio(videoPath: string, outdir: string): Promise<s
 
 /** 로컬 whisper CLI 전사. 미설치면 null 을 반환해 폴백을 유도한다. */
 async function transcribeLocalWhisper(audioPath: string, outdir: string, lang: string): Promise<string | null> {
-  if (!has('whisper')) return null;
+  if (!mediaEngineAvailable('whisper')) return null;
   const model = env('OMNI_DIGEST_WHISPER_MODEL', 'small');
   try {
     await run('whisper', [
@@ -81,11 +93,12 @@ async function transcribeLocalWhisper(audioPath: string, outdir: string, lang: s
 }
 
 /** youtube-master 의 STT 체인(ElevenLabs → OpenAI → Gemini)으로 폴백. */
-async function transcribeViaYoutubeMaster(audioPath: string, outdir: string): Promise<string | null> {
+export async function transcribeViaYoutubeMaster(audioPath: string, outdir: string): Promise<string | null> {
   const skillRoot = env('YOUTUBE_MASTER_ROOT', join(process.env.HOME || '', '.claude/skills/youtube-master'));
   const script = join(skillRoot, 'scripts/transcribe-local.ts');
   if (!existsSync(script)) return null;
 
+  if (!mediaEngineAvailable('ffmpeg')) return null;
   // transcribe-local.ts 는 chunk_%03d.mp3 가 든 디렉터리를 입력으로 받는다
   const chunksDir = join(outdir, 'chunks');
   await mkdir(chunksDir, { recursive: true });
@@ -98,7 +111,7 @@ async function transcribeViaYoutubeMaster(audioPath: string, outdir: string): Pr
 
   const outFile = join(outdir, 'transcript.txt');
   try {
-    await run('npx', ['tsx', script, chunksDir, outFile]);
+    await run(process.execPath, [script, chunksDir, outFile]);
     const text = (await readFile(outFile, 'utf-8')).trim();
     return text || null;
   } catch {
@@ -137,6 +150,7 @@ export async function transcribeTweetMedia(
     console.log(`  영상 ${Math.round(video.durationMs / 1000)}s — 상한(${Math.round(MAX_DURATION_MS / 1000)}s) 초과로 전사 생략`);
     return null;
   }
+  if (!mediaEngineAvailable('ffmpeg')) return null;
 
   const workdir = join(tmpdir(), `omni-digest-media-${video.mediaKey}`);
   try {

package/skills/omni-digest/src/visual.ts

@@ -13,7 +13,7 @@ import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'n
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { env, requireEnv } from './env.js';
-import { downloadVideo } from './media.js';
+import { downloadVideo, mediaEngineAvailable } from './media.js';
 import type { TweetMedia } from './types.js';
 
 const MAX_FRAMES = 8;
@@ -101,7 +101,8 @@ export async function absorbTweetVisuals(media: TweetMedia[], opts: { tweetId: s
       } catch (e) { log(`  [시각] 이미지 ${i + 1} 실패: ${String(e).slice(0, 120)}`); }
     }
     const videos = media.filter((m) => (m.type === 'video' || m.type === 'animated_gif') && (m.bestMp4Url || m.sttMp4Url));
-    for (const [i, v] of videos.entries()) {
+    const canExtractFrames = !videos.length || mediaEngineAvailable('ffmpeg');
+    for (const [i, v] of (canExtractFrames ? videos : []).entries()) {
       if (v.durationMs && v.durationMs > MAX_VIDEO_MS_FOR_FRAMES) { log(`  [시각] 영상 ${i + 1} 길어서 프레임 생략`); continue; }
       try {
         const dir = join(work, `v${i + 1}`);

package/skills/omni-market/scripts/main.ts

@@ -5,7 +5,7 @@ import { resolveDateRange } from '../src/date.js';
 import { route, listProviders } from '../src/router.js';
 import { render } from '../src/render.js';
 import type { Command } from '../src/types.js';
-import { writeStdoutJson } from '../../../src/cli/stdout-json.ts';
+import { writeStdoutJson } from './stdout-json.js';
 
 initEnv();
 

package/skills/omni-market/scripts/stdout-json.ts

@@ -0,0 +1,4 @@
+/** Write JSON output completely before the process can exit. (Kept inside the skill so the skill runs outside this repository — public pack and lite Pod.) */
+export async function writeStdoutJson(text: string): Promise<void> {
+  await new Promise<void>((resolve, reject) => process.stdout.write(text, error => error ? reject(error) : resolve()));
+}

package/src/agent/identity-env.ts

@@ -21,6 +21,17 @@
 import { debug } from '../debug/log.js';
 import { getCapturedEnv, capturedEnvAvailable } from '../shell-env-bootstrap.js';
 import { resolveCurrentInstance } from '../instance/current.js';
+import { treeDerivedRootFor } from '../instance/resolve.js';
+
+/** Pin a child state root together with its origin; only reuse a parent's tag for the same root. */
+export function stateDirSourceForChild(root: string, env: NodeJS.ProcessEnv = process.env): string {
+  if (env.ELANOUS_STATE_DIR === root && env.ELANOUS_STATE_DIR_SOURCE?.trim()) {
+    return env.ELANOUS_STATE_DIR_SOURCE;
+  }
+  const current = resolveCurrentInstance();
+  return root === treeDerivedRootFor(process.cwd()) || (current.root === root && current.layer === 'default')
+    ? 'derived' : 'explicit';
+}
 
 // ── 전파 allowlist ─────────────────────────────────────────────────────────
 //

package/src/agent-mission/driver.ts

@@ -22,8 +22,10 @@ import { streamLLM, type LLMMessage } from '../llm.js';
 import { debug } from '../debug/log.js';
 import { emitPtyDecision, type DecisionInput } from './pty-decision.js';
 import { observeExternalEvent } from '../context-bus/external-events.js';
+import { emitSessionEvent, type SessionEventInput } from '../context-bus/session-events.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { resolvePtyWebAddress } from '../cli/pty-web-address.js';
+import { verdictForFinalPtyScreen } from '../cli/pty-drive-verdict.js';
 import { reemitPtyUsage } from '../budget/pty-usage-reemit.js';
 import { classifyAuthError } from '../oauth/codex.js';
 import type { FallbackStep } from '../oauth/fallback-chain.js';
@@ -451,6 +453,8 @@ export interface AgentMissionSpec {
   evidence: EvidenceMode;
   /** RFC 최대 라운드(기본 16). */
   maxRounds?: number;
+  /** 화면 무변화 회복 문턱(ms, 기본 45초). */
+  recoverAfterMs?: number;
   /** 완료 시 자동 commit(기본 true). */
   commit?: boolean;
   /** 스크린 캡처 저장 디렉토리. */
@@ -487,6 +491,8 @@ export interface AgentMissionSpec {
   memory?: boolean;
   /** PTY 닉네임(휴먼 리더블·goto 로 나중 접근). 기본 branch. */
   nickname?: string;
+  /** Concurrent missions may share one decision stream alias without sharing a PTY or worktree. */
+  decisionMissionId?: string;
   /** ⭐⭐ 그 브랜치를 이미 쥔 «소유» 워크트리가 있으면 지우지 말고 그대로 재사용하라고 요청한다
    *  (`createWorktree` 의 같은 이름 인자로 그대로 내려간다 · 판정은 거기 `gateWorktreeReuse` 가 한다).
    *
@@ -509,11 +515,14 @@ export interface AgentMissionResult {
   paths?: string[];
   rounds: number;
   evidencePath: string | null;
+  /** The evidence check outcome, independent of the final mission and DRIVE-OK verdicts. */
+  evidenceSatisfied?: boolean;
   committed: boolean;
   usedOmniCrawl: boolean;
   detail: string;
   ptyId?: string;
   webUrl?: string | null;
+  driveVerdict?: ReturnType<typeof verdictForFinalPtyScreen>['kind'];
 }
 /** @deprecated codex 특정 이름 — AgentMissionResult 을 쓰라. */
 export type CodexMissionResult = AgentMissionResult;
@@ -538,6 +547,12 @@ export interface AgentMissionDeps {
   checkEvidence?: typeof checkEvidence;
   commitWorktree?: typeof commitWorktree;
   dispatchOpenPullRequest?: typeof dispatchOpenPullRequest;
+  /** Optional context-journal sink for isolated missions. */
+  emitContextEvent?: (input: SessionEventInput) => void;
+  /** Internal continuation retains the original mission's context-event owner. */
+  contextEventRun?: boolean;
+  /** Carries a PR number back to the outer mission's context event. */
+  onMissionPrNumber?: (number: number) => void;
   terminateProcessTree?: typeof terminateMissionProcessTree;
   repoStatus?: (repo: string) => string | Promise<string>;
   emitDecision?: typeof emitDecision;
@@ -835,18 +850,36 @@ export interface MissionControlBrainOpts {
   /** Screen-grounded brain summary for the next backend, never the raw PTY screen. */
   readonly onSummary?: (summary: string) => void;
   readonly onDecision?: (text: string, reply?: { question: string; answer: string }) => void;
+  readonly recoverAfterMs?: number;
+  readonly initialCommand?: string;
+  readonly onRecover?: (blocked: string, action: string) => void;
 }
 
 /** 기존 5-action mission 판단을 canonical PTY control-loop 결정으로 축소한다. search는 이 경계에서만
  * 부작용(context 기록)을 끝내고, child에는 context를 읽고 계속하라는 단일 input만 전달한다. */
-export function createMissionControlBrain(opts: MissionControlBrainOpts): RunSupervisor {
+export type MissionControlBrain = RunSupervisor & {
+  /** Report whether the last returned input was accepted by the PTY; recovery stages and events commit only on acceptance. */
+  readonly onInputResult: (text: string, accepted: boolean) => void;
+};
+
+export function createMissionControlBrain(opts: MissionControlBrainOpts): MissionControlBrain {
   const history: string[] = [];
   const backendName = (opts.backend ?? codexBackend).name;
   // ★ P4 dedup(제한적 재시도·리뷰) — (layer:spec)별 시도횟수. 성공 시 영구 차단, 실패는 최대 2회까지
   //   허용(일시 네트워크/프로세스 오류는 재시도, 지속 실패는 루프 차단).
   const provisionAttempts = new Map<string, number>();
   const PROVISION_MAX_ATTEMPTS = 2;
-  return createLlmControlBrain({
+  const recoverAfterMs = opts.recoverAfterMs ?? 45_000;
+  if (!Number.isFinite(recoverAfterMs) || recoverAfterMs <= 0) throw new Error('recoverAfterMs must be positive');
+  let lastScreen: string | undefined;
+  let repeatedQuestion = 0;
+  let lastQuestion: string | undefined;
+  let recoveryStage = 0;
+  let pendingReplayBlocked: string | undefined;
+  // The recovery input returned by the last decide(); committed (stage advance + event) only when the PTY accepts it.
+  let pendingRecovery: { blocked: string; action: string; text: string; replay?: boolean } | undefined;
+  let lastCommand = opts.initialCommand ?? opts.mission;
+  const llmBrain = createLlmControlBrain({
     goal: opts.mission,
     stream: opts.stream,
     maxTokens: 500,
@@ -887,7 +920,10 @@ ${opts.handoffEnabled ? ` - "handoff": 다른 담당자로 넘길 때 to(codex/c
       if (decision.reason && decision.action !== 'ask-human') opts.onSummary?.(decision.reason.slice(0, 2000));
       if (decision.action === 'handoff' && decision.to && decision.mission) return { action: 'handoff', to: decision.to, mission: decision.mission, ...(decision.carry ? { carry: decision.carry } : {}) };
       if (decision.action === 'ask-human') return { action: 'ask-human', reason: decision.reason, ...(decision.url ? { url: decision.url } : {}), ...(decision.code ? { code: decision.code } : {}) };
-      if (decision.action === 'send') return { action: 'input', text: `${decision.text || 'continue'}\r` };
+      if (decision.action === 'send') {
+        lastCommand = decision.text || 'continue';
+        return { action: 'input', text: `${lastCommand}\r` };
+      }
       if (decision.action === 'verify' || decision.action === 'done') return { action: 'done', reason: decision.reason || 'agent completed' };
       if (decision.action === 'search') {
         await opts.search(decision.query || opts.mission.slice(0, 120), obs.step);
@@ -922,6 +958,57 @@ ${opts.handoffEnabled ? ` - "handoff": 다른 담당자로 넘길 때 to(codex/c
       return { action: 'wait' };
     },
   });
+  return {
+    onInputResult: (text, accepted) => {
+      const recovery = pendingRecovery;
+      // Only the input this brain returned settles its recovery step (a trust answer in between does not).
+      if (!recovery || recovery.text !== text) return;
+      pendingRecovery = undefined;
+      if (!accepted) return;
+      if (recovery.replay) { pendingReplayBlocked = undefined; opts.onRecover?.(recovery.blocked, recovery.action); return; }
+      recoveryStage += 1;
+      if (recovery.action === 'Ctrl-C and replay previous command') pendingReplayBlocked = recovery.blocked;
+      else opts.onRecover?.(recovery.blocked, recovery.action);
+    },
+    decide: async (obs, signal) => {
+      pendingRecovery = undefined;
+      if (signal?.aborted) return { action: 'wait' };
+      const lines = classifierFrameLines(obs.screen);
+      // Only the active bottom line can be a repeated prompt; a question left in
+      // scrollback while new work appears is not a request for input.
+      const tail = lines.at(-1);
+      const question = tail && /\?(?:\s*\[[^\]\r\n]+\])?\s*$/.test(tail) ? tail : undefined;
+      const screenChanged = lastScreen !== undefined && obs.screen !== lastScreen;
+      if (screenChanged) recoveryStage = 0;
+      repeatedQuestion = question ? (!screenChanged && question === lastQuestion ? repeatedQuestion + 1 : 1) : 0;
+      lastQuestion = question;
+      lastScreen = obs.screen;
+      if (pendingReplayBlocked !== undefined) {
+        // Ctrl-C consumes its own step; replay on the next observation even when the
+        // interrupted child keeps redrawing a non-prompt screen. A rejected replay is retried.
+        const text = `${lastCommand}\r`;
+        pendingRecovery = { blocked: pendingReplayBlocked, action: 'Ctrl-C and replay previous command', text, replay: true };
+        return { action: 'input', text };
+      }
+      const blocked = repeatedQuestion >= 3 ? `same question repeated three times: ${question}`
+        : (obs.sameScreenMs ?? 0) >= recoverAfterMs ? `screen unchanged for ${obs.sameScreenMs}ms` : undefined;
+      if (blocked && opts.evidenceReady()) return { action: 'done', reason: 'Evidence ready on stalled screen' };
+      if (blocked && !signal?.aborted) {
+        const action = ['Enter', 'Esc', 'Ctrl-C and replay previous command', 'Human needed'] as const;
+        const next = action[Math.min(recoveryStage, 3)]!;
+        if (next !== 'Human needed') {
+          const text = next === 'Enter' ? '\r' : next === 'Esc' ? '\x1b' : '\x03';
+          pendingRecovery = { blocked, action: next, text };
+          return { action: 'input', text };
+        }
+        recoveryStage += 1;
+        opts.onRecover?.(blocked, next);
+        const summary = lines.slice(-3).join(' | ').slice(0, 240) || '(empty screen)';
+        return { action: 'no-progress', terminal: true, reason: `사람 필요 · 마지막 화면 요약: ${summary}` };
+      }
+      return llmBrain.decide(obs, signal);
+    },
+  };
 }
 
 /**
@@ -1273,6 +1360,21 @@ export async function runAgentMission(spec: AgentMissionSpec, deps: AgentMission
     } finally { signal?.removeEventListener('abort', stopWaiting); }
   }
   const startedAt = Date.now();
+  const contextOwner = !deps.contextEventRun;
+  const contextRunId = contextOwner ? ensureRunId() : undefined;
+  let contextPrNumber: number | undefined;
+  const emitContext = (kind: 'task-claimed' | 'task-done', detail: string): void => {
+    if (!contextOwner) return;
+    try {
+      (deps.emitContextEvent ?? emitSessionEvent)({ kind, seat: 'TC', text: `Agent mission ${detail}: ${spec.mission.split(/\r?\n/, 1)[0]}`,
+        ref: `runId=${contextRunId}${contextPrNumber === undefined ? '' : ` PR=#${contextPrNumber}`}` });
+    } catch (error) {
+      try { debug.log('agent-mission', 'context-event-failed', { kind, runId: contextRunId, error: String(error) }, { level: 'warn' }); } catch { /* fail-soft */ }
+    }
+  };
+  emitContext('task-claimed', 'claimed');
+  let result: AgentMissionResult | undefined;
+  try {
   const initialFiles = workdir && spec.evidence.kind === 'doc' ? initialEvidenceFiles(workdir, spec.evidence) : undefined;
   let handle: PtyHandle | undefined;
   let childPid: number | undefined;
@@ -1306,10 +1408,12 @@ export async function runAgentMission(spec: AgentMissionSpec, deps: AgentMission
   });
   signal?.addEventListener('abort', abort, { once: true });
   if (signal?.aborted) abort();
-  let result: AgentMissionResult;
   try {
     if (cancelled) await aborted;
-    const body = runAgentMissionBody(spec, { ...deps, onControlActive: (pending) => {
+    const body = runAgentMissionBody(spec, { ...deps, contextEventRun: true, onMissionPrNumber: (number) => {
+      contextPrNumber = number;
+      try { deps.onMissionPrNumber?.(number); } catch { /* context propagation never changes a mission result */ }
+    }, onControlActive: (pending) => {
       activeSettled = false;
       activeControl = pending.then(() => { activeSettled = true; }, () => { activeSettled = true; });
     }, onControlPending: (pending) => {
@@ -1377,10 +1481,12 @@ export async function runAgentMission(spec: AgentMissionSpec, deps: AgentMission
     if (paths.length) {
       debug.log('agent-mission', 'outside-write', { workdir, pids: [], reason: paths.join(', ') });
       (deps.emitDecision ?? emitDecision)({ kind: 'ESCALATE', what: '작업 폴더 밖 쓰기', reason: paths.join(', '), purpose: '사람이 확인한다', target: 'human' });
-      return { ...result, ok: false, reason: 'outside-write', paths, committed: false };
+      result = { ...result, ok: false, reason: 'outside-write', paths, committed: false };
+      return result;
     }
   }
   return result;
+  } finally { emitContext('task-done', result?.ok ? 'completed' : 'ended'); }
 }
 
 async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDeps, startedAt: number, initialFiles?: ReadonlyMap<string, string>): Promise<AgentMissionResult> {
@@ -1508,7 +1614,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     const finalEv = verifyEvidence(wt.path, spec.evidence);
     if (!finalEv.ok) return {
       ok: false, worktree: wt.path, branch: wt.branch, rounds: result.numTurns ?? 0,
-      evidencePath: null, committed: false, usedOmniCrawl: false,
+      evidencePath: null, evidenceSatisfied: false, committed: false, usedOmniCrawl: false,
       detail: `미완(증거 부족): ${finalEv.retry ?? '증거가 아직 부족하다.'}`,
     };
     if (checklist.length) {
@@ -1526,13 +1632,13 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       if (!c.ok) {
         debug.log('agent-mission', 'result', { ok: false, rounds: result.numTurns ?? 0, evidencePath: finalEv.path, committed: false, usedOmni: false });
         return { ok: false, worktree: wt.path, branch: wt.branch, rounds: result.numTurns ?? 0,
-          evidencePath: finalEv.path, committed: false, usedOmniCrawl: false,
+          evidencePath: finalEv.path, evidenceSatisfied: true, committed: false, usedOmniCrawl: false,
           detail: `미완(자동 커밋 실패): ${c.out.slice(0, 120)}` };
       }
     }
     debug.log('agent-mission', 'result', { ok: true, rounds: result.numTurns ?? 0, evidencePath: finalEv.path, committed, usedOmni: false });
     return { ok: true, worktree: wt.path, branch: wt.branch, rounds: result.numTurns ?? 0,
-      evidencePath: finalEv.path, committed, usedOmniCrawl: false, detail: '완료(증거 충족)' };
+      evidencePath: finalEv.path, evidenceSatisfied: true, committed, usedOmniCrawl: false, detail: '완료(증거 충족)' };
   }
   env.TERM = 'xterm-256color';
   // ⭐run-identity — runId was resolved before either headless or PTY spawn.
@@ -1612,7 +1718,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   process.stderr.write(`[agent-mission] pty=${h.id} watch=${webAddress.webUrl ?? `(web unavailable: ${webAddress.pwaUnavailableReason ?? 'not-resolved'})`}\n`);
   debug.log('agent-mission', 'pty-link', { id: h.id, webUrl: webAddress.webUrl, webUrlSource: webAddress.webUrlSource });
 
-  const decisionIdentity = { missionId: runId, sessionId: runId, terminalId: h.id, agent: backend.name };
+  const decisionIdentity = { missionId: spec.decisionMissionId ?? runId, sessionId: runId, terminalId: h.id, agent: backend.name };
   const decisionEvent = (event: Omit<DecisionInput, keyof typeof decisionIdentity>): void => {
     try { (deps.emitPtyDecision ?? emitPtyDecision)({ ...decisionIdentity, ...event } as DecisionInput); }
     catch { /* Observation must not change mission control or handoff. */ }
@@ -1779,6 +1885,8 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   if (deps.isMissionAborted?.()) throw new Error('MISSION_ABORTED');
   // 미션 전송 — 인핸싱/기억으로 가공됐으면(멀티라인) 파일로 떨궈 read 지시(TUI 멀티라인 위험·verbatim 보존).
   //   원문 그대로면(단문) 타이핑.
+  let submittedCommand = spec.mission;
+  const submittedInputs: string[] = [];
   if (missionText !== spec.mission) {
     const pf = join(wt.path, '.mission-prompt.md');
     try { writeFileSync(pf, missionText); } catch { /* noop */ }
@@ -1786,9 +1894,12 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       ? '.mission-prompt.md 파일을 읽고 그 안의 미션을 완수하라. [elanous 인핸싱]의 커버리지 체크리스트 모든 항목을 산출물에 빠짐없이 반영하고(요약·일반화 금지), 완료하면 MISSION-COMPLETE 라고 답하라.'
       : '.mission-prompt.md 파일을 읽고 그 안의 미션을 완수하라(원문 그대로·[elanous 기억]은 참조 컨텍스트). 완료하면 MISSION-COMPLETE 라고 답하라.';
     debug.log('agent-mission', 'mission-send', { via: 'file', file: '.mission-prompt.md', chars: missionText.length, enhanced: enhanceActive });
+    submittedCommand = note;
+    submittedInputs.push(note);
     drive(note); await sleep(800); drive('\r');
   } else {
     debug.log('agent-mission', 'mission-send', { via: 'type', chars: spec.mission.length });
+    submittedInputs.push(spec.mission);
     drive(spec.mission); await sleep(800); drive('\r');
   }
 
@@ -1803,6 +1914,9 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     backend,
     stream: deps.controlStream,
     handoffEnabled: true,
+    recoverAfterMs: spec.recoverAfterMs,
+    initialCommand: submittedCommand,
+    onRecover: (blocked, action) => { decisionEvent({ step: 'recover', text: action, detail: { blocked, action } }); },
     onSummary: (summary) => { controllerSummary = summary; },
     onDecision: (text, reply) => {
       pendingAnswer = reply ? { text: `${reply.answer || 'continue'}\r`, ...reply } : undefined;
@@ -1824,6 +1938,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   // before asking the LLM — otherwise the mission text is typed into the prompt and the run stalls.
   const trustAwareBrain: RunSupervisor = {
     decide: (obs, signal) => {
+      decisionEvent({ step: 'read', text: `step ${obs.step} (${obs.state}): ${classifierFrameLines(obs.screen).at(-1) ?? 'empty screen'}` });
       pendingAnswer = undefined;
       let answer: string | undefined;
       if (backend.handleTrust?.(obs.screen, (bytes) => { answer = bytes; }) && answer !== undefined) {
@@ -1889,7 +2004,8 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
         handoffPrSkipped = true;
         debug.log('agent-mission', 'handoff-pr-skipped', { reason: 'origin-not-github' });
       } else {
-        (deps.dispatchOpenPullRequest ?? dispatchOpenPullRequest)({ title: `agent-mission: ${spec.branch}`, body: deps.originalMission ?? spec.mission, head: spec.branch, base: spec.base ?? 'main' }, { cwd: worktree });
+        const opened = (deps.dispatchOpenPullRequest ?? dispatchOpenPullRequest)({ title: `agent-mission: ${spec.branch}`, body: deps.originalMission ?? spec.mission, head: spec.branch, base: spec.base ?? 'main' }, { cwd: worktree });
+        if (opened.number !== null) deps.onMissionPrNumber?.(opened.number);
       }
       gatedHandoff = true;
     },
@@ -1916,7 +2032,6 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     renderPng: () => h.renderScreenPng(),
     bus,
     ident: { ptyId: h.id, instance: resolveInstanceName(), runId },
-    onPublishedFrame: (obs) => decisionEvent({ step: 'read', text: `step ${obs.step} (${obs.state}): ${classifierFrameLines(obs.screen).at(-1) ?? 'empty screen'}` }),
   });
   debug.log('agent-mission', 'takeover-wait', { id: h.id, maxWaitMs: AGENT_MISSION_TAKEOVER_WAIT_MS });
   const controlRun = runWithControlObserve(
@@ -1932,7 +2047,12 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
           pendingAnswer = undefined;
           const accepted = inject(text);
           if (accepted) {
+            submittedInputs.push(text);
             decisionEvent({ step: 'input', text: `Sent ${text.startsWith('\x1b') ? 'key' : 'text'}: ${text.startsWith('\x1b') ? 'navigation' : text}` });
+          }
+          // Recovery stages and recover events are committed only after the PTY accepted the input.
+          brain.onInputResult(text, accepted);
+          if (accepted) {
             if (reply) decisionEvent({ step: 'answer', text: 'Answered agent question', detail: { question: reply.question, answer: reply.answer } });
           }
           return accepted;
@@ -1948,6 +2068,8 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
         } : {}),
         awaitOwnership: { maxWaitMs: AGENT_MISSION_TAKEOVER_WAIT_MS },
         settle: async () => {
+          // A frozen screen goes quiet after 6 s, so stall recovery is still observed; work that keeps
+          // drawing output keeps the original 360 s settle and round budget.
           const quiet = waitForQuiet(h, 6000, 360000);
           await (deps.awaitMission ? deps.awaitMission(quiet) : quiet);
         },
@@ -1986,7 +2108,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
           throw error;
         }
       },
-      }, { maxSteps: maxRounds });
+      }, { maxSteps: maxRounds, stuckLimit: maxRounds + 1 });
       deps.onControlActive?.(pending);
       return pending;
     },
@@ -2025,7 +2147,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     try { h.kill(); } catch { /* noop */ }
     return { ok: true, worktree: wt.path, branch: wt.branch, rounds: control.steps, evidencePath: wt.path, committed: true, usedOmniCrawl: usedOmni,
       ...(handoffPrSkipped ? { pr: 'skipped' as const, reason: 'origin-not-github' as const } : {}),
-      detail: handoffPrSkipped ? '완료(증거 게이트·push·PR 생략)' : '완료(증거 게이트·PR)' };
+      evidenceSatisfied: true, detail: handoffPrSkipped ? '완료(증거 게이트·push·PR 생략)' : '완료(증거 게이트·PR)' };
   }
   const done = control.termination.kind === 'success';
   const round = control.steps;
@@ -2079,24 +2201,29 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   if (deps.isMissionAborted?.()) return { ok: false, reason: 'aborted', worktree: wt.path, branch: wt.branch,
     rounds: round, evidencePath: null, committed: false, usedOmniCrawl: usedOmni, detail: 'aborted' };
   const finalEv = verifyEvidence(wt.path, spec.evidence);
-  const evidencePath = finalEv.ok ? finalEv.path : null;
+  const finalScreen = await h.renderScreen();
+  const driveVerdict = verdictForFinalPtyScreen({ screen: finalScreen, inputHistory: submittedInputs, exitCode: h.exitCode ?? null });
+  debug.log('agent-mission', 'drive-verdict', { kind: driveVerdict.kind, reason: driveVerdict.reason.slice(0, 200) });
+  const recoverExhausted = control.termination.kind === 'stuck' && control.termination.reason.startsWith('사람 필요');
+  const accepted = finalEv.ok && !recoverExhausted && driveVerdict.kind !== 'done-but-failed';
+  const evidencePath = accepted ? finalEv.path : null;
   let committed = false;
-  if (!deps.isMissionAborted?.() && !spec.workdir && finalEv.ok && (spec.commit ?? true)) {
+  if (!deps.isMissionAborted?.() && !spec.workdir && accepted && (spec.commit ?? true)) {
     const c = (deps.commitWorktree ?? commitWorktree)(wt.path, `chore(agent-mission): ${spec.branch} — ${backend.name}-in-elanous PTY RFC 산출`);
     committed = c.ok;
     debug.log('agent-mission', 'commit', { ok: c.ok, out: c.out.slice(0, 120) });
   }
-  debug.log('agent-mission', 'result', { ok: finalEv.ok, rounds: round, evidencePath, committed, usedOmni });
-  decisionEvent({ step: 'done', text: finalEv.ok ? 'Mission evidence accepted' : 'Mission ended without sufficient evidence', detail: { result: { kind: evidencePath ? 'file' : 'text', ref: evidencePath ?? (control.termination.kind === 'error' ? control.termination.message : 'evidence unavailable') } } });
-  stopLive(finalEv.ok);
+  debug.log('agent-mission', 'result', { ok: accepted, rounds: round, evidencePath, committed, usedOmni });
+  decisionEvent({ step: 'done', text: accepted ? 'Mission evidence accepted' : 'Mission ended without sufficient evidence', detail: { result: { kind: evidencePath ? 'file' : 'text', ref: evidencePath ?? (control.termination.kind === 'error' ? control.termination.message : recoverExhausted ? control.termination.reason : 'evidence unavailable') } } });
+  stopLive(accepted);
   if (h.pid) await terminateMissionProcessTree(h.pid);
   try { h.kill(); } catch { /* noop */ }
 
   return {
-    ok: finalEv.ok, worktree: wt.path, branch: wt.branch, rounds: round,
-    evidencePath, committed, usedOmniCrawl: usedOmni,
-    ptyId: h.id, webUrl: webAddress.webUrl,
-    detail: done ? '완료(증거 충족)' : (finalEv.ok ? '증거 충족(루프 종료)' : '미완(증거 부족)'),
+    ok: accepted, worktree: wt.path, branch: wt.branch, rounds: round,
+    evidencePath, evidenceSatisfied: finalEv.ok, committed, usedOmniCrawl: usedOmni,
+    ptyId: h.id, webUrl: webAddress.webUrl, driveVerdict: driveVerdict.kind,
+    detail: recoverExhausted ? control.termination.reason : driveVerdict.kind === 'done-but-failed' ? `미완(DRIVE-OK: ${driveVerdict.reason})` : done ? '완료(증거 충족)' : (finalEv.ok ? '증거 충족(루프 종료)' : '미완(증거 부족)'),
   };
   } finally { stopLive(); finishContext(false); }
 }

package/src/agent-mission/duo.ts

@@ -0,0 +1,94 @@
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { runAgentMission, resolveBackend, type AgentBackend, type AgentMissionResult, type AgentMissionSpec, type EvidenceMode } from './driver.js';
+
+export interface DuoOptions {
+  left: string;
+  right: string;
+  branch: string;
+  base?: string;
+  missionFile?: string;
+  evidence?: string;
+  docDir?: string;
+  docGlob?: string;
+  testPath?: string;
+  file?: string;
+  maxRounds?: string;
+  commit?: boolean;
+}
+
+export interface DuoSide {
+  side: 'left' | 'right';
+  backend: string;
+  branch: string;
+  finished: number;
+  result?: AgentMissionResult;
+  error?: string;
+}
+
+export interface DuoResult {
+  missionId: string;
+  sides: [DuoSide, DuoSide];
+  lines: [string, string];
+  exitCode: number;
+}
+
+export interface DuoDeps {
+  resolveBackend?: typeof resolveBackend;
+  runMission?: typeof runAgentMission;
+  readFile?: (path: string) => string;
+  id?: () => string;
+}
+
+function evidenceFor(opts: DuoOptions): EvidenceMode {
+  if (opts.evidence === 'doc') return { kind: 'doc', dirRel: opts.docDir ?? 'docs/plans', glob: new RegExp(opts.docGlob ?? '^PLAN-.*[.]md$', 'i') };
+  if (opts.evidence === 'test') {
+    if (!opts.testPath) throw new Error('test 모드엔 --test-path 필요');
+    return { kind: 'test', testPath: opts.testPath, ...(opts.file ? { fileRel: opts.file } : {}) };
+  }
+  if (opts.evidence === undefined || opts.evidence === 'tsc') return { kind: 'tsc' };
+  throw new Error('--evidence 는 doc|tsc|test 여야 합니다');
+}
+
+function render(side: DuoSide, first: DuoSide | undefined): string {
+  const evidence = side.result?.evidenceSatisfied === true
+    ? side.result.evidencePath ? `충족(${side.result.evidencePath})` : '충족'
+    : side.result?.evidenceSatisfied === false ? '미충족' : '미측정';
+  const drive = side.result?.driveVerdict ?? '미측정';
+  const detail = side.error ?? (!side.result?.ok ? side.result?.detail : undefined);
+  return `${side.side} ${side.backend} · branch=${side.branch} · terminalId=${side.result?.ptyId ?? '없음'} · ${first === side ? '먼저' : '나중'} · 증거 ${evidence} · DRIVE-OK ${drive} · ${side.result?.ok ? '완료' : '실패'}${detail ? ` (${detail})` : ''}`;
+}
+
+/** Run two independent existing agent missions; neither branch waits for or cancels its peer. */
+export async function runAgentMissionDuo(textParts: string[], opts: DuoOptions, deps: DuoDeps = {}): Promise<DuoResult> {
+  if (!opts.branch?.trim()) throw new Error('--branch 필요');
+  if (opts.left !== 'codex' && opts.left !== 'claude') throw new Error('--left 는 codex|claude 여야 합니다');
+  if (opts.right !== 'codex' && opts.right !== 'claude') throw new Error('--right 는 codex|claude 여야 합니다');
+  if (opts.left === opts.right) throw new Error('duo 에는 서로 다른 backend 둘이 필요합니다');
+  const mission = opts.missionFile ? (deps.readFile ?? ((path) => readFileSync(path, 'utf8')))(opts.missionFile) : textParts.join(' ');
+  if (!mission.trim()) throw new Error('미션 텍스트가 비었다 — <text...> 또는 --mission-file 필요');
+  const evidence = evidenceFor(opts);
+  const rounds = opts.maxRounds === undefined ? 16 : Number(opts.maxRounds);
+  if (!Number.isSafeInteger(rounds) || rounds <= 0) throw new Error('--max-rounds 는 양의 정수여야 합니다');
+  const resolve = deps.resolveBackend ?? resolveBackend;
+  const backends: [AgentBackend, AgentBackend] = [resolve(opts.left), resolve(opts.right)];
+  if (backends[0].name !== opts.left || backends[1].name !== opts.right) throw new Error('backend 선택이 요청과 다릅니다');
+  const id = `duo-${(deps.id ?? randomUUID)()}`;
+  const run = deps.runMission ?? runAgentMission;
+  let completed = 0;
+  const branches = [`${opts.branch}-${opts.left}`, `${opts.branch}-${opts.right}`] as const;
+  const tasks = backends.map(async (backend, index): Promise<DuoSide> => {
+    const side = index === 0 ? 'left' : 'right';
+    const branch = branches[index]!;
+    const spec: AgentMissionSpec = {
+      mission, branch, agent: backend, decisionMissionId: id, evidence, maxRounds: rounds,
+      ...(opts.base ? { base: opts.base } : {}), commit: opts.commit !== false,
+      enhance: false, memory: false, resources: 'off', entry: 'external-verbatim',
+    };
+    try { return { side, backend: backend.name, branch, result: await run(spec), finished: ++completed }; }
+    catch (error) { return { side, backend: backend.name, branch, error: error instanceof Error ? error.message : String(error), finished: ++completed }; }
+  });
+  const sides = await Promise.all(tasks) as [DuoSide, DuoSide];
+  const first = sides[0].finished <= sides[1].finished ? sides[0] : sides[1];
+  return { missionId: id, sides, lines: [render(sides[0], first), render(sides[1], first)], exitCode: sides.every((s) => s.result?.ok) ? 0 : 2 };
+}

package/src/agent-mission/pty-decision.ts

@@ -41,10 +41,10 @@ function safe(value: string): string {
 }
 
 /** The only emission point for the inside-PTY decision stream. Never log unsanitized input. */
-export function emitPtyDecision(input: DecisionInput, log: typeof debug.log = debug.log): PtyDecision {
+export function emitPtyDecision(input: DecisionInput, log: typeof debug.log = (category, event, data) => debug.log(category, event, data)): PtyDecision {
   let stream = missionStreams.get(input.missionId);
   if (!stream) {
-    stream = { alias: `mission-${missionStreams.size + 1}`, seq: -1 };
+    stream = { alias: `${input.missionId.startsWith('duo-') ? 'duo' : 'mission'}-${missionStreams.size + 1}`, seq: -1 };
     missionStreams.set(input.missionId, stream);
   }
   stream.seq += 1;