elanous 0.2.0 → 0.2.5

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/acp-token.ts

@@ -0,0 +1,16 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { generateAuthToken } from '../acp/transport/index.js';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+
+/** Load the persistent ACP bearer token, creating it on first boot. */
+export function ensureAuthToken(configDir: string = getElanousConfigDir()): { token: string; path: string } {
+  const path = join(configDir, 'acp-token');
+  mkdirSync(configDir, { recursive: true });
+  if (existsSync(path)) {
+    return { token: readFileSync(path, 'utf-8').trim(), path };
+  }
+  const token = generateAuthToken();
+  writeFileSync(path, token, { mode: 0o600 });
+  return { token, path };
+}

package/src/auth/github-app-token.ts

@@ -0,0 +1,112 @@
+import { createHash, createSign } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join } from 'node:path';
+import { getElanousConfigDir, getElanousConfigDirOverride } from '../elanous-config-dir.js';
+import { prodInstanceRoot } from '../instance/resolve.js';
+import { debug } from '../debug/log.js';
+
+interface AppConfig { id: number; installation_id: number; pem: string }
+interface TokenResponse { token?: unknown; expires_at?: unknown }
+export interface GithubInstallationTokenScope { repository: string }
+interface InstallationTokenRequest {
+  repositories: [string];
+  permissions: { contents: 'write'; pull_requests: 'write' };
+}
+
+/** Synchronous HTTP seam: CmdRunner must remain synchronous for existing callers. */
+export interface GithubAutomationTokenDeps {
+  configPath?: string;
+  now?: () => number;
+  scope?: GithubInstallationTokenScope;
+  fetch?: (url: string, jwt: string, body?: InstallationTokenRequest) => TokenResponse;
+}
+
+const REFRESH_MARGIN_MS = 10 * 60_000;
+const JWT_LIFETIME_SECONDS = 9 * 60;
+let cached: { fingerprint: string; token: string; expiresAt: number } | undefined;
+
+function requestToken(url: string, jwt: string, body?: InstallationTokenRequest): TokenResponse {
+  const response = spawnSync('curl', [
+    '--silent', '--show-error', '--fail', '--max-time', '30', '--request', 'POST',
+    '--header', 'Accept: application/vnd.github+json',
+    '--header', '@-',
+    '--header', 'X-GitHub-Api-Version: 2022-11-28',
+    ...(body ? ['--header', 'Content-Type: application/json', '--data-raw', JSON.stringify(body)] : []),
+    url,
+  ], { encoding: 'utf8', timeout: 35_000, input: `Authorization: Bearer ${jwt}\n`, env: process.env });
+  // Never expose curl's stderr: it may contain request credentials.
+  if (response.error || response.status !== 0) throw new Error('http-failed');
+  return JSON.parse(response.stdout) as TokenResponse;
+}
+
+/** Missing App config is a no-op; an unusable configured App falls back to the caller's gh credentials. */
+export function githubAutomationToken(deps: GithubAutomationTokenDeps = {}): string | null {
+  return githubInstallationCredential(deps)?.token ?? null;
+}
+
+/** Scoped requests always mint anew; the returned expiry comes from GitHub's response. */
+export function githubInstallationCredential(deps: GithubAutomationTokenDeps = {}): { token: string; expires_at: string } | null {
+  let path: string;
+  // The App credential is machine-level (like `gh auth` in ~/.config/gh), not per universe: a tree-derived test
+  // universe resolves its config dir to `<tree>/.elanous-test`, where the file never is — 09-29 #21879 was inert there.
+  // Order: explicit path → this universe's config dir → the prod root `~/.elanous`.
+  try {
+    const rel = join('secrets', 'github-app', 'app.json');
+    const own = join(getElanousConfigDir(), rel);
+    // An explicit config-dir override (tests · `--config-dir`) is a deliberate boundary — never reach past it.
+    path = deps.configPath ?? (existsSync(own) || getElanousConfigDirOverride() ? own : join(prodInstanceRoot(), rel));
+  }
+  catch {
+    try { debug.log('auth.github-app', 'token-failed', { reason: 'config-path-failed' }); } catch { /* fail open */ }
+    return null;
+  }
+  let configText: string;
+  try { configText = readFileSync(path, 'utf8'); }
+  catch (error) {
+    cached = undefined;
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    try { debug.log('auth.github-app', 'token-failed', { reason: 'config-read-failed' }); } catch { /* fail open */ }
+    return null;
+  }
+  try {
+    const now = (deps.now ?? Date.now)();
+    const config = JSON.parse(configText) as AppConfig;
+    if (!config || !Number.isSafeInteger(config.id) || config.id <= 0 ||
+        !Number.isSafeInteger(config.installation_id) || config.installation_id <= 0 ||
+        typeof config.pem !== 'string' || !config.pem) throw new Error('invalid-config');
+    const pem = isAbsolute(config.pem) ? readFileSync(config.pem, 'utf8')
+      : config.pem.includes('-----BEGIN') ? config.pem
+      : readFileSync(join(dirname(path), config.pem), 'utf8');
+    const repository = deps.scope?.repository;
+    if (deps.scope && (typeof repository !== 'string' || !/^[a-zA-Z0-9_.-]+$/.test(repository) || repository === '.' || repository === '..')) {
+      throw new Error('invalid-repository');
+    }
+    const request: InstallationTokenRequest | undefined = repository
+      ? { repositories: [repository], permissions: { contents: 'write', pull_requests: 'write' } }
+      : undefined;
+    const fingerprint = createHash('sha256').update(JSON.stringify([path, config.id, config.installation_id, pem])).digest('hex');
+    if (!request && cached?.fingerprint === fingerprint && now < cached.expiresAt - REFRESH_MARGIN_MS) return { token: cached.token, expires_at: new Date(cached.expiresAt).toISOString() };
+    if (!request) cached = undefined;
+    const issuedAt = Math.floor(now / 1000) - 60;
+    const encode = (value: object) => Buffer.from(JSON.stringify(value)).toString('base64url');
+    const unsigned = `${encode({ alg: 'RS256', typ: 'JWT' })}.${encode({ iat: issuedAt, exp: issuedAt + JWT_LIFETIME_SECONDS, iss: String(config.id) })}`;
+    const signer = createSign('RSA-SHA256');
+    signer.update(unsigned);
+    const jwt = `${unsigned}.${signer.sign(pem, 'base64url')}`;
+    const url = `https://api.github.com/app/installations/${config.installation_id}/access_tokens`;
+    const response = (deps.fetch ?? requestToken)(url, jwt, request);
+    const expiresAt = typeof response.expires_at === 'string' ? Date.parse(response.expires_at) : NaN;
+    if (typeof response.token !== 'string' || !response.token || !Number.isFinite(expiresAt) ||
+        expiresAt <= now + REFRESH_MARGIN_MS) throw new Error('invalid-response');
+    if (!request) cached = { fingerprint, token: response.token, expiresAt };
+    try { debug.log('auth.github-app', 'token-minted', { installationId: config.installation_id, expiresAt: new Date(expiresAt).toISOString() }); }
+    catch { /* logging must not undo a valid token */ }
+    return { token: response.token, expires_at: response.expires_at as string };
+  } catch {
+    if (!deps.scope) cached = undefined;
+    // Do not log exceptions: crypto/HTTP failures can include key or bearer material.
+    try { debug.log('auth.github-app', 'token-failed', { reason: 'mint-failed' }); } catch { /* fail open */ }
+    return null;
+  }
+}

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`;
 }