elanous 0.2.11 → 0.2.12

package/scripts/ux/demo-seed.ts

@@ -0,0 +1,108 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+export type SeedArgs = { only: 'graph' | 'wizard' | 'all'; dryRun: boolean; json: boolean };
+export type SeedEvent = { target: 'graph' | 'wizard'; phase: 'start' | 'finish' | 'failure'; command: string[]; exitCode?: number; output?: string };
+
+export const SCENE_SIX_GUIDANCE = '⑥ PTY 인텔리전스는 이 시드로 생성하지 않습니다. 실제 격리 미션을 실행하고 read → judge → answer 이벤트를 관측하세요.';
+const GRAPH = 'graphs/demo/inside-seed.yaml';
+const WIZARD_REQUEST = '데모용 자료 조사 커넥터와 스킬·그래프 초안을 만들어 주세요. 설치하거나 실행하지 마세요.';
+const DRAFT = { description: 'Demo research draft only; no connector credentials or outbound messages.', connectors: [],
+  skill: { description: 'Demo research draft', instructions: 'Research draft only. Implement and validate processing before installing or running.', requires: [] } };
+
+export function parseArgs(argv: string[]): SeedArgs {
+  const result: SeedArgs = { only: 'all', dryRun: false, json: false };
+  const seen = new Set<string>();
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i]!;
+    if (!['--only', '--dry-run', '--json'].includes(flag)) throw new Error(`알 수 없는 인자: ${flag}`);
+    if (seen.has(flag)) throw new Error(`중복 인자: ${flag}`);
+    seen.add(flag);
+    if (flag === '--only') {
+      const value = argv[++i];
+      if (value !== 'all' && value !== 'graph' && value !== 'wizard') throw new Error('--only 값은 graph|wizard|all 이어야 합니다');
+      result.only = value;
+    } else if (flag === '--dry-run') result.dryRun = true;
+    else result.json = true;
+  }
+  return result;
+}
+
+export type SeedDeps = {
+  repo: string;
+  run: (command: string[], cwd: string) => Promise<{ exitCode: number; output: string; stdout?: string }>;
+  prepareDraft: (repo: string) => { file: string; parent: string };
+};
+
+function prepareDraft(repo: string): { file: string; parent: string } {
+  const root = resolve(repo, '.elanous-test', 'demo-seed');
+  mkdirSync(root, { recursive: true });
+  const parent = mkdtempSync(join(root, 'wizard-'));
+  const file = join(parent, 'research-draft.json');
+  writeFileSync(file, JSON.stringify(DRAFT) + '\n');
+  return { file, parent };
+}
+
+const defaultDeps: SeedDeps = {
+  repo: resolve(import.meta.dir, '../..'),
+  prepareDraft,
+  run: async (command, cwd) => {
+    const child = Bun.spawn(command, { cwd, env: { ...process.env, NODE_ENV: 'test' }, stdout: 'pipe', stderr: 'pipe' });
+    const [output, errors, exitCode] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+    return { exitCode, stdout: output, output: [output, errors].filter(Boolean).join('\n').trim() };
+  },
+};
+
+export async function seed(args: SeedArgs, deps: SeedDeps = defaultDeps, onEvent?: (event: SeedEvent) => void): Promise<{ events: SeedEvent[]; guidance: string; ok: boolean }> {
+  const events: SeedEvent[] = [];
+  const emit = (event: SeedEvent): void => { events.push(event); onEvent?.(event); };
+  let ok = true;
+  for (const target of (args.only === 'all' ? ['graph', 'wizard'] : [args.only]) as Array<'graph' | 'wizard'>) {
+    const base = ['bun', 'bin/elanous.mjs', '--test'];
+    const graphCommand = [...base, 'graph', 'run', GRAPH, '--json'];
+    const wizardCommand = [...base, 'plugin', 'make', WIZARD_REQUEST, '--name', 'inside-demo-draft', '--draft-file', '<isolated-draft-file>', '--dir', '<isolated-parent>', '--json'];
+    const command = target === 'graph' ? graphCommand : wizardCommand;
+    if (args.dryRun) {
+      emit({ target, phase: 'start', command });
+      emit({ target, phase: 'finish', command, exitCode: 0, output: 'dry-run: no process started' });
+      continue;
+    }
+    try {
+      if (target === 'wizard') {
+        const { file, parent } = deps.prepareDraft(deps.repo);
+        command.splice(command.indexOf('<isolated-draft-file>'), 1, file);
+        command.splice(command.indexOf('<isolated-parent>'), 1, parent);
+      }
+      emit({ target, phase: 'start', command });
+      const result = await deps.run(command, deps.repo);
+      const parsed = (() => {
+        try { return JSON.parse(result.stdout ?? result.output) as { status?: string; dryRun?: boolean; errors?: string[]; timings?: { install?: number } }; } catch { return null; }
+      })();
+      const complete = target === 'wizard'
+        ? parsed?.status === 'draft' && parsed.timings?.install === 0 && parsed.errors?.length === 0
+        : parsed?.status === 'done' && parsed.dryRun === false;
+      const phase = result.exitCode === 0 && complete ? 'finish' : 'failure';
+      emit({ target, phase, command, exitCode: result.exitCode, output: result.output });
+      if (phase === 'failure') ok = false;
+    } catch (error) {
+      ok = false;
+      emit({ target, phase: 'failure', command, output: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { events, guidance: SCENE_SIX_GUIDANCE, ok };
+}
+
+if (import.meta.main) {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const report = await seed(args, defaultDeps, args.json ? undefined : (event) => {
+      console.log(`${event.target} ${event.phase}${event.exitCode === undefined ? '' : ` (exit ${event.exitCode})`}: ${event.command.join(' ')}${event.output ? `\n${event.output}` : ''}`);
+    });
+    if (args.json) console.log(JSON.stringify(report));
+    else console.log(report.guidance);
+    if (!report.ok) process.exitCode = 1;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}

package/scripts/ux/lib/rehearsal-verdict.ts

@@ -10,6 +10,8 @@ export type SceneObservation = {
   leaks: string[];
   sectionsInDom: number;
   visibleScene: number | null;
+  /** Empty-state phrases observed in the visible scene. */
+  emptyStates?: string[];
   /** Number of captured JPEG frames with no discernible scene content. */
   blankFrames?: number;
 };
@@ -36,7 +38,7 @@ export function failedApiResponse(url: string, status: number): string | null {
   } catch { return null; }
 }
 
-export type SceneResult = SceneObservation & { verdict: 'ok' | 'broken' | 'unverified'; reasons: string[] };
+export type SceneResult = SceneObservation & { verdict: 'ok' | 'broken' | 'unverified' | 'no-data'; reasons: string[] };
 
 /** A scene the demo hides is not a pass — it was not seen. OP 10-03: ⑤ (wizard → market) is the 10-08 highlight. */
 export const UNVERIFIED_REASON = '시연 모드에서 숨긴 장면 — WIZ1 착지 뒤 실물 필요';
@@ -58,16 +60,21 @@ export function judgeScene(obs: SceneObservation): SceneResult {
   if (obs.sectionsInDom < 6) reasons.push(`장면 언마운트 (${obs.sectionsInDom}/6)`);
   if (obs.visibleScene !== obs.scene) reasons.push(`보이는 장면 불일치 (기대 ${obs.scene}, 실제 ${obs.visibleScene ?? '없음'})`);
   if (obs.leaks.length) reasons.push(`공개 화면 누설 ${obs.leaks.length}건`);
-  return { ...obs, verdict: reasons.length ? 'broken' : 'ok', reasons };
+  if (reasons.length) return { ...obs, verdict: 'broken', reasons };
+  if (obs.emptyStates?.length) return { ...obs, verdict: 'no-data', reasons: obs.emptyStates.map((phrase) => `실데이터 없음 — ${phrase}`) };
+  return { ...obs, verdict: 'ok', reasons };
 }
 
 export function judgeRun(scenes: SceneResult[]) {
   const ok = scenes.filter((scene) => scene.verdict === 'ok').length;
   const broken = scenes.filter((scene) => scene.verdict === 'broken').length;
   const unverified = scenes.filter((scene) => scene.verdict === 'unverified').length;
-  // broken wins; otherwise any unseen scene keeps the whole run from reading as a pass.
-  const verdict = broken ? 'broken' as const : unverified ? 'unverified' as const : 'ok' as const;
+  const noData = scenes.filter((scene) => scene.verdict === 'no-data').length;
+  // Broken wins, then unseen scenes, then scenes without real data; none is a pass.
+  const verdict = broken ? 'broken' as const : unverified ? 'unverified' as const : noData ? 'no-data' as const : 'ok' as const;
   const banner = scenes.filter((scene) => scene.verdict === 'unverified')
     .map((scene) => `${CIRCLED[scene.scene - 1] ?? scene.scene} 미검증 — WIZ1 착지 뒤 실물 필요`);
-  return { verdict, ok, broken, unverified, banner, scenes };
+  const noDataScenes = scenes.filter((scene) => scene.verdict === 'no-data').map((scene) => CIRCLED[scene.scene - 1] ?? String(scene.scene));
+  if (noDataScenes.length) banner.push(`${noDataScenes.join('')} 실데이터 없음 — 런·PTY·마법사가 도는 판에서 다시`);
+  return { verdict, ok, broken, unverified, noData, banner, scenes };
 }

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;
   /** 스크린 캡처 저장 디렉토리. */
@@ -538,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;
@@ -835,18 +845,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 +915,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 +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);
+    },
+  };
 }
 
 /**
@@ -1273,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;
@@ -1306,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) => {
@@ -1377,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> {
@@ -1779,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 */ }
@@ -1786,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');
   }
 
@@ -1803,6 +1909,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 +1933,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 +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;
     },
@@ -1916,7 +2027,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 +2042,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 +2063,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 +2103,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
           throw error;
         }
       },
-      }, { maxSteps: maxRounds });
+      }, { maxSteps: maxRounds, stuckLimit: maxRounds + 1 });
       deps.onControlActive?.(pending);
       return pending;
     },
@@ -2079,24 +2196,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,
+    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); }
 }

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

@@ -41,7 +41,7 @@ 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 };

package/src/autopilot/pty-control-loop.ts

@@ -88,7 +88,7 @@ export type ControlDecision =
   | { readonly action: 'handoff'; readonly to: 'codex' | 'claude' | 'elanous'; readonly mission: string; readonly carry?: 'diff' | 'summary' }
   | { readonly action: 'ask-human'; readonly reason: string; readonly url?: string; readonly code?: string }
   /** `no-progress` reports observed lack of progress without claiming completion. */
-  | { readonly action: 'no-progress'; readonly reason: string };
+  | { readonly action: 'no-progress'; readonly reason: string; readonly terminal?: boolean };
 
 export interface RunSupervisor {
   /** run supervisor의 관측 → 다음 행동. 동기/비동기 모두 허용(LLM 은 async). `signal` 이 abort 되면(사람 takeover
@@ -664,6 +664,9 @@ export async function runPtyControlLoop(
           previousIntervention = { ...intervention, sameScreenCount: 1 };
         }
       } else if (decision.action === 'wait' || decision.action === 'no-progress') {
+        if (decision.action === 'no-progress' && decision.terminal) {
+          return finish({ kind: 'stuck', iteration: step, reason: decision.reason }, step, intervention, true);
+        }
         // wait/no-progress — 종료된 자식은 새 출력을 낼 수 없으므로 대기 없이 즉시 수렴한다.
         if (deps.isAlive?.() === false) {
           debug.log('autopilot.control', 'child-exited', { step });

package/src/chat/index.ts

@@ -438,6 +438,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'clear', aliases: ['cls'],       description: '대화 기록 지우기' },
   { name: 'status', aliases: ['st'], description: '지금 상태 — 모델 · 연결 · 계정' },
   { name: 'now', aliases: [], description: '현재 맥락과 출처 표 — /now [주제]' },
+  { name: 'wish', aliases: [], description: '소원을 카드로 남기기 — /wish <소원 한 줄>' },
   { name: 'remaining', aliases: [], description: '계정별 남은 사용량' },
   { name: 'setup', aliases: [], description: '상세 설정 — /setup · /setup reset(다음 실행 때 마법사 다시)', subcommands: ['help', 'reset'] },
   { name: 'quit',  aliases: ['q', 'exit'], description: '나가기' },

package/src/cli/persona-cli.ts

@@ -7,7 +7,7 @@ import { parse as parseYaml } from 'yaml';
 import { debug } from '../debug/log.js';
 import { parsePersonaYaml } from '../persona/loader.js';
 import { resolveRepositoryPersonaDir, resolveStatePersonaDir } from '../persona/global-registry.js';
-import { choosePersonaId, clonePreset, describePreset, editPersona, findPreset, loadPresetIndex, loadPresets, presetToProfileYaml } from '../persona/presets.js';
+import { UnknownPersonaSchemaKeyError, choosePersonaId, clonePreset, describePreset, editPersona, findPreset, loadPresetIndex, loadPresets, presetToProfileYaml } from '../persona/presets.js';
 import { addTeamSet, listTeamSets, removeTeamSet } from '../persona/team-set.js';
 
 interface StoredPersona { personaId: string; displayName: string; description?: string; preset?: string; title?: string; path: string }
@@ -43,11 +43,11 @@ function mapping(value: unknown): value is Record<string, unknown> {
 
 function setEdit(edits: Record<string, unknown>, assignment: string): void {
   const equals = assignment.indexOf('=');
-  if (equals < 1) throw new Error(`--set requires key=value: ${assignment}`);
+  if (equals < 0) throw new Error(`--set requires key=value: ${assignment}`);
   const key = assignment.slice(0, equals);
   const parts = key.split('.');
   if (parts.some((part) => !part || ['__proto__', 'prototype', 'constructor'].includes(part))) {
-    throw new Error(`invalid --set key: ${key}`);
+    throw new UnknownPersonaSchemaKeyError(key);
   }
   const value: unknown = parseYaml(assignment.slice(equals + 1));
   let target = edits;
@@ -94,7 +94,7 @@ export function registerPersonaCommands(program: Command): void {
       if (opts.json) { console.log(JSON.stringify({ presets: presets.map((p) => ({ id: p.personaId, displayName: p.displayName, role: p.role, oneLine: p.oneLine })), mine }, null, 2)); return; }
       if (!presets.length) console.log('페르소나 프리셋을 찾지 못했습니다(persona-presets/ 가 이 설치본에 없습니다).');
       else {
-        console.log('프리셋 — 골라서 내 페르소나로 만들기: elanous persona add <프리셋> [--name <이름>]');
+        console.log('프리셋 — 골라서 내 페르소나로 만들기: elanous persona add <이름> [--from <프리셋>]');
         const width = Math.max(...presets.map((p) => p.personaId.length));
         for (const p of presets) console.log(`  ${p.personaId.padEnd(width)}  ${p.displayName} — ${p.role} · ${p.oneLine}`);
       }
@@ -105,24 +105,27 @@ export function registerPersonaCommands(program: Command): void {
       }
     });
 
-  persona.command('add <preset>')
-    .description('Make your own persona from a preset (id, name or role) — the preset file is not changed')
+  persona.command('add <name>')
+    .description('Make your own persona from a preset — the preset file is not changed')
+    .option('--from <preset>', 'Preset to clone (defaults to the named preset)')
     .option('--name <name>', 'What to call it (default: the preset’s first name)')
     .option('--as <name>', 'Clone this preset under a new, unique name')
     .option('--title <title>', 'Optional title, e.g. CMO')
     .option('--json', 'JSON output')
-    .action((query: string, opts: { name?: string; as?: string; title?: string; json?: boolean }) => {
+    .action((query: string, opts: { from?: string; name?: string; as?: string; title?: string; json?: boolean }) => {
       const presets = loadPresets();
-      const preset = findPreset(presets, query);
+      const presetQuery = opts.from ?? query;
+      const preset = findPreset(presets, presetQuery);
       if (!preset) {
-        console.error(`프리셋 «${query}» 을 찾지 못했습니다. 있는 것: ${presets.map((p) => p.personaId).join(', ')}`);
+        console.error(`프리셋 «${presetQuery}» 을 찾지 못했습니다. 있는 것: ${presets.map((p) => p.personaId).join(', ')}`);
         process.exitCode = 1;
         return;
       }
-      if (opts.as !== undefined) {
+      if (opts.as !== undefined || opts.from !== undefined) {
         try {
-          if (opts.name !== undefined || opts.title !== undefined) throw new Error('--as cannot be combined with --name or --title');
-          const result = clonePreset(preset, opts.as);
+          if (opts.from !== undefined && (opts.as !== undefined || opts.name !== undefined || opts.title !== undefined)) throw new Error('--from cannot be combined with --as, --name or --title');
+          if (opts.as !== undefined && (opts.name !== undefined || opts.title !== undefined)) throw new Error('--as cannot be combined with --name or --title');
+          const result = clonePreset(preset, opts.from !== undefined ? query : opts.as!);
           debug.log('persona.cli', 'cloned', { preset: preset.personaId, personaId: result.personaId });
           if (opts.json) console.log(JSON.stringify({ personaId: result.personaId, displayName: result.displayName, preset: preset.personaId, path: result.path }, null, 2));
           else {
@@ -170,8 +173,8 @@ export function registerPersonaCommands(program: Command): void {
           console.log(`  파일: ${result.path}`);
         }
       } catch (err) {
-        console.error(err instanceof Error ? err.message : String(err));
-        process.exitCode = 1;
+        console.error(err instanceof Error ? err.message.replace(/\s+/g, ' ').trim() : String(err));
+        process.exitCode = err instanceof UnknownPersonaSchemaKeyError ? 2 : 1;
       }
     });
 

package/src/cli/pod-cli.ts

@@ -3,6 +3,7 @@
 
 import type { Command } from 'commander';
 import { debug } from '../debug/log.js';
+import { readPodMemoryAdvice } from './pod-memory-advice.js';
 import { getUserConfig } from '../user-config.js';
 import { listCodexAccountsInStore } from '../oauth/codex-account-store.js';
 import { parsePodPool, resolvePodPoolSpec, type PoolKubectl } from '../task-orchestrator/surfaces/pod-pool.js';
@@ -24,6 +25,7 @@ export interface PodCliDeps {
   perAccount?: () => number;
   poolSpec?: (explicit?: string) => string | null;
   harnessPool?: () => string | undefined;
+  memoryAdvice?: (logsDb?: string) => ReturnType<typeof readPodMemoryAdvice>;
 }
 
 const HELP = `elanous pod run [--pool <스펙>] [--skill <이름,…>] [--llm grok] [--clone] [--deadline <초>] -- <명령…>
@@ -38,6 +40,21 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
   };
   const run = deps.run ?? ((options: RunPodCommandOptions) => runPodCommand(options));
   const pod = program.command('pod').description('Pod 명령 Job — 하니스 없이 명령 하나를 돌리고 산출을 돌려받는다');
+  pod.command('memory').description('실측 기반 Pod 메모리 권고 (읽기 전용)')
+    .command('advise').description('골 종류별 standard 16Gi / high 32Gi 권고와 근거')
+    .option('--json', '권고와 측정 근거를 JSON 으로')
+    .option('--logs-db <path>', '기존 logs.db 경로')
+    .action((opts: { json?: boolean; logsDb?: string }) => {
+      try {
+        const advice = (deps.memoryAdvice ?? readPodMemoryAdvice)(opts.logsDb);
+        if (opts.json) io.log(JSON.stringify(advice));
+        else for (const row of advice.byGoalType) io.log(`${row.goalType}: ${row.recommended} ${row.limit} · ${row.reason}`);
+        io.exit(0);
+      } catch (err) {
+        io.error(err instanceof Error ? err.message : String(err));
+        io.exit(1);
+      }
+    });
   pod.command('lease').description('Pod 풀 동시 실행 권장 (DNS 점검용 Pod 를 잠깐 만들었다 지움)')
     .command('status').description('지금 추가로 쏠 수 있는 Pod 골과 제한 근거')
     .option('--pool <spec>', '풀 스펙 — 컨텍스트[@ssh호스트][:상한][#레지스트리:포트] 쉼표')