elanous 0.2.0 → 0.2.4

package/src/agent-substrate/review-intent.ts

@@ -14,12 +14,16 @@ import { unified } from 'unified';
 
 import { parseGoalType, type GoalType } from '../self-implement/goal-author.js';
 import type { DesignCheckOutcome } from '../design/design-check.js';
+import type { DesignGateResult } from '../design/design-gate.js';
+import type { PriorDraftFinding } from '../self-implement/prior-draft-findings.js';
 
 export interface ReviewIntentInput {
   /** 무엇을 왜 — 골 원문. */
   readonly goal: string;
   /** 직전 라운드에서 이미 재주입된 must-fix(스테일 재지적 차단). */
   readonly appliedLastRound?: readonly string[];
+  /** Same-goal, other-run draft reviewer must-fix findings to re-evaluate against this diff. */
+  readonly priorRunFindings?: readonly PriorDraftFinding[];
   /** 현재 rework 라운드(0-base). */
   readonly round?: number;
   /** 리뷰 artifact·관측 로그를 잇는 실행 식별자. */
@@ -70,6 +74,7 @@ export interface ReviewIntentInput {
   } | null;
   /** Read-only comparison of the worktree DESIGN.md declaration and installed craft rulebooks. */
   readonly designCheck?: DesignCheckOutcome;
+  readonly designGate?: DesignGateResult | { readonly unmeasured: string };
 }
 
 export const MAX_REVIEW_INTENT_CHARS = 4000;
@@ -150,6 +155,16 @@ function runFactsBlock(i: Readonly<ReviewIntentInput>): Block | undefined {
   return { ...block, minimumText: `${RUN_FACTS_TITLE}\n${minimumItems.map((item) => `- ${item}`).join('\n')}` };
 }
 
+function priorRunFindingsBlock(findings: ReviewIntentInput['priorRunFindings']): Block | undefined {
+  if (!findings?.some((finding) => finding.items.length)) return undefined;
+  const title = '앞 런이 남긴 지적(같은 골 · 다른 런)';
+  const items = findings.flatMap((finding) => finding.items.map((item) => `- #${finding.pr} · 라운드 ${finding.round} · ${item}`));
+  return {
+    title,
+    text: `${title}\n${items.join('\n')}\n각 항목이 이 diff 에서 닫혔는지 판정하라 — 닫히지 않았고 이 PR 범위에 해당하면 must-fix 로 올린다 · 해당 없으면 이유 한 줄`,
+  };
+}
+
 function preexistingFailuresBlock(items: ReviewIntentInput['preexistingTestFailures']): Block | undefined {
   const failures = items?.map((item) => item.trim()).filter(Boolean) ?? [];
   return failures.length
@@ -195,6 +210,29 @@ function designCheckBlock(outcome: ReviewIntentInput['designCheck']): Block | un
     };
 }
 
+function designGateBlock(outcome: ReviewIntentInput['designGate']): Block | undefined {
+  if (!outcome) return undefined;
+  if ('unmeasured' in outcome) {
+    const title = '디자인 게이트 — 측정 불가';
+    return { title, text: `${title}\n측정 불가: ${outcome.unmeasured}` };
+  }
+  if (outcome.verdict === 'not-applicable') return undefined;
+  if (outcome.verdict === 'pass') {
+    const title = `디자인 게이트 통과(방향 ${outcome.direction})`;
+    return { title, text: title };
+  }
+  const title = `디자인 게이트 — must-fix 후보(P0 ${outcome.p0Total})`;
+  const findings = outcome.files.flatMap((file) => file.findings
+    .filter((finding) => finding.severity === 'p0')
+    .map((finding) => `${file.path}:${finding.line ?? '?'} ${finding.rule}`));
+  const shown = findings.slice(0, 20);
+  const omitted = findings.length - shown.length;
+  return {
+    title,
+    text: [title, ...shown.map((finding) => `- ${finding}`), ...(omitted ? [`- …${omitted}개 생략`] : [])].join('\n'),
+  };
+}
+
 function shardSiblingsBlock(siblings: ReviewIntentInput['shardSiblings']): Block | undefined {
   if (!siblings?.items.length) return undefined;
   const items = siblings.items.map((sibling) => `${sibling.runId}${sibling.shardId ? ` (${sibling.shardId}${sibling.pieceIndex !== undefined ? ` #${sibling.pieceIndex}` : ''})` : ''}`);
@@ -501,11 +539,13 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
   // ⭐ **자식이 낸 증거**(diff 밖 이행 · base 적색 · 직전 반영분)를 한 묶음으로 잡아 둔다 — 아래 예산
   //   배분에서 **목표 본문보다 먼저** 채우기 위해서다. 제목 문자열이 아니라 **동일성**으로 가른다.
   const applied = listBlock('직전 라운드 반영분', i.appliedLastRound);
+  const priorFindings = priorRunFindingsBlock(i.priorRunFindings);
   const preexisting = preexistingFailuresBlock(i.preexistingTestFailures);
   const importerTestsNotRun = importerTestsNotRunBlock(i.importerTestsNotRun);
   const claims = diffOutsideClaimsBlock(i.diffOutsideClaims);
   const gateEvidence = gateEvidenceBlock(i.gateEvidenceNote);
   const designCheck = designCheckBlock(i.designCheck);
+  const designGate = designGateBlock(i.designGate);
   const shardSiblings = shardSiblingsBlock(i.shardSiblings);
   const coverage = evidenceCoverageBlock(i.evidenceCoverage);
   const goalFile = goalFileBlock(i.goalFile);
@@ -520,6 +560,7 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
   //   ⚠️ 이것은 «렌더 순서»만 바꾼다 — 예산 배분 순서(`order`)와 보호 블록은 아래에서 따로 정한다.
   const blocks: Block[] = [
     runFacts,
+    priorFindings,
     goalFile,
     goalType,
     goal,
@@ -529,6 +570,7 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
     importerTestsNotRun,
     gateEvidence,
     designCheck,
+    designGate,
     shardSiblings,
     coverage,
     claims,
@@ -542,7 +584,7 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
   //   `…[N개 생략됨]`** 이 됐다. 그러면 리뷰는 *"실행하지 않았다 · 증거가 없다"* 를 적고 — 그것이
   //   **리뷰 입장에서 사실**이라 반박도 안 된다. 두 트랙 합쳐 **여섯 런**이 이 사인으로 죽었다.
   //   ⭐ 목표 본문을 뒤로 미뤄도 잃는 것이 적다 — **수용기준·경계는 이미 추출돼 보호 블록**에 있다.
-  const evidenceBlocks = [applied, preexisting, importerTestsNotRun, gateEvidence, designCheck, shardSiblings, coverage, claims, runFacts, goalFile].filter((b): b is Block => Boolean(b));
+  const evidenceBlocks = [priorFindings, designGate, applied, preexisting, importerTestsNotRun, gateEvidence, designCheck, shardSiblings, coverage, claims, runFacts, goalFile].filter((b): b is Block => Boolean(b));
   const otherBlocks = blocks.filter((block) => !protectedBlocks.includes(block) && !evidenceBlocks.includes(block) && block !== goal);
   const order = [...protectedBlocks, ...evidenceBlocks, ...otherBlocks, ...(goal ? [goal] : [])];
   // ⛔⭐⭐⭐ 1차는 우선순위와 무관하게 공정 몫까지만 준다. 목표 본문은 이미 추출된

package/src/auth/scope.ts

@@ -16,7 +16,7 @@
 // makes "leak in shell history" recovery a one-line revoke instead
 // of a key-rotation flow.
 
-export type TokenScope = 'admin' | 'session' | 'read-only';
+export type TokenScope = 'admin' | 'session' | 'read-only' | 'mcp-public';
 
 const READONLY_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
 
@@ -36,9 +36,8 @@ export interface ScopedToken {
 
 export interface ScopeCheckRequest {
   method: string;
-  /** Path AFTER the `/v1/` prefix — e.g. `registry/daemons/x` or
-   *  `bindings/telegram/123`. The server.ts dispatcher passes the
-   *  url.pathname; we strip `/v1/` here for clarity. */
+  /** Request path (e.g. `/v1/mcp`). Callers must provide the full
+   *  pathname when checking the `mcp-public` scope. */
   pathname: string;
   /** Optional — the session id this request is targeting. Routes
    *  that touch a single session (e.g. `active-session` or future
@@ -73,6 +72,11 @@ export function tokenScopeAllows(
     case 'admin':
       return { ok: true };
 
+    case 'mcp-public':
+      return req.method.toUpperCase() === 'POST' && req.pathname === '/v1/mcp'
+        ? { ok: true }
+        : { ok: false, reason: 'mcp_public_scope' };
+
     case 'read-only': {
       const m = req.method.toUpperCase();
       if (READONLY_METHODS.has(m)) return { ok: true };

package/src/auth/temp-tokens.ts

@@ -0,0 +1,131 @@
+// 단기 소유자 토큰 — `elanous token issue --ttl 15m`.
+//
+// 왜: 검증·시연·다른 기기 한 번 붙이기에 «영구 소유자 토큰»(~/.elanous/acp-token)을 꺼내 건네면 그 값이
+// 명령줄·세션 기록·브라우저에 영구로 남는다(2026-09-28 · 운영 웹 터미널 검증을 Aside 로 하려다 막혔다 · 대표 «직접 만들라»).
+// ⇒ 수명이 짧고(기본 15분 · 최대 24시간), 저장소엔 «해시만» 있고, 언제든 걷을 수 있는 토큰.
+//
+// 권한 = 소유자 토큰과 같다(HTTP bearer ⊕ ACP 웹소켓). 범위를 좁히지 않는 대신 «수명»으로 위험을 줄인다.
+// 저장 = `<config dir>/temp-tokens.json`(0600 · 원문 없음 · sha256 만) — 관리 토큰과 같은 디렉터리라 운영 데몬과 CLI 가 같은 곳을 본다.
+
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { closeSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { debug } from '../debug/log.js';
+
+export const TEMP_TOKEN_DEFAULT_TTL_MS = 15 * 60_000;
+export const TEMP_TOKEN_MAX_TTL_MS = 24 * 60 * 60_000;
+const PREFIX = 'elt_';
+
+interface StoredTempToken {
+  id: string;
+  hash: string;
+  label: string;
+  createdAt: string;
+  expiresAt: string;
+}
+
+export interface TempTokenInfo { id: string; label: string; createdAt: string; expiresAt: string; expired: boolean }
+export interface IssuedTempToken { id: string; token: string; label: string; expiresAt: string }
+
+function storePath(dir: string): string { return join(dir, 'temp-tokens.json'); }
+
+function readStore(dir: string): StoredTempToken[] {
+  const path = storePath(dir);
+  let text: string;
+  try {
+    const st = lstatSync(path);
+    if (!st.isFile() || (st.mode & 0o077) !== 0) throw new Error('temp token store must be a private regular file (0600)');
+    text = readFileSync(path, 'utf8');
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw e;
+  }
+  const parsed = JSON.parse(text) as { tokens?: unknown };
+  if (!parsed || !Array.isArray(parsed.tokens)) throw new Error('temp token store is malformed');
+  return parsed.tokens.filter((t): t is StoredTempToken => !!t && typeof t === 'object'
+    && typeof (t as StoredTempToken).id === 'string' && /^[a-f0-9]{64}$/.test(String((t as StoredTempToken).hash))
+    && typeof (t as StoredTempToken).expiresAt === 'string');
+}
+
+function writeStore(dir: string, tokens: StoredTempToken[]): void {
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const tmp = `${storePath(dir)}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify({ tokens }, null, 2), { mode: 0o600 });
+  renameSync(tmp, storePath(dir));
+}
+
+/** 쓰기 잠금 — O_EXCL 잠금 파일(짧게 기다렸다 포기). 발급·회수는 드물어 이것으로 충분하다. */
+function withLock<T>(dir: string, fn: () => T): T {
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const lock = `${storePath(dir)}.lock`;
+  const until = Date.now() + 3000;
+  let fd = -1;
+  while (fd < 0) {
+    try { fd = openSync(lock, 'wx', 0o600); }
+    catch (e) {
+      if ((e as NodeJS.ErrnoException).code !== 'EEXIST' || Date.now() > until) throw new Error('temp token store is locked — try again');
+      Bun.sleepSync(20);
+    }
+  }
+  try { return fn(); } finally { closeSync(fd); try { unlinkSync(lock); } catch { /* already gone */ } }
+}
+
+const hashOf = (token: string) => createHash('sha256').update(token).digest('hex');
+
+/** 발급 — 원문은 이 반환값에만 있다(저장소엔 해시). 만료된 것은 이때 걷는다. */
+export function issueTempToken(opts: { ttlMs?: number; label?: string; dir?: string; now?: number } = {}): IssuedTempToken {
+  const ttl = opts.ttlMs ?? TEMP_TOKEN_DEFAULT_TTL_MS;
+  if (!Number.isFinite(ttl) || ttl <= 0 || ttl > TEMP_TOKEN_MAX_TTL_MS) throw new Error('ttl must be > 0 and at most 24h');
+  const label = (opts.label ?? 'temp').trim();
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(label)) throw new Error('label must be 1–64 of [A-Za-z0-9._-]');
+  const dir = opts.dir ?? getElanousConfigDir();
+  const now = opts.now ?? Date.now();
+  return withLock(dir, () => {
+    const live = readStore(dir).filter((t) => Date.parse(t.expiresAt) > now);
+    const token = `${PREFIX}${randomBytes(32).toString('base64url')}`;
+    const id = randomBytes(4).toString('hex');
+    const entry: StoredTempToken = { id, hash: hashOf(token), label, createdAt: new Date(now).toISOString(), expiresAt: new Date(now + ttl).toISOString() };
+    writeStore(dir, [...live, entry]);
+    try { debug.log('auth.temp-token', 'issued', { id, label, expiresAt: entry.expiresAt }); } catch { /* 관측 실패가 발급을 막지 않는다 */ }
+    return { id, token, label, expiresAt: entry.expiresAt };
+  });
+}
+
+/** 지금 유효한가(해시 상수시간 대조 · 만료 제외). 저장소가 손상되면 «거부»(fail-closed). */
+export function matchTempToken(token: string, opts: { dir?: string; now?: number } = {}): TempTokenInfo | null {
+  if (typeof token !== 'string' || !token.startsWith(PREFIX)) return null;
+  let entries: StoredTempToken[];
+  try { entries = readStore(opts.dir ?? getElanousConfigDir()); } catch { return null; }
+  const now = opts.now ?? Date.now();
+  const digest = Buffer.from(hashOf(token), 'hex');
+  let hit: StoredTempToken | null = null;
+  for (const e of entries) if (timingSafeEqual(digest, Buffer.from(e.hash, 'hex')) && Date.parse(e.expiresAt) > now) hit = e;
+  return hit ? { id: hit.id, label: hit.label, createdAt: hit.createdAt, expiresAt: hit.expiresAt, expired: false } : null;
+}
+
+export function listTempTokens(opts: { dir?: string; now?: number } = {}): TempTokenInfo[] {
+  const now = opts.now ?? Date.now();
+  return readStore(opts.dir ?? getElanousConfigDir()).map((t) => ({ id: t.id, label: t.label, createdAt: t.createdAt, expiresAt: t.expiresAt, expired: Date.parse(t.expiresAt) <= now }));
+}
+
+/** 회수 — id 하나 또는 전부. 다음 요청부터 거부된다. 걷은 수를 돌려준다. */
+export function revokeTempTokens(which: { id?: string; all?: boolean }, opts: { dir?: string } = {}): number {
+  const dir = opts.dir ?? getElanousConfigDir();
+  return withLock(dir, () => {
+    const tokens = readStore(dir);
+    const remaining = which.all ? [] : tokens.filter((t) => t.id !== which.id);
+    const removed = tokens.length - remaining.length;
+    if (removed > 0) writeStore(dir, remaining);
+    try { debug.log('auth.temp-token', 'revoked', { id: which.id ?? null, all: !!which.all, removed }); } catch { /* */ }
+    return removed;
+  });
+}
+
+/** `15m` · `2h` · `90s` · `1d`(=24h) → ms. */
+export function parseTtl(text: string): number {
+  const m = /^([1-9]\d*)(s|m|h|d)$/.exec(text.trim());
+  if (!m) throw new Error('ttl must look like 90s, 15m, 2h or 1d');
+  const n = Number(m[1]);
+  return n * ({ s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000 } as const)[m[2] as 's' | 'm' | 'h' | 'd'];
+}

package/src/auto-research/obsidian-bridge.ts

@@ -14,6 +14,7 @@
 // src/agent/loader.ts uses; we duplicate the logic here so the
 // auto-research module stays free of agent-subsystem coupling.
 
+import { assertVaultWriteAllowed } from '../obsidian/vault-write-guard.js';
 import {
   existsSync,
   mkdirSync,
@@ -98,6 +99,7 @@ export function writeNote(
   frontmatter?: Record<string, unknown>,
 ): void {
   const path = join(vault.root, relPath);
+  assertVaultWriteAllowed(path);   // ⛔ 격리 우주는 운영 볼트에 쓰지 않는다
   ensureDir(dirname(path));
   const fmText = frontmatter ? renderFrontmatter(frontmatter) : '';
   const full = fmText + body;

package/src/autopilot/build/integrity-gate.ts

@@ -13,6 +13,7 @@ import { parseTestOutput } from '../../agent-mission/parse.js';
 import { androidFilesIn } from '../../../scripts/ci-android-unit-tests.js';
 import { iosFilesIn } from '../../../scripts/ci-ios-unit-tests.js';
 import { tscEnv } from '../../typecheck-ratchet.js';
+import { debug } from '../../debug/log.js';
 
 export interface CmdResult {
   code: number;
@@ -46,7 +47,11 @@ function signalProcessGroup(pid: number, signal: NodeJS.Signals): void {
     if (process.platform === 'win32') process.kill(pid, signal);
     else process.kill(-pid, signal);
   } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error;
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === 'ESRCH') return;
+    if (code !== 'EPERM') throw error;
+    debug.log('integrity-gate', 'signal-eperm', { pid, signal }, { level: 'warn' });
+    try { process.kill(pid, signal); } catch { /* best-effort leader fallback */ }
   }
 }
 
@@ -57,6 +62,7 @@ function processGroupExists(pid: number): boolean {
     return true;
   } catch (error: unknown) {
     if ((error as NodeJS.ErrnoException).code === 'ESRCH') return false;
+    if ((error as NodeJS.ErrnoException).code === 'EPERM') return true;
     throw error;
   }
 }
@@ -130,10 +136,18 @@ const runCmdImpl = (
     cleanup();
     reject(error);
   };
+  const groupStillExists = (pid: number): boolean => {
+    try {
+      return groupExists(pid);
+    } catch (error: unknown) {
+      if ((error as NodeJS.ErrnoException).code === 'EPERM') return true;
+      throw error;
+    }
+  };
   const settleAfterReap = () => {
     if (!closed || terminationReason === undefined) return;
     try {
-      if (processGroupId !== undefined && groupExists(processGroupId)) return;
+      if (processGroupId !== undefined && groupStillExists(processGroupId)) return;
       settle();
     } catch (error: unknown) {
       fail(error);
@@ -153,7 +167,16 @@ const runCmdImpl = (
     // ⭐ 종료 경로 전체의 상한(리뷰 must-fix) — TERM 유예 + KILL 후 reap 대기까지 다 지나면
     //   그룹이 남아 있어도 **무조건 결과를 낸다**. 데드라인이 없으면 좀비 하나가 게이트를
     //   영구히 멈춘다(이 파일이 고치려는 바로 그 실패 형태).
-    reapDeadlineTimer = setTimeout(settle, TERMINATION_GRACE_MS + REAP_DEADLINE_MS);
+    reapDeadlineTimer = setTimeout(() => {
+      try {
+        if (processGroupId !== undefined && groupStillExists(processGroupId)) {
+          debug.log('integrity-gate', 'group-unkillable', { pid: processGroupId }, { level: 'warn' });
+        }
+        settle();
+      } catch (error: unknown) {
+        fail(error);
+      }
+    }, TERMINATION_GRACE_MS + REAP_DEADLINE_MS);
     killTimer = setTimeout(() => {
       try {
         if (processGroupId !== undefined) signalProcessGroup(processGroupId, 'SIGKILL');
@@ -263,7 +286,7 @@ export async function runIntegrityGate(
   opts: { steps?: GateStepName[]; runCmd?: RunCmd; failFast?: boolean; testArgs?: string[]; previousPassCount?: number } = {},
 ): Promise<GateResult> {
   const steps = opts.steps ?? DEFAULT_GATE_STEPS;
-  const runCmd = opts.runCmd ?? defaultRunCmd;
+  const runCmd = opts.runCmd ?? createRunCmd();
   const results: GateStep[] = [];
   const logs: string[] = [];
   let passed = true;

package/src/autopilot/build/isolated-instance.ts

@@ -15,9 +15,10 @@ import { createWorktree, linkWorktreeDependencies, removeWorktree, worktreeParen
 import { configuredWorktreeRoot, getUserConfig } from '../../user-config.js';
 import { debug } from '../../debug/log.js';
 import { runGitCommand } from '../../git-fs/runner.js';
+import { DEFAULT_NEXUS_HTTP_PORT } from '../../nexus/default-port.js';
 
 /** 정식 데몬 포트 — 격리는 이 포트를 절대 쓰지 않는다. */
-export const PRODUCTION_PORT = 31415;
+export const PRODUCTION_PORT = DEFAULT_NEXUS_HTTP_PORT;
 /** 격리 포트 범위(정식 회피). */
 export const ISOLATED_PORT_BASE = 31416;
 export const ISOLATED_PORT_SPAN = 84; // 31416~31499

package/src/autopilot/build/llm-conflict-merge.ts

@@ -51,12 +51,21 @@ export interface LlmMergeOutcome {
   sizeChange?: LlmMergeSizeChange;
   testDeclarationLoss?: Array<{ file: string; ours: number; theirs: number; merged: number }>;
   testDeclarationUnmeasured?: string[];
+  /** 해결기 응답이 LLM 공급자 오류 문구였다 — 파일 내용이 아니다(🅢 2026-09-27 #21086: 세 파일이 통째로 그 문구가 됐다). */
+  providerFailure?: string[];
+  /** 병합 결과가 양쪽 판 중 작은 쪽의 절반 아래로 줄었다 — 통째로 날린 것으로 보고 해결 실패로 친다. */
+  sizeCollapse?: Array<{ file: string; ours: number; theirs: number; merged: number }>;
   /** `status: 'error'` 일 때 어느 단계인지. 선택 — 옛 호출자는 이 칸 없이 돌아도 된다. */
   errorStep?: LlmMergeErrorStep;
   /** 그 단계의 git stderr 첫 줄. seam 이 안 주면 칸 자체를 만들지 않는다. */
   errorDetail?: string;
 }
 
+/** `src/session-runtime/retry-policy.ts` `formatProviderFallbackOutput` 의 머리 — 라우터는 공급자가 전부 막히면 이 문구를 «응답 텍스트»로 돌려준다. */
+export const PROVIDER_FAILURE_TEXT = /^\s*\[LLM PROVIDER (?:BLOCKED|STOPPED)\]/;
+/** 이 줄 수 미만 파일은 크기 붕괴 판정에서 뺀다(작은 파일은 정당하게 크게 줄 수 있다). */
+export const SIZE_COLLAPSE_MIN_LINES = 50;
+
 function lineCount(s: string): number {
   if (s.length === 0) return 0;
   return s.endsWith('\n') ? s.slice(0, -1).split('\n').length : s.split('\n').length;
@@ -189,6 +198,10 @@ export async function mergeMainWithLlmResolve(
       git.abort(worktreePath); // LLM 예외 → base 유지
       return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles });
     }
+    if (PROVIDER_FAILURE_TEXT.test(merged)) {
+      git.abort(worktreePath); // 해결기가 공급자 오류 문구를 «내용»으로 돌려줬다 → base 유지
+      return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles, providerFailure: [f] });
+    }
     if (hasConflictMarkers(merged)) {
       git.abort(worktreePath); // LLM 이 종합 못 함(마커 잔존) → base 유지
       return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles });
@@ -205,6 +218,18 @@ export async function mergeMainWithLlmResolve(
     } catch {
       testDeclarationUnmeasured.push(f);
     }
+    try {
+      const ours = lineCount(git.readIndexStage(worktreePath, 2, f));
+      const theirs = lineCount(git.readIndexStage(worktreePath, 3, f));
+      const mergedLines = lineCount(merged);
+      const smaller = Math.min(ours, theirs);
+      if (smaller >= SIZE_COLLAPSE_MIN_LINES && mergedLines * 2 < smaller) {
+        git.abort(worktreePath); // 양쪽 판 모두보다 절반 넘게 작다 → 통째로 날렸다 → base 유지
+        return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles, sizeCollapse: [{ file: f, ours, theirs, merged: mergedLines }] });
+      }
+    } catch {
+      /* 한쪽 판이 없는 충돌(삭제·추가) — 크기 비교 대상이 아니다 */
+    }
     addSizeChange(sizeChange, f, conflicted, merged);
     git.writeFile(abs, merged);
     git.add(worktreePath, f);
@@ -293,6 +318,8 @@ export function defaultGitMergeSeam(): MergeGitSeam {
 export async function defaultLlmResolve(filePath: string, conflicted: string, mergeTarget: string): Promise<string> {
   const { streamLLM } = await import('../../llm.js');
   const out = await streamLLM([{ role: 'user', content: conflictResolvePrompt(filePath, conflicted, mergeTarget) }], () => {}, { model: process.env.ELANOUS_CONFLICT_MODEL || tierModel('better'), reasoningEffort: 'medium' });
+  // ⛔ 라우터는 공급자가 전부 막히면 던지지 않고 오류 문구를 돌려준다 — 그것은 파일 내용이 아니다. 던져서 «LLM 예외 → base 유지» 로 보낸다.
+  if (PROVIDER_FAILURE_TEXT.test(out)) throw new Error(`conflict resolve: LLM provider failure for ${filePath}`);
   return `${out.replace(/^```[\w.-]*\n?/, '').replace(/\n?```\s*$/, '').trimEnd()}\n`;
 }
 

package/src/autopilot/llm-control-brain.ts

@@ -1,10 +1,10 @@
 // ── LLM 제어 brain (PLAN §7 P3b · 제어 루프를 자율화) ──
 //
 // runPtyControlLoop(§P3a)의 "판단"을 실제 LLM 으로 채운다: 화면(#1 분류 상태 포함)을 보고 다음 행동
-// (input/wait/done)을 결정. 이게 substrate(관측·판단·대기·안전한 행동)를 **실제 자율 에이전트**로 만든다.
+// (input/key/mouse/resize/wait/done)을 결정. 이게 substrate(관측·판단·대기·안전한 행동)를 **실제 자율 에이전트**로 만든다.
 //   runPtyControlLoop(createLlmControlBrain({goal}), controlDepsForHandle(h), opts)
 //
-// 범용 3-액션(input/wait/done) — agent-mission 의 codex-특정 5-액션(send/verify/search…)의 일반형.
+// 범용 제어 액션(input/key/mouse/resize/wait/done) — agent-mission 의 codex-특정 액션과 별개.
 // streamLLM 은 lazy-inject(테스트=스텁·프로덕션=실제 · 테스트가 llm.js 무겁게 로드 안 함).
 //
 // ⭐제1원칙: 판단은 관측 관문(debug.log('autopilot.control','brain'))에 남긴다. LLM 오류/무JSON 은
@@ -14,6 +14,8 @@ import type { RunSupervisor, ControlDecision, ControlObservation } from './pty-c
 import { formatStallContext } from './stall-context.js';
 import type { LLMMessage } from '../llm.js';
 import { debug } from '../debug/log.js';
+import { emitDecision } from '../live/detail-switch.js';
+import { MAX_PTY_KEY_REPEAT } from '../pty-shell/pty-mouse.js';
 
 /** 주입 가능한 LLM 스트림 함수(streamLLM 시그니처 부분집합). */
 export type StreamLLMFn = (
@@ -41,7 +43,7 @@ export interface LlmControlBrainOpts {
   readonly historyLimit?: number;
   /** 결정 관측 훅(전사·디버그). */
   readonly onDecision?: (decision: ControlDecision, raw: string) => void;
-  /** 도메인별 프롬프트가 기본 3-action 프롬프트를 대체할 때 사용한다. */
+  /** 도메인별 프롬프트가 기본 제어 프롬프트를 대체할 때 사용한다. */
   readonly messageBuilder?: (obs: ControlObservation, history: readonly string[]) => LLMMessage[];
   /** 도메인별 원문→결정 어댑터. 비동기 부작용(search context 기록 등)도 허용한다. */
   readonly decisionFromRaw?: (raw: string, obs: ControlObservation) => ControlDecision | Promise<ControlDecision>;
@@ -66,17 +68,25 @@ export function extractFirstJsonObject(raw: string): string | null {
   return null;
 }
 
-/** ⭐LLM 원문 → ControlDecision. JSON {action,text,reason} 관대 파싱. 무JSON/실패 → wait(fail-soft). */
+/** ⭐LLM 원문 → ControlDecision. 무JSON/잘못된 JSON 은 wait; 알 수 없는 행동은 오류. */
 export function parseControlDecision(raw: string): ControlDecision {
   const json = extractFirstJsonObject(raw);
   if (!json) return { action: 'wait' };
   try {
     const d = JSON.parse(json) as Record<string, unknown>;
     if (d.action === 'input' && typeof d.text === 'string' && d.text.length > 0) return { action: 'input', text: d.text };
+    if (d.action === 'key' && typeof d.name === 'string' && d.name.trim() && (d.repeat === undefined || (Number.isSafeInteger(d.repeat) && (d.repeat as number) > 0 && (d.repeat as number) <= MAX_PTY_KEY_REPEAT))) return { action: 'key', name: d.name, ...(d.repeat === undefined ? {} : { repeat: d.repeat as number }) };
+    if (d.action === 'mouse' && Number.isSafeInteger(d.x) && (d.x as number) > 0 && Number.isSafeInteger(d.y) && (d.y as number) > 0 && ['click', 'scroll-up', 'scroll-down'].includes(d.kind as string) && (d.button === undefined || ['left', 'middle', 'right'].includes(d.button as string))) return { action: 'mouse', x: d.x as number, y: d.y as number, kind: d.kind as 'click' | 'scroll-up' | 'scroll-down', ...(d.button === undefined ? {} : { button: d.button as 'left' | 'middle' | 'right' }) };
+    if (d.action === 'resize' && Number.isSafeInteger(d.cols) && (d.cols as number) > 0 && Number.isSafeInteger(d.rows) && (d.rows as number) > 0) return { action: 'resize', cols: d.cols as number, rows: d.rows as number };
+    if (d.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: 'handoff', to: d.to as 'codex' | 'claude' | 'elanous', mission: d.mission, ...(d.carry ? { carry: d.carry as 'diff' | 'summary' } : {}) };
+    if (d.action === 'ask-human' && typeof d.reason === 'string' && d.reason.trim() && (d.url === undefined || typeof d.url === 'string') && (d.code === undefined || typeof d.code === 'string')) return { action: 'ask-human', reason: d.reason, ...(typeof d.url === 'string' ? { url: d.url } : {}), ...(typeof d.code === 'string' ? { code: d.code } : {}) };
+    if (d.action === 'wait') return { action: 'wait' };
     if (d.action === 'done') return { action: 'done', reason: typeof d.reason === 'string' ? d.reason : 'done' };
     if (d.action === 'no-progress' && typeof d.reason === 'string' && d.reason.length > 0) return { action: 'no-progress', reason: d.reason };
-    return { action: 'wait' };
-  } catch {
+    if (d.action === 'input' || d.action === 'no-progress') return { action: 'wait' };
+    throw new Error(`unknown or invalid PTY control action: ${String(d.action)}`);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith('unknown or invalid PTY')) throw error;
     return { action: 'wait' };
   }
 }
@@ -89,10 +99,15 @@ function buildSystem(opts: LlmControlBrainOpts, state: string, stallKnown: boole
 목표: ${opts.goal.slice(0, 600)}
 ${opts.systemHint ? opts.systemHint.slice(0, 400) + '\n' : ''}${hasRoundContext ? '화면은 현재 신호 하나다. 제공된 라운드 맥락과 직전 실패를 함께 고려하되, 화면만으로 이전 라운드의 진행을 추정하지 마라.\n' : ''}화면을 보고 **다음 행동 하나**를 JSON 으로 결정하라:
 - "input": 자식이 입력을 기다리면(프롬프트/선택/blocked) 다음 입력 text(개행 필요 시 \\r 포함).
+- "key": 특수키 name(enter/esc/tab/up/down/left/right 등), 선택 repeat(1~${MAX_PTY_KEY_REPEAT}).
+- "mouse": 마우스가 켜진 TUI 에 1부터 세는 x,y 와 kind(click/scroll-up/scroll-down), 선택 button(left/middle/right). 모드가 꺼져 있으면 거절되며 다음 관측의 직전 행동 불가 이유를 보고 다른 행동을 택하라.
+- "resize": 양의 정수 cols, rows 로 화면 크기 변경.
 - "wait": 자식이 아직 작업 중(working)이면 대기.
 - "done": 목표를 달성했으면 reason.
+- "handoff": 같은 미션의 다른 담당자에게 넘길 때 to(codex/claude/elanous), mission(다음 작업), carry(diff/summary 선택). elanous 는 증거 게이트와 PR.
+- "ask-human": 화면에 로그인 URL/장치 코드가 보일 때 reason, url/code(화면에 보이는 것만). 자격 파일/토큰은 읽지 마라.
 ${stallKnown ? '- "no-progress": 화면이 오래 얼어붙고 진행 표지가 없지만 완료를 주장할 수 없으면 reason.\n' : ''}${stallKnown ? '화면이 오래 얼어붙고 진행 표지가 없으면 done 또는 no-progress 를 화면 근거로만 판단하라.\n' : ''}화면 분류(참고 신호): ${state}.
-JSON 만 출력: {"action":"input|wait|done${stallKnown ? '|no-progress' : ''}","text":"...","reason":"..."}`;
+JSON 만 출력. 행동을 고른 화면 근거 한 줄을 reason 으로 반드시 담아라. 예: {"action":"key","name":"enter","reason":"메뉴 선택"} / {"action":"mouse","x":10,"y":5,"kind":"click","button":"left","reason":"버튼 누름"} / {"action":"resize","cols":80,"rows":24,"reason":"화면 맞춤"}. input 은 text, done${stallKnown ? '/no-progress' : ''} 는 reason 을 싣는다.`;
 }
 
 function buildUser(obs: ControlObservation, history: readonly string[], limit: number): string {
@@ -101,12 +116,12 @@ function buildUser(obs: ControlObservation, history: readonly string[], limit: n
   const roundContext = obs.roundContext
     ? `\n\n=== 라운드 맥락 ===\n현재 라운드: ${obs.roundContext.round}/${obs.roundContext.effectiveMax}\n직전 라운드 실패: ${obs.roundContext.previousRoundFailure}${obs.roundContext.landedSiblings ? `\n착지한 형제: ${obs.roundContext.landedSiblings.items.map((sibling) => `#${sibling.prNumber} (${sibling.shardId ?? sibling.runId})`).join(', ')} · 표시 ${obs.roundContext.landedSiblings.shownItems}/${obs.roundContext.landedSiblings.totalItems} · 생략 ${obs.roundContext.landedSiblings.omittedItems} · 잘림 ${obs.roundContext.landedSiblings.truncated}` : ''}`
     : '';
-  return `스텝 ${obs.step}. 최근 결정: ${recent}. 화면 변화: ${obs.changed}${stallContext ? ` · ${stallContext}` : ''}${roundContext}\n\n=== 자식 화면 ===\n${obs.screen.slice(-3500)}`;
+  return `스텝 ${obs.step}. 최근 결정: ${recent}. 화면 변화: ${obs.changed}${stallContext ? ` · ${stallContext}` : ''}${roundContext}${obs.unavailableAction ? `\n직전 행동 불가: ${obs.unavailableAction}` : ''}\n\n=== 자식 화면 ===\n${obs.screen.slice(-3500)}`;
 }
 
 /**
  * ⭐제어 루프용 LLM brain. `runPtyControlLoop(createLlmControlBrain({goal}), deps, opts)` 로
- * 자율 미션 실행. 화면⊕#1상태 → LLM → input/wait/done. 오류·무JSON 은 wait(fail-soft).
+ * 자율 미션 실행. 화면⊕#1상태 → LLM → 구조화된 PTY 행동. 오류·무JSON 은 wait(fail-soft).
  */
 export function createLlmControlBrain(opts: LlmControlBrainOpts): RunSupervisor {
   const history: string[] = [];
@@ -155,16 +170,43 @@ export function createLlmControlBrain(opts: LlmControlBrainOpts): RunSupervisor
             ])
           : await call;
       } catch (e) {
-        // fail-soft: 루프의 stuck 감지가 지속 실패를 종료로 수렴(헛돌지 않음).
-        debug.log('autopilot.control', 'brain-error', { step: obs.step, error: (e as Error).message });
+        // Provider failures remain fail-soft; malformed/unknown actions are reported separately below.
+        debug.log('autopilot.control', 'brain-error', { step: obs.step, error: e instanceof Error ? e.message : String(e) });
         record(`${obs.step}:error`);
         return { action: 'wait' };
       } finally {
         if (timer) clearTimeout(timer); // 정상 호출마다 타이머 잔존 방지(review·누수)
         externalSignal?.removeEventListener('abort', onExternalAbort);
       }
-      const decision = await (opts.decisionFromRaw?.(raw, obs) ?? parseControlDecision(raw));
+      let decision: ControlDecision;
+      try {
+        decision = await (opts.decisionFromRaw?.(raw, obs) ?? parseControlDecision(raw));
+      } catch (error) {
+        debug.log('autopilot.control', 'brain-error', { step: obs.step, error: error instanceof Error ? error.message : String(error) });
+        record(`${obs.step}:error`);
+        throw error;
+      }
+      let reason = '';
+      try {
+        const object = extractFirstJsonObject(raw);
+        const parsed = object ? JSON.parse(object) as { reason?: unknown } : null;
+        reason = typeof parsed?.reason === 'string' ? parsed.reason.slice(0, 160) : '';
+      } catch { /* raw response need not be JSON for a domain adapter */ }
+      const rationale = reason.replace(/\s+/g, ' ').trim().slice(0, 160);
+      // Preserve the legacy input/done and handoff contracts (which need no reason field),
+      // but never execute a structured key/mouse/resize operation without a rationale.
+      if (!rationale && (decision.action === 'key' || decision.action === 'mouse' || decision.action === 'resize')) {
+        const error = new Error(`PTY control action ${decision.action} missing brain reason`);
+        debug.log('autopilot.control', 'brain-error', { step: obs.step, error: error.message });
+        record(`${obs.step}:error`);
+        throw error;
+      }
       record(`${obs.step}:${decision.action}`);
+      // wait 외 판단은 ROUTE, ask-human 은 ESCALATE 로 남긴다. 로그인/전환 이벤트에는 화면과 원문 reason 을 싣지 않는다.
+      //   구형 계약(input·done·no-progress 는 reason 없이 와도 된다)은 깨지 않는다 · 구조 행동은 위에서 이미 거절됐다.
+      if (rationale || decision.action !== 'wait') {
+        emitDecision({ kind: decision.action === 'ask-human' ? 'ESCALATE' : 'ROUTE', what: decision.action === 'ask-human' ? '로그인 필요 → 사람' : decision.action === 'handoff' ? `handoff → ${decision.to}` : decision.action === 'key' ? `key ${decision.name}` : decision.action === 'mouse' ? `mouse ${decision.kind} (${decision.x},${decision.y})` : decision.action === 'resize' ? `resize ${decision.cols}x${decision.rows}` : decision.action === 'input' ? `input (${decision.text.length} chars)` : decision.action, reason: decision.action === 'ask-human' ? 'login screen requires human authentication' : decision.action === 'handoff' ? decision.to === 'claude' ? '리뷰 = claude · 왜: 다른 눈' : 'continue mission with next backend' : rationale || '—', purpose: decision.action === 'ask-human' || decision.action === 'handoff' ? 'mission continuation' : opts.goal.replace(/\s+/g, ' ').slice(0, 160), target: decision.action === 'ask-human' ? 'human' : decision.action === 'handoff' ? decision.to : obs.subjectPtyId ?? 'unknown-pty', phase: 'implement' });
+      }
       // ⭐제1원칙 관측 — 판단을 남긴다.
       debug.log('autopilot.control', 'brain', {
         step: obs.step, action: decision.action, state: obs.state,

package/src/autopilot/mission-engine.ts

@@ -27,6 +27,8 @@ import {
   type DecompBaseline, type BaselineArcView, type BaselinePhaseView,
 } from './mission-decompose-baseline.js';
 import { executeApprovedMission } from './mission-executor.js';
+import { deliverMissionPhases, type CourierDeps } from './track-courier.js';
+import { getUserConfig } from '../user-config.js';
 import type { DecomposeCallable } from '../task-orchestrator/generator.js';
 import type { ProposedTask } from '../task-orchestrator/generator-schema.js';
 import { spawn } from 'node:child_process';
@@ -863,11 +865,21 @@ export type SpawnRunFn = (missionId: string) => void;
 
 export async function approveMission(
   missionId: string,
-  deps: { store?: TaskStore; now?: number; createSchedule?: CreateScheduleFn; spawnRun?: SpawnRunFn } = {},
+  deps: { store?: TaskStore; now?: number; createSchedule?: CreateScheduleFn; spawnRun?: SpawnRunFn; courier?: Omit<CourierDeps, 'store' | 'now'> } = {},
 ): Promise<ApproveMissionResult> {
   const store = deps.store ?? new TaskStore();
   const owns = !deps.store;
   const now = deps.now ?? Date.now();
+  const notifyCourier = () => {
+    try {
+      const config = deps.courier?.config ?? getUserConfig().autopilot?.trackCourier;
+      if (config?.enabled === true) {
+        void deliverMissionPhases(missionId, { ...deps.courier, config, store, now });
+      }
+    } catch (e) {
+      try { debug.log('autopilot.track-courier', 'post-failed', { missionId, error: e instanceof Error ? e.message : String(e) }); } catch { /* fail-soft */ }
+    }
+  };
   try {
     const m = getMission(store, missionId);
     if (!m) return { ok: false, activated: 0, error: `미션 없음: ${missionId}` };
@@ -916,6 +928,7 @@ export async function approveMission(
       //   승인 후 막히던 문제. 이제 모든 도메인 승인=실행. 실제 매매 집행은 하위 trade-mandate
       //   (armed/live)가 게이트하므로 미션 실행해도 실매매 오집행 불가(도메인 통째 dry 는 과잉 이중).
       try { (deps.spawnRun ?? defaultSpawnRunMission)(m.id); } catch { /* fail-soft — 스테이징 유지 */ }
+      if (r.ok) notifyCourier();
       return { ok: r.ok, activated: r.activated, ...(r.note ? { note: r.note } : {}) };
     }
     // ── 단일 페이즈 → 기존 동작 유지(ready + run-mission one-shot) ──
@@ -928,6 +941,7 @@ export async function approveMission(
     // ★ 실집행 — ready 만으론 안 돎(활성 디스패처 부재·대표 지적 2026-07-10). run-mission.ts 를
     //   detached one-shot 실행해 골을 에이전트 턴으로 즉시 수행·발송(scheduler 의 1회판).
     try { (deps.spawnRun ?? defaultSpawnRunMission)(m.id); } catch { /* fail-soft — ready 로 남음 */ }
+    notifyCourier();
     return { ok: true, activated };
   } catch (e) {
     return { ok: false, activated: 0, error: e instanceof Error ? e.message.slice(0, 150) : String(e) };