elanous 0.2.0 → 0.2.5

package/src/agent-mission/env-profile.ts

@@ -0,0 +1,68 @@
+import { spawnSync } from 'node:child_process';
+
+const PACKAGE_MANAGERS = ['brew', 'apt', 'npm', 'pip', 'bun'] as const;
+const CLI_TOOLS = ['git', 'jq', 'rg', 'sed', 'awk', 'curl', 'ffmpeg', 'docker', 'kubectl', 'gh', 'codex', 'claude'] as const;
+
+export interface EnvProfile {
+  os: string;
+  shell: string | null;
+  packageManagers: string[];
+  tools: string[];
+  credentials: Record<string, boolean>;
+  network: boolean;
+  disk: { availableKb: number } | null;
+}
+
+export interface EnvProfileDeps {
+  which?: (name: string) => boolean;
+  exec?: (command: string, args: string[]) => { status: number | null; stdout: string };
+  env?: NodeJS.ProcessEnv;
+}
+
+const defaultExec: NonNullable<EnvProfileDeps['exec']> = (command, args) => {
+  const result = spawnSync(command, args, { encoding: 'utf8', timeout: 3_000, maxBuffer: 64 * 1024 });
+  return { status: result.status, stdout: result.stdout ?? '' };
+};
+
+const defaultWhich: NonNullable<EnvProfileDeps['which']> = (name) =>
+  spawnSync('which', [name], { stdio: 'ignore', timeout: 3_000 }).status === 0;
+
+/** Collects a bounded, non-secret snapshot; no credential value is read or returned. */
+export function collectEnvProfile(deps: EnvProfileDeps = {}): EnvProfile {
+  const which = deps.which ?? defaultWhich;
+  const exec = deps.exec ?? defaultExec;
+  const env = deps.env ?? process.env;
+  const available = (name: string): boolean => {
+    try { return which(name); } catch { return false; }
+  };
+  const run = (command: string, args: string[]): { status: number | null; stdout: string } | null => {
+    try { return exec(command, args); } catch { return null; }
+  };
+
+  const packageManagers = PACKAGE_MANAGERS.filter(available);
+  const tools = CLI_TOOLS.filter(available);
+  const credentials = {
+    github: Object.hasOwn(env, 'GH_TOKEN') || Object.hasOwn(env, 'GITHUB_TOKEN'),
+    openai: Object.hasOwn(env, 'OPENAI_API_KEY'),
+    anthropic: Object.hasOwn(env, 'ANTHROPIC_API_KEY'),
+  };
+  const network = tools.includes('curl') && run('curl', ['--head', '--silent', '--output', '/dev/null', '--max-time', '3', 'https://example.com'])?.status === 0;
+  const diskResult = run('df', ['-kP', '.']);
+  const diskFields = diskResult?.status === 0
+    ? diskResult.stdout.trim().split(/\r?\n/).slice(1).join(' ').trim().split(/\s+/)
+    : [];
+  const availableKb = diskFields.length >= 6
+    && diskFields.slice(1, 4).every((field) => /^\d+$/.test(field))
+    && /^\d+%$/.test(diskFields[4]!)
+    ? Number(diskFields[3]) : NaN;
+
+  return {
+    os: process.platform,
+    shell: env.SHELL ?? null,
+    packageManagers,
+    tools,
+    credentials,
+    network,
+    disk: Number.isFinite(availableKb) && availableKb >= 0 ? { availableKb } : null,
+  };
+}

package/src/agent-mission/handoff.ts

@@ -0,0 +1,128 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync, lstatSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ControlDecision } from '../autopilot/pty-control-loop.js';
+import { emitDecision } from '../live/detail-switch.js';
+
+type MissionHandoff = Extract<ControlDecision, { action: 'handoff' }>;
+type MissionAskHuman = Extract<ControlDecision, { action: 'ask-human' }>;
+
+export interface HandoffOperations {
+  start: (to: 'codex' | 'claude', mission: string, worktree: string) => Promise<void>;
+  gateAndPr: (worktree: string) => Promise<void>;
+  claudeLoggedIn: () => boolean;
+  notify: (card: { text: string; url?: string; code?: string }) => Promise<void> | void;
+  screen: () => Promise<string>;
+  alive: () => boolean;
+  sleep: (ms: number) => Promise<void>;
+  diff?: (worktree: string) => string;
+  /** Launch the official Claude login CLI in a PTY before asking a human to authenticate. */
+  login?: (worktree: string) => Promise<{ screen: () => Promise<string>; alive: () => boolean; close: () => void }>;
+}
+
+export const MAX_HANDOFF_DIFF_BYTES = 256 * 1024 * 1024;
+
+export function missionDiff(worktree: string): string {
+  // Large patches are normal for big missions; the default 1 MiB buffer would abort the handoff before review.
+  const tracked = execFileSync('git', ['diff', '--binary', 'HEAD', '--'], { cwd: worktree, encoding: 'utf8', maxBuffer: MAX_HANDOFF_DIFF_BYTES });
+  const names = execFileSync('git', ['ls-files', '--others', '--exclude-standard', '-z'], { cwd: worktree }).toString('utf8').split('\0').filter(Boolean);
+  const patches = names.filter((name) => !name.startsWith('.mission-') && lstatSync(join(worktree, name)).isFile()).map((name) => {
+    const result = spawnSync('git', ['diff', '--no-index', '--binary', '--', '/dev/null', name], { cwd: worktree, encoding: 'utf8', maxBuffer: MAX_HANDOFF_DIFF_BYTES });
+    if (result.error || (result.status !== 0 && result.status !== 1)) throw new Error(`cannot diff untracked file ${name}: ${result.stderr || result.error?.message || result.status}`);
+    if (result.stdout) return result.stdout;
+    // Git emits no patch at all for an empty new file; its mode and empty-blob id are sufficient to restore it.
+    const quote = (path: string): string => /[\s"\\]/.test(path) ? JSON.stringify(path) : path;
+    return `diff --git ${quote(`a/${name}`)} ${quote(`b/${name}`)}\nnew file mode 100644\nindex 0000000..e69de29\n`;
+  });
+  return [tracked, ...patches].join('');
+}
+
+/** Only a visible login URL/device code leaves the screen; never inspect credential stores. */
+export function loginCard(_decision: MissionAskHuman, screen: string): { text: string; url?: string; code?: string } {
+  const visibleUrl = screen.match(/https?:\/\/[^\s<>"']+/i)?.[0];
+  // Keep visible HTTPS login links, but never forward credential-bearing callback parameters or fragments.
+  let url: string | undefined;
+  if (visibleUrl) {
+    try {
+      const parsed = new URL(visibleUrl);
+      const sensitive = /(?:^|[_-])(?:access[_-]?token|refresh[_-]?token|id[_-]?token|secret|credential|password|ticket|session|auth[_-]?code|code)(?:$|[_-])/i;
+      if (parsed.protocol === 'https:' && !parsed.username && !parsed.password
+        && [...parsed.searchParams.keys()].every((key) => !sensitive.test(key))
+        && (!parsed.hash || /^#[\w/-]+$/.test(parsed.hash))) url = visibleUrl;
+    } catch { /* not a URL */ }
+  }
+  const code = screen.match(/(?:device\s*code|enter\s*code)\s*[:：]\s*([A-Z0-9-]{4,})/i)?.[1];
+  return { text: '로그인해 주세요', ...(url ? { url } : {}), ...(code ? { code } : {}) };
+}
+
+export function isLoginScreen(screen: string): boolean {
+  return /login|log in|sign in|authenticate|device code|인증|로그인/i.test(screen);
+}
+
+export async function waitForHumanLogin(decision: MissionAskHuman, ops: HandoffOperations): Promise<void> {
+  const first = await ops.screen();
+  if (!isLoginScreen(first)) throw new Error('ask-human requested without a visible login screen');
+  const card = loginCard(decision, first);
+  if ((decision.url && card.url !== decision.url) || (decision.code && card.code !== decision.code)) {
+    throw new Error('ask-human URL or device code is not verified on the login screen');
+  }
+  emitDecision({ kind: 'ESCALATE', what: '로그인 필요 → 사람', reason: 'login screen requires human authentication', purpose: 'mission login', target: 'human', phase: 'implement' });
+  await ops.notify(card);
+  while (ops.alive()) {
+    await ops.sleep(1000);
+    if (!isLoginScreen(await ops.screen())) return;
+  }
+  throw new Error('login PTY exited before authentication completed');
+}
+
+/** Coordinator shared by brain decisions and the explicit CLI chain. No new worktree is created. */
+export async function handoffMission(
+  decision: MissionHandoff,
+  worktree: string,
+  ops: HandoffOperations,
+  summary = '',
+): Promise<'started' | 'gated'> {
+  if (decision.to === 'elanous') {
+    emitDecision({ kind: 'ROUTE', what: 'handoff → elanous', reason: 'mission evidence gate and PR', purpose: 'mission gate', target: 'elanous', phase: 'gate' });
+    const carryFile = join(worktree, '.mission-handoff.diff');
+    if (existsSync(carryFile)) unlinkSync(carryFile);
+    await ops.gateAndPr(worktree);
+    return 'gated';
+  }
+  if (decision.to === 'claude' && !ops.claudeLoggedIn()) {
+    if (!ops.login) throw new Error('Claude login PTY unavailable');
+    const login = await ops.login(worktree);
+    try {
+      let screen = await login.screen();
+      while (login.alive() && !ops.claudeLoggedIn() && !isLoginScreen(screen)) {
+        await ops.sleep(1000);
+        screen = await login.screen();
+      }
+      if (!ops.claudeLoggedIn()) {
+        if (!login.alive()) throw new Error('Claude login PTY exited before authentication completed');
+        const card = loginCard({ action: 'ask-human', reason: 'Claude subscription login required' }, screen);
+        if (!card.url && !card.code) throw new Error('Claude login PTY did not show a safe URL or device code');
+        emitDecision({ kind: 'ESCALATE', what: '로그인 필요 → 사람', reason: 'Claude subscription login required', purpose: 'mission login', target: 'human', phase: 'implement' });
+        await ops.notify(card);
+        while (login.alive() && (!ops.claudeLoggedIn() || isLoginScreen(await login.screen()))) await ops.sleep(1000);
+      }
+      if (!ops.claudeLoggedIn()) throw new Error('Claude subscription still unavailable after login');
+    } finally { login.close(); }
+  }
+  const carryFile = join(worktree, '.mission-handoff.diff');
+  // lstat, not exists: a dangling or planted symlink must be removed, never followed.
+  const carryPresent = (() => { try { lstatSync(carryFile); return true; } catch { return false; } })();
+  if (carryPresent) unlinkSync(carryFile);
+  let note = decision.mission;
+  if (decision.carry === 'diff') {
+    const diff = (ops.diff ?? missionDiff)(worktree);
+    // Exclusive create: if something reappears at this path, fail instead of writing through it.
+    writeFileSync(carryFile, diff, { mode: 0o600, flag: 'wx' });
+    note += '\nRead .mission-handoff.diff and review the changes before responding.';
+  } else if (decision.carry === 'summary') {
+    note += `\nPrevious controller summary: ${summary || 'No summary available.'}`;
+  }
+  emitDecision({ kind: 'ROUTE', what: `handoff → ${decision.to}`, reason: decision.to === 'claude' ? '리뷰 = claude · 왜: 다른 눈' : 'continue mission with review findings', purpose: 'mission continuation', target: decision.to, phase: 'implement' });
+  await ops.start(decision.to, note, worktree);
+  return 'started';
+}

package/src/agent-mission/in-agent-plugin.ts

@@ -0,0 +1,311 @@
+import type { PtyHandle } from '../pty-shell/registry.js';
+import { classifierFrameLines } from '../capture/frame-state-detect.js';
+import { emitDecision, type DecisionEvent } from '../live/detail-switch.js';
+import { debug } from '../debug/log.js';
+import { streamLLM, type LLMMessage } from '../llm.js';
+
+export interface PluginRequest { agent: 'codex' | 'claude'; plugin: string; marketplace: string }
+export type PluginResult = { outcome: 'installed' } | { outcome: 'escalate'; reason: 'plugins-disabled' | 'unknown-menu' | 'timeout' | 'wrong-target' | 'credentials' };
+export interface PluginDeps {
+  sleep?: (ms: number) => Promise<void>;
+  decide?: (event: DecisionEvent) => unknown;
+  log?: (event: string, data: Record<string, unknown>) => void;
+  /** Returns a single UI action, not arbitrary bytes. An Enter suggestion is still checked against the visible target. */
+  brain?: (screen: string, target: string) => Promise<'up' | 'down' | 'tab' | 'enter' | 'wait' | 'unknown'>;
+  write?: (chars: string) => void;
+  /** The backend's folder-trust answer (driver passes `backend.handleTrust`). A trust menu can appear late on a folder
+   *  opened for the first time — after the driver's own trust pass — so the installer answers it too. */
+  handleTrust?: (screen: string, write: (chars: string) => void) => boolean;
+}
+
+const IDENT = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+export function parsePluginRef(ref: string): { plugin: string; marketplace: string } | null {
+  const parts = ref.split('@');
+  return parts.length === 2 && parts.every(part => IDENT.test(part)) ? { plugin: parts[0]!, marketplace: parts[1]! } : null;
+}
+
+function lines(screen: string): string[] { return classifierFrameLines(screen); }
+function targetLine(line: string, request: PluginRequest, onMarket: boolean): boolean {
+  // A bare plugin name is only unambiguous inside a visibly selected marketplace tab.
+  const name = request.plugin.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const market = request.marketplace.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`(?:^|\\s)${name}(?:@${market})?(?=\\s|$|[✓✔])`, 'i').test(line)
+    && !new RegExp(`(?:^|\\s)${name}@(?!${market}(?=\\s|$|[✓✔]))`, 'i').test(line)
+    && (onMarket || new RegExp(`${name}@${market}(?=\\s|$|[✓✔])`, 'i').test(line));
+}
+function selected(line: string): boolean { return /^\s*(?:>|❯|›|→|●|\*)\s/.test(line); }
+function installButton(line: string): boolean {
+  return selected(line) && /^\s*(?:>|❯|›|→|●|\*)\s+(?:Confirm install|Install|설치)\s*$/i.test(line);
+}
+function selectedPluginRow(line: string): boolean {
+  return selected(line) && /^\s*(?:>|❯|›|→|●|\*)\s+[a-zA-Z0-9][a-zA-Z0-9._-]*@[a-zA-Z0-9][a-zA-Z0-9._-]*(?:\s|$)/.test(line);
+}
+function negativeInstallation(line: string): boolean {
+  return /(?:\b(?:not|never|un|failed|error|disabled)\s*[- ]?installed\b|\bnot\s+enabled\b|\binstall\s+failed\b|설치 안 됨|설치 실패)/i.test(line);
+}
+function installed(screen: string, request: PluginRequest, onMarket: boolean): boolean {
+  let visible = lines(screen);
+  if (request.agent === 'claude') {
+    // Only output below this install command counts — an «Installed» row left from an earlier run must not.
+    const echo = visible.map((line, i) => line.includes(`/plugin install ${request.plugin}@${request.marketplace}`) ? i : -1).filter(i => i >= 0).pop();
+    if (echo === undefined) return false;
+    visible = visible.slice(echo + 1);
+  }
+  return visible.some(line => targetLine(line, request, onMarket)
+    && !negativeInstallation(line)
+    && !/(?:\b(?:installing|loading|downloading|fetching)\b|설치 중)/i.test(line)
+    && /(?:\binstalled\b|\benabled\b|✓|✔|설치됨)/i.test(line));
+}
+
+// Lines an agent draws under its input box: status/path line and the shortcut hint.
+// 🩸 09-29 codex 0.157 home: «› Ask Codex to do anything» then «~/… · branch · Context 100% left ·…» and
+//    «? for shortcuts ⚠ 3 warnings · f2 to view» — the prompt is no longer the last line (T 녹화 2/2 unknown-menu).
+function footerLine(line: string): boolean {
+  return /\?\s*for shortcuts|Context \d+% left|\bf2 to view\b|^\s*~\//i.test(line);
+}
+
+function conversationPrompt(screen: string, agent: PluginRequest['agent']): boolean {
+  const visible = lines(screen);
+  // codex rotates its placeholder («Ask a question», «Ask Codex to do anything», «Explain this codebase», …), so any
+  // «› text» line above the footer counts; the Browse-plugins guard below keeps menu rows out.
+  const prompt = agent === 'codex'
+    ? /^\s*[›❯>]\s+\S/
+    : /^\s*❯\s*(?:$|How can I help|Type a message)/i;
+  // A selected plugin row is not a conversation prompt; neither is a prompt left above an overlay.
+  let end = visible.length;
+  while (end > 0 && footerLine(visible[end - 1]!)) end--;
+  const lastPrompt = visible[end - 1];
+  return lastPrompt !== undefined && prompt.test(lastPrompt)
+    && (agent === 'codex' || (visible.some(line => /Claude Code/i.test(line)) && !visible.some(line => /\bCodex\b/i.test(line))))
+    && !visible.some(line => /^(?:Browse plugins|Plugins)(?:\s|$)/i.test(line));
+}
+
+function menuPluginRows(visible: string[], onMarket: boolean): { line: string; index: number }[] {
+  const menuStart = visible.findIndex(line => /^(?:Browse plugins|Plugins)(?:\s|$)/i.test(line));
+  if (menuStart < 0) return [];
+  return visible.slice(menuStart + 1).flatMap((line, offset) => {
+    if (!/^\s*(?:[>❯›→●*]\s+)?[a-zA-Z0-9][a-zA-Z0-9._-]*(?:@[a-zA-Z0-9][a-zA-Z0-9._-]*)?(?:\s|$)/.test(line)
+      || /^(?:Marketplaces?|Tabs?|Install|Confirm install|Ask a question)\b/i.test(line.replace(/^\s*(?:[>❯›→●*]\s+)?/, ''))
+      || (!onMarket && !/@[a-zA-Z0-9._-]+/.test(line))) return [];
+    return [{ line, index: menuStart + 1 + offset }];
+  });
+}
+
+export async function installPluginInsideAgent(request: PluginRequest, pty: Pick<PtyHandle, 'renderScreen' | 'write' | 'isAlive'>, deps: PluginDeps = {}): Promise<PluginResult> {
+  if (!IDENT.test(request.plugin) || !IDENT.test(request.marketplace)) return { outcome: 'escalate', reason: 'wrong-target' };
+  const sleep = deps.sleep ?? ((ms: number) => Bun.sleep(ms));
+  const log = (event: string, data: Record<string, unknown>) => (deps.log ?? ((e, d) => debug.log('agent-mission.plugin', e, d)))(event, data);
+  const decide = (kind: DecisionEvent['kind'], what: string, reason: string) =>
+    (deps.decide ?? emitDecision)({ kind, what, reason, purpose: '미션에 이 플러그인 스킬이 필요', target: `${request.plugin}@${request.marketplace}`, phase: 'implement' });
+  const write = deps.write ?? ((text: string) => pty.write(text, 'agent'));
+  const safeTail = (screen: string) =>
+    /password|token|api.?key|sign in|log in|login method|Paste code here|https?:\/\//i.test(screen)
+      ? ['[credential screen]']
+      : lines(screen).slice(-10).map(line => line.slice(0, 160));
+  const brain = deps.brain ?? (async (screen: string, target: string) => {
+    const messages: LLMMessage[] = [
+      { role: 'system', content: 'You navigate a plugin menu using only up/down/tab/enter/wait/unknown. Return exactly one of those words. Do not choose enter unless the requested plugin@marketplace is visibly selected. Never enter credentials.' },
+      { role: 'user', content: `Target: ${target}\nScreen:\n${screen.slice(-3500)}` },
+    ];
+    const answer = (await streamLLM(messages, () => {}, { maxTokens: 20 })).trim().toLowerCase();
+    return /^(up|down|tab|enter|wait)$/.test(answer) ? answer as 'up' | 'down' | 'tab' | 'enter' | 'wait' : 'unknown';
+  });
+  const target = `${request.plugin}@${request.marketplace}`;
+  const fail = (reason: Extract<PluginResult, { outcome: 'escalate' }>['reason'], screen: string): PluginResult => {
+    log('escalated', { reason, tail: safeTail(screen) });
+    decide('ESCALATE', `에이전트 안 플러그인 ${target} 설치 중단`, reason === 'plugins-disabled' ? 'plugins 기능 꺼짐 — 사람에게 codex features enable plugins 확인 요청' : reason);
+    return { outcome: 'escalate', reason };
+  };
+  // Installed (now or already): confirm, close the menu with Esc and wait for the conversation prompt.
+  const closeInstalled = async (why: string): Promise<PluginResult> => {
+    decide('VERIFY', `설치됨 ${target}`, why);
+    write('\x1b');
+    for (let i = 0; i < 4; i++) {
+      await sleep(300);
+      const prompt = await pty.renderScreen();
+      if (conversationPrompt(prompt, request.agent)) return { outcome: 'installed' };
+    }
+    return fail('unknown-menu', await pty.renderScreen());
+  };
+  // codex ≥0.157 (실물 09-29): the plugin menu is tabbed by marketplace and has «Type to search plugins». Typing the
+  // name filters to «[-] <name>  Available|Installed»; Enter opens details whose header is «<name> · <status> · <market>»
+  // with «1. Back to plugins / 2. Install plugin|Uninstall plugin»; a finished install prints «• Installed <name> plugin.»
+  // Returns null when the menu has no search box (older codex → the generic loop below).
+  const credentialScreen = (text: string) => /(?:password|passphrase|api.?key|token|sign in|log in|authentication required|two.factor|Paste code here)/i.test(text);
+  const escapeRegExp = (text: string) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const nameRe = escapeRegExp(request.plugin);
+  const rowRe = new RegExp(`^\\s*(›\\s*)?\\[[-* x]\\]\\s+${nameRe}\\s+(Available|Installed)\\b`, 'i');
+  const headerRe = new RegExp(`^\\s*${nameRe}\\s+·\\s+(.+?)\\s+·\\s+([A-Za-z0-9._-]+)\\s*$`, 'i');
+  const frame = async (): Promise<string> => { await sleep(700); const s = await pty.renderScreen(); log('screen', { step: 'search', tail: safeTail(s) }); return s; };
+  const closeToPrompt = async (why: string): Promise<PluginResult> => {
+    decide('VERIFY', `설치됨 ${target}`, why);
+    for (let i = 0; i < 3; i++) {
+      write('\x1b');
+      const s = await frame();
+      if (conversationPrompt(s, 'codex')) return { outcome: 'installed' };
+    }
+    return fail('unknown-menu', await pty.renderScreen());
+  };
+  let handedScreen: string | undefined;
+  const codexSearchInstall = async (): Promise<PluginResult | null> => {
+    let menu = '';
+    let resent = false;
+    for (let i = 0; i < 8; i++) {
+      menu = await frame();
+      if (!pty.isAlive()) return fail('timeout', menu);
+      if (/Plugins are disabled\. Enable the plugins feature/i.test(menu)) return fail('plugins-disabled', menu);
+      if (credentialScreen(menu)) return fail('credentials', menu);
+      if (/Type to search plugins/i.test(menu)) break;
+      if (/Browse plugins/i.test(menu)) { handedScreen = menu; return null; }
+      if (!resent && lines(menu).some(line => /^\s*[›❯>]\s*\/plugins\s*$/.test(line))) { resent = true; write('\r'); }
+    }
+    if (!/Type to search plugins/i.test(menu)) return fail('unknown-menu', menu);
+    write(request.plugin);
+    let rows: string[] = [];
+    for (let i = 0; i < 6 && rows.length === 0; i++) rows = lines(await frame()).filter(line => rowRe.test(line));
+    if (rows.length === 0) return fail('wrong-target', await pty.renderScreen());
+    for (let candidate = 0; candidate < Math.min(rows.length, 5); candidate++) {
+      if (candidate > 0) write('\x1b[B');
+      write('\r');
+      let header: RegExpMatchArray | null = null;
+      let details = '';
+      for (let i = 0; i < 6 && !header; i++) {
+        details = await frame();
+        if (credentialScreen(details)) return fail('credentials', details);
+        header = lines(details).map(line => line.match(headerRe)).find(Boolean) ?? null;
+      }
+      if (!header) return fail('unknown-menu', details);
+      const [, status, market] = header;
+      if (market!.toLowerCase() !== request.marketplace.toLowerCase()) {
+        log('market-mismatch', { target, market });
+        write('\r'); // «1. Back to plugins» is selected when details open
+        await frame();
+        continue;
+      }
+      if (/^Installed$/i.test(status!.trim())) return closeToPrompt('이미 설치돼 있다 — 다시 설치하지 않고 미션으로');
+      decide('ROUTE', `설치 ${target}`, '상세 화면의 마켓이 요청과 같다');
+      write('\x1b[B');
+      const choose = await frame();
+      const chosen = lines(choose).find(line => /^\s*›\s*2\.\s*Install plugin\b/i.test(line));
+      const stillTarget = lines(choose).some(line => { const m = line.match(headerRe); return Boolean(m && m[2]!.toLowerCase() === request.marketplace.toLowerCase()); });
+      if (!chosen || !stillTarget) return fail('wrong-target', choose);
+      write('\r');
+      for (let i = 0; i < 20; i++) {
+        const after = await frame();
+        if (!pty.isAlive()) return fail('timeout', after);
+        if (credentialScreen(after) && !/No additional app authentication is required/i.test(after)) return fail('credentials', after);
+        if (new RegExp(`Installed\\s+${nameRe}\\s+plugin`, 'i').test(after)
+          || lines(after).some(line => { const m = line.match(headerRe); return Boolean(m && /^Installed$/i.test(m[1]!.trim())); })) {
+          return closeToPrompt('설치 완료 줄을 화면에서 확인');
+        }
+      }
+      return fail('timeout', await pty.renderScreen());
+    }
+    return fail('wrong-target', await pty.renderScreen());
+  };
+  let screen = await pty.renderScreen();
+  if (!pty.isAlive()) return fail('timeout', screen);
+  // 🩸 09-29 (🅣 v4 녹화): on a first-opened folder codex showed «Trust this folder? › 1. Trust and continue» after the
+  //    driver's trust pass, and this step escalated unknown-menu. Answer late trust menus here (at most 3).
+  for (let pass = 0; pass < 3 && deps.handleTrust?.(screen, write); pass++) {
+    decide('ROUTE', '폴더 신뢰 메뉴 응답', '처음 여는 워크트리 — 설치 전에 늦게 뜬 신뢰 메뉴');
+    await sleep(1500);
+    screen = await pty.renderScreen();
+  }
+  if (/(?:password|passphrase|api.?key|token|sign in|log in|login method|authentication required|two.factor|Paste code here)/i.test(screen)) return fail('credentials', screen);
+  if (!conversationPrompt(screen, request.agent)) return fail('unknown-menu', screen);
+  decide('ROUTE', '에이전트 안 메뉴 → 설치', '미션에 이 플러그인 스킬이 필요');
+  write(request.agent === 'codex' ? '/plugins\r' : `/plugin install ${target}\r`);
+  if (request.agent === 'codex') {
+    const bySearch = await codexSearchInstall();
+    if (bySearch) return bySearch;
+  }
+  let marketSelected = false;
+  let installStarted = request.agent === 'claude';
+  let observedInstallTransition = false;
+  let lastAction = '';
+  let repeats = 0;
+  let resentSlash = false;
+  for (let step = 0; step < 36; step++) {
+    if (handedScreen !== undefined) { screen = handedScreen; handedScreen = undefined; }
+    else { await sleep(700); screen = await pty.renderScreen(); }
+    log('screen', { step, tail: safeTail(screen) });
+    if (!pty.isAlive()) return fail('timeout', screen);
+    if (/Plugins are disabled\. Enable the plugins feature to use \/plugins\./i.test(screen)) return fail('plugins-disabled', screen);
+    if (/(?:password|passphrase|api.?key|token|sign in|log in|authentication required|two.factor)/i.test(screen)) return fail('credentials', screen);
+    if (installStarted && lines(screen).some(line => targetLine(line, request, marketSelected) && negativeInstallation(line))) return fail('unknown-menu', screen);
+    if (request.agent === 'codex' && !/(?:Browse plugins|marketplace|Install|Installing|Installed|✓|✔)/i.test(screen)) {
+      // 🩸 09-29 (🅣 녹화 3/3): step 0 showed «› /plugins» still in the input box — the menu had not opened yet
+      //    and this line escalated at once. Give the slash command one more Enter and a few frames to open.
+      if (!installStarted && step < 6) {
+        if (!resentSlash && lines(screen).some(line => /^\s*[›❯>]\s*\/plugins\s*$/.test(line))) { resentSlash = true; write('\r'); }
+        continue;
+      }
+      return fail('unknown-menu', screen);
+    }
+    if (installed(screen, request, marketSelected) && (request.agent === 'claude' || observedInstallTransition)) {
+      return closeInstalled('대상 항목 설치됨 표지를 화면에서 확인');
+    }
+    if (/(?:Installing|Downloading|Loading|Fetching|설치 중|⠋|⠙)/i.test(screen) && installStarted) { observedInstallTransition = true; continue; }
+    if (request.agent === 'claude') {
+      if (/(?:error|failed|not found|unknown plugin|not installed)/i.test(screen)) return fail('unknown-menu', screen);
+      continue;
+    }
+    const visible = lines(screen);
+    const tabs = visible.find(line => /marketplaces?|tabs?/i.test(line) && line.toLowerCase().includes(request.marketplace.toLowerCase()));
+    const activeMarket = visible.some(line => selected(line) && line.includes(request.marketplace)) || Boolean(tabs && tabs.includes(`[${request.marketplace}]`));
+    marketSelected = activeMarket;
+    const menuRows = menuPluginRows(visible, marketSelected);
+    const rows = menuRows.filter(({ line }) => targetLine(line, request, marketSelected));
+    const chosen = menuRows.find(({ line }) => selected(line))?.index ?? -1;
+    const row = rows.length === 1 ? rows[0]!.index : -1;
+    const button = visible.find(installButton);
+    const targetButton = Boolean(button && installStarted && menuRows.length === 1 && rows.length === 1
+      && !menuRows.some(({ line }) => selected(line)));
+    let action: 'up' | 'down' | 'tab' | 'enter' | 'wait' | 'unknown' = 'unknown';
+    let safeEnter = false;
+    if (!installStarted && rows.length === 1 && installed(rows[0]!.line, request, marketSelected)) {
+      log('already-installed', { target });
+      return closeInstalled('이미 설치돼 있다 — 다시 설치하지 않고 미션으로');
+    }
+    if (rows.length === 1 && row === chosen) {
+      action = 'enter'; safeEnter = true;
+    } else if (rows.length === 1 && chosen >= 0) action = row > chosen ? 'down' : 'up';
+    else if (targetButton) { action = 'enter'; safeEnter = true; }
+    else if (tabs && !marketSelected) action = 'tab';
+    if (action === 'unknown') {
+      try { action = await brain(screen.slice(-3500), target); }
+      catch { action = 'unknown'; }
+      safeEnter = rows.length === 1 && row === chosen || targetButton;
+    }
+    if (action === 'unknown') return fail('unknown-menu', screen);
+    if (action === 'enter' && !safeEnter) return fail('wrong-target', screen);
+    if (action === 'enter') {
+      const freshScreen = await pty.renderScreen();
+      if (/(?:password|passphrase|api.?key|token|sign in|log in|authentication required|two.factor)/i.test(freshScreen)) return fail('credentials', freshScreen);
+      const fresh = lines(freshScreen);
+      const freshRows = menuPluginRows(fresh, marketSelected);
+      const freshSelected = freshRows.filter(({ line }) => selected(line) && targetLine(line, request, marketSelected));
+      // State can change between the decision and the key: an «Installed» row must not receive Enter.
+      if (freshSelected.length === 1 && installed(freshSelected[0]!.line, request, marketSelected)) {
+        return closeInstalled('Enter 직전 재확인에서 이미 설치됨');
+      }
+      const freshButton = fresh.find(installButton);
+      const freshTargetButton = Boolean(freshButton && installStarted && freshRows.length === 1
+        && targetLine(freshRows[0]!.line, request, marketSelected)
+        && !freshRows.some(({ line }) => selected(line))
+        && !fresh.some(line => selectedPluginRow(line)));
+      if (!(freshSelected.length === 1 && !freshButton
+        && !freshRows.some(({ line }) => selected(line) && !targetLine(line, request, marketSelected)))
+        && !freshTargetButton) return fail('wrong-target', fresh.join('\n'));
+    }
+    if (action === 'enter') { installStarted = true; observedInstallTransition = true; }
+    if (action === lastAction) repeats++; else repeats = 0;
+    if (repeats > 8) return fail('timeout', screen);
+    lastAction = action;
+    if (action === 'wait') continue;
+    decide('ROUTE', `에이전트 안 메뉴 → ${action}`, `화면에서 ${target} 대상 확인`);
+    write(action === 'enter' ? '\r' : action === 'up' ? '\x1b[A' : action === 'down' ? '\x1b[B' : '\t');
+  }
+  return fail('timeout', screen);
+}

package/src/agent-mission/mission-cli.ts

@@ -8,12 +8,17 @@ import { readFileSync } from 'node:fs';
 import type { AgentBackend, AgentMissionResult, EvidenceMode } from './driver.js';
 import { buildAgentMissionDevSpec, executeAgentMissionReroute, type runDevPipeline } from '../self-dev/dev-pipeline.js';
 import { parsePositiveInt } from '../self-dev/dev-cli.js';
+import { parsePluginRef } from './in-agent-plugin.js';
 
 export interface MissionCliOpts {
   missionFile?: string;
   branch: string;
   base?: string;
   backend?: string;
+  chain?: string;
+  headless?: boolean;
+  plugin?: string;
+  resources?: 'on' | 'off';
   evidence?: string; // 'doc' | 'tsc' | 'test'
   docDir?: string;
   docGlob?: string;
@@ -43,9 +48,23 @@ export async function runAgentMissionCliCommand(
   deps: MissionCliDeps,
 ): Promise<MissionCliOutcome> {
   // ── backend 검증(fail-fast·단일 resolve) ──
+  const chain = opts.chain?.split(',').map((item) => item.trim());
+  if (chain && (opts.commit === false || !['codex,claude,elanous', 'codex,claude,codex,elanous'].includes(chain.join(',')) || (opts.backend && opts.backend !== 'codex') || opts.headless)) {
+    return { ok: false, message: '--chain 은 codex,claude[,codex],elanous 형식이며 --backend 는 첫 backend 와 같아야 하고 --headless/--no-commit 은 함께 쓸 수 없습니다', exitCode: 1 };
+  }
   let agentBackend: AgentBackend;
-  try { agentBackend = deps.resolveBackend(opts.backend); }
+  try { agentBackend = deps.resolveBackend(chain?.[0] ?? opts.backend); }
   catch (e) { return { ok: false, message: String((e as { message?: string })?.message ?? e), exitCode: 1 }; }
+  if (opts.headless && agentBackend.name !== 'claude') {
+    return { ok: false, message: '--headless 는 --backend claude 전용입니다', exitCode: 1 };
+  }
+  const plugin = opts.plugin ? parsePluginRef(opts.plugin) : null;
+  if (opts.plugin !== undefined && (!plugin || !['codex', 'claude'].includes(agentBackend.name) || opts.headless)) {
+    return { ok: false, message: '--plugin 은 codex/claude 대화형 backend 에서 <name>@<market> 형식이어야 합니다', exitCode: 1 };
+  }
+  if (opts.resources !== undefined && opts.resources !== 'on' && opts.resources !== 'off') {
+    return { ok: false, message: '--resources 는 on|off 여야 합니다', exitCode: 1 };
+  }
 
   // ── mission 텍스트(verbatim: --mission-file 우선) ──
   const readFile = deps.readFile ?? ((p: string) => readFileSync(p, 'utf8'));
@@ -80,6 +99,11 @@ export async function runAgentMissionCliCommand(
   const spec = buildAgentMissionDevSpec({
     mission,
     backend: agentBackend.name,
+    ...(chain ? { chain: chain as ('codex' | 'claude' | 'elanous')[] } : {}),
+    ...(plugin ? { plugin } : {}),
+    resources: opts.resources ?? 'on',
+    ...(opts.backend ? { backendExplicit: opts.backend } : {}),
+    ...(opts.headless ? { headless: true } : {}),
     branch: opts.branch,
     ...(opts.base ? { base: opts.base } : {}),
     ...(opts.enhance === false ? { enhanceOff: true } : {}),

package/src/agent-mission/parse.ts

@@ -50,8 +50,8 @@ export function parseTscErrors(out: string): string[] {
 // ★ P4 — 'provision' 추가(감독이 자식 역량을 자율 설치·[[provision.ts]]). spec/layer 필드 동반.
 //   layer 는 **raw 문자열 그대로** 보존한다 — 검증/기본화는 provision 정책이 단일점에서(무효/non-pkg 전부 defer).
 //   파서가 무효 layer 를 drop 하면 undefined→pkg 오분류 우회가 생긴다(리뷰 must-fix).
-export type BrainAction = 'wait' | 'send' | 'search' | 'verify' | 'done' | 'provision';
-export interface BrainDecision { action: BrainAction; text?: string; query?: string; spec?: string; layer?: string; reason: string; }
+export type BrainAction = 'wait' | 'send' | 'search' | 'verify' | 'done' | 'provision' | 'handoff' | 'ask-human';
+export interface BrainDecision { action: BrainAction; text?: string; query?: string; spec?: string; layer?: string; reason: string; to?: 'codex' | 'claude' | 'elanous'; mission?: string; carry?: 'diff' | 'summary'; url?: string; code?: string; }
 
 /** 브레인 LLM 의 원문에서 JSON 결정을 관대하게 파싱. 실패 시 wait 폴백. */
 export function parseBrainDecision(raw: string): BrainDecision {
@@ -59,8 +59,10 @@ export function parseBrainDecision(raw: string): BrainDecision {
   if (!jm) return { action: 'wait', reason: `no-json: ${raw.slice(0, 80)}` };
   try {
     const d = JSON.parse(jm[0]) as Record<string, unknown>;
-    const action = (['wait', 'send', 'search', 'verify', 'done', 'provision'] as const).includes(d.action as BrainAction)
+    const action = (['wait', 'send', 'search', 'verify', 'done', 'provision', 'handoff', 'ask-human'] as const).includes(d.action as BrainAction)
       ? (d.action as BrainAction) : 'wait';
+    if (action === 'handoff' && (!['codex', 'claude', 'elanous'].includes(d.to as string) || typeof d.mission !== 'string' || !d.mission.trim() || (d.carry !== undefined && d.carry !== 'diff' && d.carry !== 'summary'))) return { action: 'wait', reason: 'invalid handoff' };
+    if (action === 'ask-human' && (typeof d.reason !== 'string' || !d.reason.trim())) return { action: 'wait', reason: 'invalid ask-human' };
     return {
       action,
       text: typeof d.text === 'string' ? d.text : undefined,
@@ -68,6 +70,8 @@ export function parseBrainDecision(raw: string): BrainDecision {
       spec: typeof d.spec === 'string' ? d.spec : undefined,
       layer: typeof d.layer === 'string' ? d.layer : undefined,
       reason: typeof d.reason === 'string' ? d.reason : '',
+      ...(action === 'handoff' ? { to: d.to as 'codex' | 'claude' | 'elanous', mission: d.mission as string, ...(d.carry ? { carry: d.carry as 'diff' | 'summary' } : {}) } : {}),
+      ...(action === 'ask-human' ? { ...(typeof d.url === 'string' ? { url: d.url } : {}), ...(typeof d.code === 'string' ? { code: d.code } : {}) } : {}),
     };
   } catch { return { action: 'wait', reason: 'json-parse-fail' }; }
 }
@@ -79,5 +83,6 @@ export function screenSignalsComplete(screen: string): boolean {
 
 /** codex TUI 화면에서 trust 프롬프트를 감지. */
 export function screenNeedsTrust(screen: string): boolean {
-  return /trust the contents|Do you trust/i.test(screen);
+  // codex ≥0.157: «Trust this folder? … 1. Trust and continue» (older: «Do you trust the contents …»).
+  return /trust the contents|Do you trust|Trust this folder\?/i.test(screen);
 }