elanous 0.2.10 → 0.2.12

package/skills/youtube-master/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "."
+  },
+  "include": ["src/**/*.ts", "scripts/**/*.ts"]
+}

package/src/acp/server.ts

@@ -241,6 +241,8 @@ export interface AcpServerOptions {
   /** ACP standalone entry: require session cwd or an explicit boot default. */
   requireSessionToolCwd?: boolean;
   bootToolCwd?: string;
+  /** Optional PTY factory for the web terminal; production uses PreviewTerminal. */
+  createWebTerminal?: (opts: ConstructorParameters<typeof import('../preview/terminal.js').PreviewTerminal>[0]) => import('../preview/terminal.js').PreviewTerminal;
   /** Test seam for exercising stdio EOF with controlled byte streams. */
   stdioInput?: ReadableStream<Uint8Array>;
   stdioOutput?: WritableStream<Uint8Array>;
@@ -2190,7 +2192,8 @@ function wireAcpConnection(
           throw new Error('terminal/spawn: sessionId required');
         }
         const tid = resolveAcpTerminalId(p.terminalId);
-        const cwd = typeof p.cwd === 'string' && p.cwd.length > 0 ? p.cwd : process.cwd();
+        const cwd = typeof p.cwd === 'string' && p.cwd.length > 0 ? p.cwd
+          : (await import('../project/session-context.js')).resolveSessionProjectContext(p.sessionId)?.cwd ?? process.cwd();
         const cols = typeof p.cols === 'number' && p.cols > 0 ? p.cols : 80;
         const rows = typeof p.rows === 'number' && p.rows > 0 ? p.rows : 24;
 
@@ -2234,7 +2237,7 @@ function wireAcpConnection(
         }
 
         const { PreviewTerminal } = await import('../preview/terminal.js');
-        const pt = new PreviewTerminal({
+        const pt = (opts.createWebTerminal ?? ((terminalOpts) => new PreviewTerminal(terminalOpts)))({
           cols, rows, cwd,
           // Web-terminal child shell renders inside the PWA's xterm.js,
           // which implements the xterm-256color terminfo. When the daemon

package/src/agent-mission/driver.ts

@@ -20,8 +20,12 @@ import { configuredWorktreeRoot } from '../user-config.js';
 import { worktreeHasChanges, commitWorktree, changedFiles } from '../self-implement/seams.js';
 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';
@@ -449,6 +453,8 @@ export interface AgentMissionSpec {
   evidence: EvidenceMode;
   /** RFC 최대 라운드(기본 16). */
   maxRounds?: number;
+  /** 화면 무변화 회복 문턱(ms, 기본 45초). */
+  recoverAfterMs?: number;
   /** 완료 시 자동 commit(기본 true). */
   commit?: boolean;
   /** 스크린 캡처 저장 디렉토리. */
@@ -522,6 +528,8 @@ export interface AgentMissionDeps {
   createWorktree?: typeof createWorktree;
   recordWorktreeProvenance?: typeof recordHarnessWorktreeProvenance;
   runControlLoop?: typeof runPtyControlLoop;
+  /** Capture decisions in tests without replacing the process-wide debug logger. */
+  emitPtyDecision?: typeof emitPtyDecision;
   /** Inject controller responses while keeping the production control loop. */
   controlStream?: StreamLLMFn;
   resolvePtyWebAddress?: typeof resolvePtyWebAddress;
@@ -534,6 +542,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;
@@ -830,18 +844,37 @@ export interface MissionControlBrainOpts {
   readonly handoffEnabled?: boolean;
   /** 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,
@@ -855,7 +888,7 @@ export function createMissionControlBrain(opts: MissionControlBrainOpts): RunSup
  행동(action):
  - "wait": ${backendName} 가 아직 작업 중(도구 실행/생성)이면 대기.
  - "verify": ${backendName} 가 MISSION-COMPLETE/완료를 주장하면 증거 게이트(내가 실행)로 검증. 완료주장 시 이걸 우선.
- - "send": ${backendName} 가 멈추거나 계속 진행이 필요하면 짧고 명확한 지시(text).
+ - "send": ${backendName} 가 멈추거나 계속 진행이 필요하면 짧고 명확한 지시(text). 화면의 질문에 직접 답하는 경우에만 reason 을 Answering question: <화면의 질문 원문> 으로 기록하라. 다른 send 의 reason 은 종전처럼 행동 이유를 적어라.
  - "search": ${backendName} 가 정보/라이브러리/문법/외부자원에 막혔으면 omni-crawl 로 조사(query). ⭐외부 힌트 없이 스스로 판단.
 ${opts.handoffEnabled ? ` - "handoff": 다른 담당자로 넘길 때 to(codex/claude/elanous), mission(다음 지시), carry(diff/summary 선택). carry=summary 면 reason 에 화면에서 확인한 리뷰 지적을 구체적으로 요약하라(다음 backend 에 전달된다). claude 리뷰 뒤 지적은 codex 에 summary 로 되돌려라. elanous 는 증거 게이트와 PR.
  - "ask-human": 화면에 로그인 URL/장치 코드가 보이면 reason, url/code(보이는 것만). 토큰·자격파일을 열지 마라.` : ''}${opts.provision ? `
@@ -873,10 +906,19 @@ ${opts.handoffEnabled ? ` - "handoff": 다른 담당자로 넘길 때 to(codex/c
       history.push(`s${obs.step}:${decision.action}`);
       debug.log('agent-mission', 'brain', { step: obs.step, action: decision.action,
         ...(decision.action === 'ask-human' ? {} : { reason: decision.reason.slice(0, 120) }) });
+      // A '?' on screen alone does not establish that this send answered it. Only an
+      // explicit question citation in the brain's reason can attribute the reply.
+      const citedQuestion = /^Answering question:\s*(.+\?)\s*$/i.exec(decision.reason)?.[1]?.trim();
+      const question = citedQuestion && classifierFrameLines(obs.screen).find((line) => line === citedQuestion);
+      opts.onDecision?.(`step ${obs.step}: ${decision.action}${decision.action === 'ask-human' ? '' : ` — ${decision.reason || decision.text || decision.query || ''}`}`,
+        decision.action === 'send' && decision.text?.trim() && question ? { question, answer: decision.text } : undefined);
       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);
@@ -911,6 +953,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);
+    },
+  };
 }
 
 /**
@@ -974,6 +1067,7 @@ export function makeMissionObserveStep(deps: {
   bus: ChannelBus;
   ident: { ptyId: string; instance: string; runId?: string };
   now?: () => number;
+  onPublishedFrame?: (obs: ControlObservation) => void;
 }): (obs: ControlObservation, decision: ControlDecision) => Promise<void> {
   const now = deps.now ?? ((): number => Date.now());
   let lastFrameState: FrameState | null = null;
@@ -1008,6 +1102,7 @@ export function makeMissionObserveStep(deps: {
       ...(deps.ident.runId ? { runId: deps.ident.runId } : {}),
       ...(pngRef ? { pngRef } : {}),
     });
+    deps.onPublishedFrame?.(obs);
     // capture 는 원 semantics 유지 — 예외 전파(증거/전사 계약 불변).
     await deps.capture(`s${obs.step}-${decision.action}`);
   };
@@ -1260,6 +1355,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;
@@ -1293,10 +1403,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) => {
@@ -1364,10 +1476,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> {
@@ -1574,9 +1688,19 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   if (deps.isMissionAborted?.()) { offLive(); throw new Error('MISSION_ABORTED'); }
   try { h = spawnPty(ptyOpts); }
   catch (error) { offLive(); throw error; }
-  deps.onPtyStarted?.(h, () => { if (liveTimer) clearInterval(liveTimer); offLive(); });
-  if (deps.isMissionAborted?.()) return { ok: false, reason: 'aborted', worktree: wt.path, branch: wt.branch,
-    rounds: 0, evidencePath: null, committed: false, usedOmniCrawl: false, detail: 'aborted' };
+  if (backend.name === 'codex') observeExternalEvent({ origin: 'codex-agent-mission', kind: 'started',
+    summary: 'Codex agent mission started', source: `elanous://agent-mission/${encodeURIComponent(runId)}/${encodeURIComponent(h.id)}` });
+  let contextFinished = false;
+  const finishContext = (ok: boolean): void => {
+    if (contextFinished || backend.name !== 'codex') return;
+    contextFinished = true;
+    observeExternalEvent({ origin: 'codex-agent-mission', kind: 'finished',
+      summary: `Codex agent mission ${ok ? 'completed' : 'failed'}`,
+      source: `elanous://agent-mission/${encodeURIComponent(runId)}/${encodeURIComponent(h.id)}` });
+  };
+  deps.onPtyStarted?.(h, () => { if (liveTimer) clearInterval(liveTimer); offLive(); finishContext(false); });
+  if (deps.isMissionAborted?.()) { finishContext(false); return { ok: false, reason: 'aborted', worktree: wt.path, branch: wt.branch,
+    rounds: 0, evidencePath: null, committed: false, usedOmniCrawl: false, detail: 'aborted' }; }
   const executorRef = buildExecutorPtyRef({
     ptyId: h.id,
     backend: backend.name,
@@ -1589,6 +1713,12 @@ 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 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. */ }
+  };
+
   // ⭐P2 arbiter: the child is accessMode='auto' (brain-owned), so the driver —
   // the autonomous brain — must write as 'agent' or the arbiter denies it. This
   // makes "protected autonomy" real: a human attaching mid-mission (read) can't
@@ -1615,6 +1745,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
         : 'AGENT_YIELDED: PTY 제어가 사람에게 이양됨(takeover) — 자율 미션 중단');
     }
     h['write'](s, 'agent');
+    decisionEvent({ step: 'input', text: s === '\r' ? 'Sent Enter' : `Sent ${s.startsWith('\x1b') ? 'key' : 'text'}: ${s.startsWith('\x1b') ? 'navigation' : s}` });
   };
 
   let seq = 0;
@@ -1638,7 +1769,8 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       if (liveChunks % 20 === 0) debug.log('agent-mission', 'live', { chunks: liveChunks, tail: s.slice(-80).replace(/\s+/g, ' ') });
     }).catch(() => { /* noop */ });
   }, 800);
-  const stopLive = (): void => { if (liveTimer) clearInterval(liveTimer); offLive(); };
+  const stopLive = (ok = false): void => { if (liveTimer) clearInterval(liveTimer); offLive(); if (ok) finishContext(true); };
+  try {
 
   // ready + trust — backend 별 신뢰/권한 프롬프트 처리(codex=1, 이후 백엔드는 자체 handler).
   await (deps.awaitMission ? deps.awaitMission(waitForQuiet(h, 1500, 20000)) : waitForQuiet(h, 1500, 20000));
@@ -1648,7 +1780,11 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   // A trust menu can need more than one key (claude: ↓ to «Yes», then Enter) — answer until it is gone, at most 3 times.
   //   🩸 09-29: one pass sent only ↓, the mission text went into the menu and its Enter confirmed «Yes» instead of
   //   submitting the mission, which then sat unsent in the input box.
-  for (let pass = 0; pass < 3 && backend.handleTrust?.(screen, (s) => drive(s)); pass++) {
+  for (let pass = 0; pass < 3 && backend.handleTrust?.(screen, (s) => {
+    drive(s);
+    // Moving the selection is only input; the trust question is answered when the choice is confirmed.
+    if (s === '\r') decisionEvent({ step: 'answer', text: 'Answered folder trust prompt', detail: { question: 'Trust this folder?', answer: 'Confirm selected choice' } });
+  }); pass++) {
     debug.log('agent-mission', 'trust', { agent: backend.name, action: 'handled', pass });
     const trusted = (async () => { await waitForQuiet(h, 1500, 15000); return capture('trusted'); })();
     screen = await (deps.awaitMission ? deps.awaitMission(trusted) : trusted);
@@ -1744,6 +1880,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 */ }
@@ -1751,9 +1889,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');
   }
 
@@ -1761,13 +1902,21 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   let controllerSummary = deps.previousSummary ?? '';
   let reviewSummary = '';
   let coverageRetries = enhanceActive && checklist.length ? 2 : 0;
+  let pendingAnswer: { text: string; question: string; answer: string } | undefined;
   const search = createMissionSearch({ worktree: wt.path, omniPath });
   const brain = createMissionControlBrain({
     mission: spec.mission,
     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;
+      decisionEvent({ step: 'judge', text });
+    },
     evidenceReady: () => spec.chain && spec.chain.length > 1 ? true : verifyEvidence(wt.path, spec.evidence).ok,
     search: async (query, step) => {
       usedOmni = true;
@@ -1784,9 +1933,14 @@ 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) {
         debug.log('agent-mission', 'trust', { agent: backend.name, action: 'handled-in-loop', step: obs.step });
+        decisionEvent({ step: 'judge', text: `step ${obs.step}: trust prompt` });
+        // Only the confirming Enter answers the trust question; a navigation key stays an input event.
+        if (answer === '\r') pendingAnswer = { text: answer, question: 'Trust this folder?', answer: 'Confirm selected choice' };
         emitDecision({ kind: 'ROUTE', what: `${backend.name} 폴더 신뢰 화면 → 계속`, reason: '시작 뒤 늦게 뜬 신뢰 확인', purpose: '미션을 이어 간다', target: backend.name, phase: 'implement' });
         return { action: 'input', text: answer };
       }
@@ -1845,7 +1999,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;
     },
@@ -1879,15 +2034,37 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     (d) => debug.log('agent-mission.observe', 'progress', { surfaceId: d.surfaceId, state: d.state, summary: d.summary, unknownInput: d.unknownInput, frame: d.frameCount, runId: d.runId }),
     () => {
       const handleDeps = controlDepsForHandle(h);
+      const inject = backend.name === 'claude' ? submitSeparately(handleDeps.inject) : handleDeps.inject;
       const pending = (deps.runControlLoop ?? runPtyControlLoop)(trustAwareBrain, {
         ...handleDeps,
-        ...(backend.name === 'claude' ? { inject: submitSeparately(handleDeps.inject) } : {}),
+        inject: (text) => {
+          const reply = pendingAnswer?.text === text ? pendingAnswer : undefined;
+          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;
+        },
+        injectKey: handleDeps.injectKey && ((name, repeat) => {
+          const accepted = handleDeps.injectKey!(name, repeat);
+          if (accepted) decisionEvent({ step: 'input', text: `Pressed ${name}${repeat ? ` ×${repeat}` : ''}`, detail: { keys: name } });
+          return accepted;
+        }),
         ...(deps.isMissionAborted ? {
           controlStance: () => deps.isMissionAborted!() ? 'unknown' as const : probeControlStance(h, 'agent', (e) =>
             debug.log('agent-mission', 'hascontrol-error', { id: h.id, error: (e as Error)?.message ?? String(e) })),
         } : {}),
         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);
         },
@@ -1903,7 +2080,11 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
           }
         }
       },
-      verifyDone: spec.chain && spec.chain.length > 1 ? async () => ({ ok: true as const }) : verifyDone,
+      verifyDone: spec.chain && spec.chain.length > 1 ? async () => ({ ok: true as const }) : async (obs) => {
+        const verdict = await verifyDone(obs);
+        if (!verdict.ok) decisionEvent({ step: 'recover', text: 'Evidence check requires another attempt', detail: { blocked: verdict.retry, action: 'Retry after fixing evidence' } });
+        return verdict;
+      },
       handoff: async (decision, obs) => {
         try {
           if (spec.chain && decision.to !== spec.chain[1]) throw new Error(`chain order violation: expected ${spec.chain[1] ?? 'completion'}, got ${decision.to}`);
@@ -1916,12 +2097,13 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       askHuman: async (decision) => {
         try {
           await waitForHumanLogin(decision, handoffOps);
+          decisionEvent({ step: 'answer', text: 'Human login question resolved', detail: { question: decision.reason, answer: 'Login completed' } });
         } catch (error) {
           transitionFailure = error instanceof Error ? error.message : String(error);
           throw error;
         }
       },
-      }, { maxSteps: maxRounds });
+      }, { maxSteps: maxRounds, stuckLimit: maxRounds + 1 });
       deps.onControlActive?.(pending);
       return pending;
     },
@@ -1954,7 +2136,9 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   }
   // A gate/PR handoff only counts as success when the control loop itself did not end in error.
   if (gatedHandoff && control.termination.kind !== 'error') {
-    stopLive();
+    // The gate hands off a branch, not a file: record what is known instead of mislabeling the worktree directory.
+    decisionEvent({ step: 'done', text: 'Mission handoff gate completed', detail: { result: { kind: 'text', ref: `branch ${wt.branch}` } } });
+    stopLive(true);
     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 } : {}),
@@ -1985,6 +2169,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       maxFallbackDescents: runtimeFallback.maxDescents,
     });
     if (nextBackend && !deps.isMissionAborted?.()) {
+      decisionEvent({ step: 'recover', text: `Switching ${backend.name} to ${nextBackend.name}`, detail: { blocked: control.termination.message, action: `Retry with ${nextBackend.name}` } });
       const nextStep: FallbackStep = nextBackend.name === 'grok' ? 'grok' : 'codex-rotate';
       stopLive();
       if (h.pid) await (deps.terminateProcessTree ?? terminateMissionProcessTree)(h.pid);
@@ -2011,24 +2196,31 @@ 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 });
-  stopLive();
+  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,
+    ok: accepted, worktree: wt.path, branch: wt.branch, rounds: round,
     evidencePath, committed, usedOmniCrawl: usedOmni,
     ptyId: h.id, webUrl: webAddress.webUrl,
-    detail: done ? '완료(증거 충족)' : (finalEv.ok ? '증거 충족(루프 종료)' : '미완(증거 부족)'),
+    detail: recoverExhausted ? control.termination.reason : driveVerdict.kind === 'done-but-failed' ? `미완(DRIVE-OK: ${driveVerdict.reason})` : done ? '완료(증거 충족)' : (finalEv.ok ? '증거 충족(루프 종료)' : '미완(증거 부족)'),
   };
+  } finally { stopLive(); finishContext(false); }
 }
 
 /** @deprecated codex 특정 이름 — runAgentMission 을 쓰라(codex 는 기본 backend). */

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

@@ -0,0 +1,71 @@
+import { debug } from '../debug/log.js';
+
+type Identity = {
+  ts: string;
+  missionId: string;
+  seq: number;
+  sessionId: string;
+  terminalId: string;
+  agent: string;
+  text: string;
+};
+type Detail = { keys?: string; row?: number };
+
+export type PtyDecision = Identity & (
+  | { step: 'read' | 'judge' | 'input'; detail?: Detail }
+  | { step: 'answer'; detail: Detail & { question: string; answer: string } }
+  | { step: 'recover'; detail: Detail & { blocked: string; action: string } }
+  | { step: 'done'; detail: Detail & { result: { kind: 'pr' | 'file' | 'text'; ref: string } } }
+);
+
+export type DecisionInput = Omit<Identity, 'ts' | 'seq'> & (
+  | { step: 'read' | 'judge' | 'input'; detail?: Detail }
+  | { step: 'answer'; detail: Detail & { question: string; answer: string } }
+  | { step: 'recover'; detail: Detail & { blocked: string; action: string } }
+  | { step: 'done'; detail: Detail & { result: { kind: 'pr' | 'file' | 'text'; ref: string } } }
+);
+
+const missionStreams = new Map<string, { alias: string; seq: number }>();
+export const PTY_DECISION_TEXT_MAX = 240;
+
+function safe(value: string): string {
+  const masked = value
+    .replace(/\bBearer\s+(?:"[^"]*"|'[^']*'|[^\s"'<>]+)/gi, 'Bearer [redacted]')
+    .replace(/\b([a-z0-9_]*(?:token|key(?:[_-]?id)?|secret|password|authorization)\s*[:=]\s*)(?:"[^"]*"|'[^']*'|[^\s"'<>]+)/gi, '$1[redacted]')
+    .replace(/\b(?:sk-[a-z0-9_-]+|gh[pousr]_[a-z0-9_]+|github_pat_[a-z0-9_]+|AIza[a-z0-9_-]+|xox[baprs]-[a-z0-9-]+)\b/gi, '[redacted]')
+    .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, '[redacted]')
+    .replace(/[\x00-\x1f\x7f-\x9f]/g, ' ')
+    .trim();
+  const clipped = masked.slice(0, PTY_DECISION_TEXT_MAX);
+  return clipped.replace(/[\uD800-\uDBFF]$/, '') || '[redacted]';
+}
+
+/** The only emission point for the inside-PTY decision stream. Never log unsanitized input. */
+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 };
+    missionStreams.set(input.missionId, stream);
+  }
+  stream.seq += 1;
+  const base = {
+    ts: new Date().toISOString(),
+    missionId: stream.alias,
+    seq: stream.seq,
+    sessionId: safe(input.sessionId),
+    terminalId: safe(input.terminalId),
+    agent: safe(input.agent),
+    text: safe(input.text),
+  };
+  const common = input.detail ? {
+    ...(input.detail.keys !== undefined ? { keys: safe(input.detail.keys) } : {}),
+    ...(input.detail.row !== undefined ? { row: input.detail.row } : {}),
+  } : {};
+  let decision: PtyDecision;
+  if (input.step === 'answer') decision = { ...base, step: input.step, detail: { ...common, question: safe(input.detail.question), answer: safe(input.detail.answer) } };
+  else if (input.step === 'recover') decision = { ...base, step: input.step, detail: { ...common, blocked: safe(input.detail.blocked), action: safe(input.detail.action) } };
+  else if (input.step === 'done') decision = { ...base, step: input.step, detail: { ...common, result: { kind: input.detail.result.kind, ref: safe(input.detail.result.ref) } } };
+  else decision = { ...base, step: input.step, ...(input.detail ? { detail: common } : {}) };
+  log('pty.decision', decision.step, decision);
+  return decision;
+}