elanous 0.2.17 → 0.2.19

package/scripts/test-diet/effectiveness.ts

@@ -1,7 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { cpSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, existsSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import ts from 'typescript';
 import { pickRange } from './lib.js';
 
@@ -119,6 +119,67 @@ export function fixedCountAssertions(testPath: string, root: string): Array<{ li
   return assertions.sort((a, b) => a.line - b.line);
 }
 
+// Read module specifiers from syntax, not from comments or strings; re-exports count for non-test importers.
+function directImports(file: string, includeReexports = false): string[] {
+  const source = ts.createSourceFile(file, readFileSync(file, 'utf8'), ts.ScriptTarget.Latest, true);
+  const imports: string[] = [];
+  const visit = (node: ts.Node): void => {
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) imports.push(node.moduleSpecifier.text);
+    if (includeReexports && ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier))
+      imports.push(node.moduleSpecifier.text);
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword
+      && node.arguments.length === 1 && ts.isStringLiteral(node.arguments[0]!)) imports.push(node.arguments[0]!.text);
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return imports;
+}
+
+/** Directly imported repository modules with no direct, tracked, non-test importer. */
+export function unreachableImports(testPath: string, root: string, deps: {
+  importers?: (modulePath: string, root: string) => string[];
+} = {}): string[] {
+  const repo = realpathSync(resolve(root));
+  const inside = (path: string) => path !== repo && !relative(repo, path).startsWith(`..${sep}`)
+    && relative(repo, path) !== '..' && !isAbsolute(relative(repo, path));
+  const validFile = (path: string) => inside(path) && existsSync(path) && realpathSync(path) === path && statSync(path).isFile();
+  const isTest = (path: string) => path.endsWith('.test.ts') || path === 'test' || path.startsWith(`test${sep}`);
+  const testFile = resolve(repo, testPath);
+  if (!validFile(testFile)) throw new Error('test path outside repository or symlinked');
+  const resolveImport = (from: string, specifier: string): string | undefined => {
+    if (!/^\.{1,2}\//.test(specifier)) return undefined;
+    const base = resolve(dirname(from), specifier);
+    const candidates = base.endsWith('.js')
+      ? [base.replace(/\.js$/, '.ts'), base, `${base}.ts`, join(base, 'index.ts')]
+      : [base, `${base}.ts`, join(base, 'index.ts')];
+    return candidates.find(validFile);
+  };
+  const importers = deps.importers ?? ((modulePath: string, rootPath: string): string[] => {
+    const stem = basename(modulePath).replace(/\.[^.]+$/, '');
+    const needles = stem === 'index' ? [stem, basename(dirname(modulePath))] : [stem];
+    const matches = new Set<string>();
+    for (const needle of needles) {
+      const found = spawnSync('git', ['-C', rootPath, 'grep', '-l', '-F', '--', needle], { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+      if (found.error || (found.status !== 0 && found.status !== 1)) throw new Error(`importer lookup failed: ${found.error?.message ?? found.stderr}`);
+      for (const file of found.stdout.split('\n').filter(Boolean)) matches.add(file);
+    }
+    return [...matches];
+  });
+  const sources = new Set(directImports(testFile).map((specifier) => resolveImport(testFile, specifier))
+    .filter((path): path is string => path !== undefined && !isTest(relative(repo, path))));
+  const unreachable: string[] = [];
+  for (const source of sources) {
+    const modulePath = relative(repo, source);
+    const used = importers(modulePath, repo).some((candidate) => {
+      const path = resolve(repo, candidate);
+      if (!validFile(path) || isTest(relative(repo, path)) || path === source) return false;
+      return directImports(path, true).some((specifier) => resolveImport(path, specifier) === source);
+    });
+    if (!used) unreachable.push(modulePath.split(sep).join('/'));
+  }
+  return unreachable.sort();
+}
+
 export function mutationProbe(file: string, deps: { root: string; run?: (root: string, file: string) => number | null; baselineStable?: boolean }): Mutation {
   if (deps.baselineStable === false) return 'n/a';
   const root = realpathSync(resolve(deps.root));

package/scripts/test-diet/lib.ts

@@ -7,7 +7,7 @@ export const DEFAULT_COST_SECS = 10;
 export const SLOW_SECS = 60;
 export const HEAVY_MB = 2048;
 
-export interface Effectiveness { flake: 'stable' | 'flaky' | 'failing'; mutation: 'caught' | 'survived' | 'n/a'; fixedCounts?: number }
+export interface Effectiveness { flake: 'stable' | 'flaky' | 'failing'; mutation: 'caught' | 'survived' | 'n/a'; fixedCounts?: number; unreachable?: number }
 export interface Measurement { file: string; secs: number; rssMb: number | null; rc: number | null; pass: number | null; fail: number | null; reason?: string; effectiveness?: Effectiveness }
 export type Verdict = 'keep' | 'failing' | 'review';
 export type Proposal = 'delete' | 'shrink' | 'rewrite-cheap' | 'move-out-of-gate' | 'investigate';

package/scripts/test-diet/node.ts

@@ -10,7 +10,7 @@ import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
 import { CardStore } from '../../src/task-cards/card-store.js';
 import { GATE_NIGHTLY_AUDITS } from '../release-loop/gate-node.js';
 import { appendLedger, costTable, judge, lastLedgerLine, ledgerPath, nightlyAuditLedgerPath, pickRange, propose, td1Dispositions, writeCardDraft, type LedgerLine, type Measurement, type Td1Disposition } from './lib.js';
-import { fixedCountAssertions, flakeVerdict, sweepSlice, type Mutation, type TestRun } from './effectiveness.js';
+import { fixedCountAssertions, flakeVerdict, sweepSlice, unreachableImports, type Mutation, type TestRun } from './effectiveness.js';
 
 type Context = { graphId?: string; input: Record<string, unknown>; outputs: Record<string, Record<string, unknown> | null> };
 function context(): Context {
@@ -123,6 +123,13 @@ function measure(ctx: Context, audit = false, effectiveness = false): number {
           file: measurement.file, reason: error instanceof Error ? error.message : String(error),
         });
       }
+      try {
+        measurement.effectiveness.unreachable = unreachableImports(measurement.file, process.cwd()).length;
+      } catch (error) {
+        debug.log('test-diet.effectiveness', 'unreachable-unreadable', {
+          file: measurement.file, reason: error instanceof Error ? error.message : String(error),
+        });
+      }
       debug.log('test-diet.effectiveness', 'judged', { file: measurement.file, ...measurement.effectiveness, secs: effect.secs });
     }
   }

package/scripts/video/scene-table.ts

@@ -0,0 +1,159 @@
+#!/usr/bin/env bun
+// ── 장면표(scenes.json) 한 벌에서 SRT·VO 대본을 뽑고, 공개 전 검사를 한다 ──────
+//
+// 계기(DEMO-VIDEO-1008 · 2026-10-07): 스토리보드 SRT 초안이 «한 줄 22자 · 두 줄»을
+//   스스로 어겼다(한 블록 세 줄 · 24자 줄). 자막·VO·숫자 카드가 표 «셋»에 따로 있으면
+//   한쪽만 고쳐지고 갈린다 ⇒ 장면표가 SSOT 이고 SRT·VO 는 «뽑아낸 것»이다.
+//
+// 사용:
+//   bun scripts/video/scene-table.ts check <scenes.json>   검사(exit 0 통과 · 1 걸림 · 3 입력 불량)
+//   bun scripts/video/scene-table.ts srt   <scenes.json>   한국어 SRT 를 stdout 으로(검사 통과 때만)
+//   bun scripts/video/scene-table.ts vo    <scenes.json>   영어 VO 대본(장면 번호 · 시각)을 stdout 으로
+//
+// ⛔ 숫자 자리표시 `{{KEY}}` 는 `measured.KEY.value` 로만 채운다 — 값이 없으면 «걸림»이다(지어낸 수치 금지).
+
+import { readFileSync } from 'node:fs';
+
+export type Cue = { start: number; end: number; lines: string[] };
+export type Scene = {
+  n: number; start: number; end: number; source: string[];
+  vo?: string | null; ko?: Cue[]; numberCard?: string; requestText?: string;
+};
+export type SceneTable = {
+  durationSec: number;
+  vo?: { maxWpm?: number };
+  subtitles?: { maxCharsPerLine?: number; maxLines?: number };
+  measured?: Record<string, { value?: number | string | null }>;
+  scenes: Scene[];
+};
+
+// 공개 수위: 특허 보류 기전 · 경쟁사 이름 · 미래 약속 · 내부 표식 · 기기 경로.
+// 단어 경계가 없는 한국어는 부분 일치로 잡는다.
+export const BANNED: Array<{ re: RegExp; why: string }> = [
+  { re: /시냅스|synap/i, why: '특허 보류 기전' },
+  { re: /수면|\bsleep/i, why: '특허 보류 기전' },
+  { re: /그라운딩\s*방아쇠|grounding\s+trigger/i, why: '특허 보류 기전' },
+  { re: /선제\s*PTY|pre-?emptive\s+PTY/i, why: '특허 보류 기전' },
+  { re: /면역|immun|암\s*억제|\bcancer\b/i, why: '특허 보류 기전' },
+  { re: /openclaw|hermes|codex|cursor|devin|copilot|claude\s*code/i, why: '경쟁사 이름' },
+  { re: /곧\s|\bsoon\b|\bcoming\b|available now|out now/i, why: '미래 약속' },
+  // 표식 문자는 코드 포인트로 적는다 — 이 파일 자체가 공개본 유출 검사에 걸리지 않게.
+  { re: /[\u{1F451}\u{1F162}\u{1F163}\u{1F155}\u{1F15E}]|RFC-|HAND[O]FF-/u, why: '내부 표식' },
+  { re: /\/Users\/|\.ts\.net|tail[0-9a-f]{6}/, why: '기기 경로·이름' },
+];
+
+const PLACEHOLDER = /\{\{([A-Z0-9_]+)\}\}/g;
+
+export function fill(text: string, t: SceneTable, problems: string[], where: string): string {
+  return text.replace(PLACEHOLDER, (_m, key: string) => {
+    const v = t.measured?.[key]?.value;
+    if (v === undefined || v === null || v === '') {
+      problems.push(`${where}: {{${key}}} 의 실측값이 없다(measured.${key}.value)`);
+      return `{{${key}}}`;
+    }
+    return String(v);
+  });
+}
+
+const words = (s: string) => s.trim().split(/\s+/).filter(Boolean).length;
+
+export function checkTable(t: SceneTable): string[] {
+  const p: string[] = [];
+  const maxChars = t.subtitles?.maxCharsPerLine ?? 22;
+  const maxLines = t.subtitles?.maxLines ?? 2;
+  const maxWpm = t.vo?.maxWpm ?? 150;
+  const scenes = [...t.scenes].sort((a, b) => a.start - b.start);
+
+  let cursor = 0;
+  let lastCueEnd = -1;
+  for (const s of scenes) {
+    const at = `장면 ${s.n}`;
+    if (s.start !== cursor) p.push(`${at}: 시작 ${s.start}s — 앞 장면 끝 ${cursor}s 와 이어지지 않는다`);
+    if (!(s.end > s.start)) p.push(`${at}: 끝(${s.end}s)이 시작(${s.start}s) 뒤가 아니다`);
+    cursor = s.end;
+
+    const pub: Array<[string, string]> = [];
+    if (s.vo) {
+      const wpm = (words(s.vo) / (s.end - s.start)) * 60;
+      if (wpm > maxWpm) p.push(`${at}: VO ${wpm.toFixed(0)} wpm > ${maxWpm}`);
+      pub.push([`${at} VO`, s.vo]);
+    }
+    if (s.numberCard) pub.push([`${at} 숫자 카드`, fill(s.numberCard, t, p, `${at} 숫자 카드`)]);
+    if (s.requestText) pub.push([`${at} 요청 문구`, s.requestText]);
+
+    for (const [i, c] of (s.ko ?? []).entries()) {
+      const cat = `${at} 자막 ${i + 1}`;
+      if (!(c.end > c.start)) p.push(`${cat}: 끝이 시작 뒤가 아니다`);
+      if (c.start < s.start || c.end > s.end) p.push(`${cat}: ${c.start}–${c.end}s 가 장면 ${s.start}–${s.end}s 밖으로 나간다`);
+      if (c.start < lastCueEnd) p.push(`${cat}: 앞 자막(끝 ${lastCueEnd}s)과 겹친다`);
+      lastCueEnd = c.end;
+      if (c.lines.length === 0 || c.lines.length > maxLines) p.push(`${cat}: ${c.lines.length}줄(1~${maxLines})`);
+      for (const raw of c.lines) {
+        const line = fill(raw, t, p, cat);
+        const len = [...line].length;
+        if (len > maxChars) p.push(`${cat}: «${line}» ${len}자 > ${maxChars}`);
+        pub.push([cat, line]);
+      }
+    }
+    for (const [where, text] of pub) {
+      for (const b of BANNED) if (b.re.test(text)) p.push(`${where}: ${b.why} — «${text}»`);
+    }
+  }
+  if (cursor !== t.durationSec) p.push(`마지막 장면 끝 ${cursor}s ≠ durationSec ${t.durationSec}s`);
+  return p;
+}
+
+const ts = (sec: number) => {
+  const ms = Math.round(sec * 1000);
+  const h = Math.floor(ms / 3_600_000), m = Math.floor((ms % 3_600_000) / 60_000);
+  const s = Math.floor((ms % 60_000) / 1000), r = ms % 1000;
+  const z = (n: number, w = 2) => String(n).padStart(w, '0');
+  return `${z(h)}:${z(m)}:${z(s)},${z(r, 3)}`;
+};
+
+export function toSrt(t: SceneTable): string {
+  const scratch: string[] = [];
+  const cues = t.scenes.flatMap((s) => s.ko ?? []).sort((a, b) => a.start - b.start);
+  return cues
+    .map((c, i) => `${i + 1}\n${ts(c.start)} --> ${ts(c.end)}\n${c.lines.map((l) => fill(l, t, scratch, '')).join('\n')}\n`)
+    .join('\n');
+}
+
+export function toVoScript(t: SceneTable): string {
+  return t.scenes
+    .filter((s) => s.vo)
+    .map((s) => `[${s.n}] ${ts(s.start).slice(3, 8)}–${ts(s.end).slice(3, 8)}  ${s.vo}`)
+    .join('\n') + '\n';
+}
+
+function readTable(file: string): SceneTable {
+  try {
+    const t = JSON.parse(readFileSync(file, 'utf8')) as SceneTable;
+    if (!Array.isArray(t.scenes) || typeof t.durationSec !== 'number') throw new Error('scenes[] · durationSec 가 필요하다');
+    return t;
+  } catch (e) {
+    console.error(`⛔ 장면표를 못 읽었다: ${(e as Error).message}`);
+    process.exit(3);
+  }
+}
+
+if (import.meta.main) {
+  const [cmd, file] = process.argv.slice(2);
+  if (!cmd || !file || !['check', 'srt', 'vo'].includes(cmd)) {
+    console.error('사용: bun scripts/video/scene-table.ts <check|srt|vo> <scenes.json>');
+    process.exit(3);
+  }
+  const t = readTable(file);
+  const problems = checkTable(t);
+  if (cmd === 'check') {
+    for (const x of problems) console.log(`⛔ ${x}`);
+    console.log(problems.length ? `걸림 ${problems.length}` : `✅ 통과 · 장면 ${t.scenes.length} · 자막 ${t.scenes.flatMap((s) => s.ko ?? []).length}`);
+    process.exit(problems.length ? 1 : 0);
+  }
+  if (problems.length) {
+    for (const x of problems) console.error(`⛔ ${x}`);
+    console.error(`걸림 ${problems.length} — 검사를 통과한 장면표에서만 ${cmd} 를 뽑는다`);
+    process.exit(1);
+  }
+  process.stdout.write(cmd === 'srt' ? toSrt(t) : toVoScript(t));
+}

package/src/acp/core-turn-bridge.ts

@@ -49,9 +49,24 @@ import type { AcpServerOptions, AcpTurnContext } from './server.js';
 import { acpToolDenialResult } from './tool-approval.js';
 import { readOriginSessionMeta } from './origin-session-meta.js';
 import { isFactQuestion } from './fact-question.js';
+import { classifyTuiChatIntent, type TuiChatRoute } from '../core-turn/short-question.js';
+import { HARNESS_ROLE_ENV } from '../harness/harness-space.js';
 
 const FACT_QUESTION_INSTRUCTION = '사실·최신 정보 질문이다. WebSearch 를 1~2회 쓰고 검색 결과(제목·스니펫·URL)로 답하라. 출처 링크를 붙여라. 셸·브라우저·파일 도구는 검색 결과로 부족할 때만. 도구 예산에 닿으면 지금까지 근거로 답하고 끝에 «더 찾아볼까요?»를 붙여라.';
 
+// An allowlist, not a denylist: a new repository writer cannot slip into a quick turn.
+const QUICK_TOOLS: Record<Exclude<TuiChatRoute, '코딩·구현'>, readonly string[]> = {
+  '조회': ['decisions_pending', 'ops_seats', 'ops_status', 'release_status', 'logs_query', 'context_now', 'memory_recall', 'Read'],
+  '설정 변경': ['DashboardConfigGet', 'DashboardConfigSet', 'LlmListAvailableModels', 'prompt_getRuntimeConfig', 'prompt_setRuntimeConfig', 'view_getConfig', 'view_applyRuntimeConfig', 'view_saveConfig'],
+  '조사': ['WebSearch', 'OmniSearch', 'Grep', 'Glob', 'Read', 'fact_check'],
+  '상시 일': ['schedule_manage', 'schedule_list', 'schedule_create', 'schedule_update', 'session_manage', 'ops_status'],
+};
+
+export function toolsForTuiRoute(tools: readonly LLMToolSpec[], route: Exclude<TuiChatRoute, '코딩·구현'>): LLMToolSpec[] {
+  const preferred = QUICK_TOOLS[route];
+  return preferred.flatMap((name) => tools.filter((tool) => tool.name === name));
+}
+
 export interface CoreTurnBridgeDeps {
   /** Build the seed message list for this ACP prompt. Implementations
    *  typically concatenate per-session history with
@@ -110,6 +125,8 @@ export interface CoreTurnBridgeDeps {
    *  to 1ms so they don't spend real wall clock waiting for the
    *  flag to propagate. */
   abortPollMs?: number;
+  /** Only the in-process dashboard session opts into TUI routing; daemon ACP stays unchanged. */
+  tuiRouting?: boolean;
 }
 
 /** Default abort-poll cadence. 50ms = 20 Hz: responsive without
@@ -192,12 +209,32 @@ export function bridgeCoreTurnToAcp(
           promptMeta: turnCtx.promptMeta,
         }),
       );
-      const tools = await Promise.resolve(
+      const availableTools = await Promise.resolve(
         deps.getTools({
           sessionId: turnCtx.sessionId,
           userText: turnCtx.userText,
         }),
       );
+      // Only a goal-driven harness child (explicit executor role — dev-harness · self-implement surfaces) keeps every
+      // turn on the goal loop. A human TUI inside a harness space (one-word `dev --elanous`, `--hold`) is routed (UX 10-07).
+      const harness = process.env[HARNESS_ROLE_ENV]?.trim() === 'executor';
+      const route = deps.tuiRouting && !harness
+        ? classifyTuiChatIntent(turnCtx.userText, {
+            hasAttachments: turnCtx.promptBlocks?.some((block) => block.type !== 'text') ?? false,
+          })
+        : { route: '코딩·구현' as const, reason: harness ? 'harness' : 'legacy', goalLoop: true };
+      const tools = !route.goalLoop && route.route !== '코딩·구현'
+        ? toolsForTuiRoute(availableTools, route.route)
+        : availableTools;
+      if (deps.tuiRouting) {
+        debug.log('chat.route', 'decided', { route: route.route, reason: route.reason, goalLoop: route.goalLoop });
+        // Only a quick route is announced: a coding turn's transcript stays exactly as before (preservation).
+        // Awaited so the route line precedes the answer; a failed write is observed, not fatal to the turn.
+        if (!route.goalLoop) {
+          try { await turnCtx.push(`라우팅: ${route.route}\n`); }
+          catch (error) { debug.log('chat.route', 'push-failed', { route: route.route, error: String(error) }); }
+        }
+      }
       const modelOverride = deps.resolveModel?.({ sessionId: turnCtx.sessionId, userText: turnCtx.userText });
       const factQuestion = isFactQuestion(turnCtx.userText);
       const explicitMaxToolTurns = deps.resolveMaxToolTurns?.({ sessionId: turnCtx.sessionId });
@@ -233,7 +270,7 @@ export function bridgeCoreTurnToAcp(
       const goalLoopCfg = getUserConfig().llm.goalLoop;
       const turnModel = modelOverride ?? getUserConfig().llm.model;
       const turnFamily = getModelFamily(turnModel);
-      const armGoalLoop = goalLoopCfg?.enabled === true;
+      const armGoalLoop = goalLoopCfg?.enabled === true && route.goalLoop;
       if (armGoalLoop) {
         // 관측 — 어느 family/모델에서 across-turn goal-loop 가 아밍됐나(전-family 개방 검증).
         debug.log('goal.loop', 'arm', { family: turnFamily, model: turnModel });

package/src/agent-mission/review-loop.ts

@@ -22,7 +22,7 @@ import { budgetReviewerContext } from '../agent-substrate/pr-reviewer.js';
 import { DEFAULT_REVIEW_BACKEND } from '../agent-substrate/acp-reviewer.js';
 import { loadReviewerContext } from '../agent-substrate/self-review-cli.js';
 import { createRepositoryReferencedFileReader, type ReferencedFileReader } from '../self-implement/goal-file-reader.js';
-import { parse as parsePrCommentMeta } from '../agent-substrate/pr-comment-meta.js';
+import { expandRecords, parse as parsePrCommentMeta } from '../agent-substrate/pr-comment-meta.js';
 
 export type ReviewVerdict = 'ok' | 'reinforce' | 'reject' | 'ambiguous';
 export type ReviewClassificationSource = 'llm' | 'llm-call-failure' | 'empty-review' | 'injected';
@@ -310,9 +310,10 @@ function analyzeAppliedReviewItems(comments: readonly NonNullable<LatestReviewSo
   const items: string[] = [];
   const seen = new Set<string>();
   let headlineComments = 0;
-  const newestFirst = [...comments].sort((a, b) => (b.createdAt ?? '').localeCompare(a.createdAt ?? ''));
+  const newestFirst = comments.flatMap((comment) => expandRecords(comment.body ?? '').map((body) => ({ ...comment, body })))
+    .sort((a, b) => (b.createdAt ?? '').localeCompare(a.createdAt ?? ''));
   for (const comment of newestFirst) {
-    const lines = (comment.body ?? '').split('\n');
+    const lines = comment.body.split('\n');
     const headlineIndex = parsePrCommentMeta(lines[0] ?? '') ? 1 : 0;
     const headline = lines[headlineIndex]?.trim() ?? '';
     if (!headline.startsWith(REVIEW_REINFORCEMENT_HEADLINE) && !headline.startsWith(ACP_REWORK_HEADLINE)) continue;

package/src/agent-substrate/pr-comment-meta.ts

@@ -97,3 +97,23 @@ export function parse(body: string): PrCommentMeta | null {
   }
   return parsed;
 }
+
+/** 상태 댓글의 details 에 쌓인 라운드 기록을 개별 댓글 본문으로 펼친다. */
+export function expandRecords(body: string): string[] {
+  if (!/^<!-- elanous:run-status -->(?:\r?\n|$)/.test(body)) return [body];
+
+  const records: string[] = [];
+  for (const details of body.matchAll(/<details(?:\s[^>]*)?>([\s\S]*?)<\/details>/g)) {
+    const content = details[1];
+    const headers: Array<{ index: number; round?: number }> = [];
+    for (const header of content.matchAll(/^<!-- elanous-pr-comment v1 [^\r\n]* -->$/gm)) {
+      const meta = parse(header[0]);
+      if (meta) headers.push({ index: header.index, round: meta.round });
+    }
+    for (let i = 0; i < headers.length; i++) {
+      if (headers[i].round === undefined) continue;
+      records.push(content.slice(headers[i].index, headers[i + 1]?.index ?? content.length).replace(/(?:\r?\n)+$/, ''));
+    }
+  }
+  return records.length ? records : [body];
+}

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

@@ -67,8 +67,10 @@ export interface LlmMergeOutcome {
   testDeclarationUnmeasured?: string[];
   /** 해결기 응답이 LLM 공급자 오류 문구였다 — 파일 내용이 아니다(🅢 2026-09-27 #21086: 세 파일이 통째로 그 문구가 됐다). */
   providerFailure?: string[];
-  /** LLM 입력 상한 초과: 사람 수확으로 넘긴다. 원래 브랜치는 abort 후 보존된다. */
-  reason?: 'conflict-input-too-large' | 'conflict-resolver-interrupted';
+  /** 충돌 미해결의 원인. 기존 두 원인에 마커 잔존·파일 읽기 실패를 추가한다. */
+  reason?: 'conflict-input-too-large' | 'conflict-resolver-interrupted' | 'conflict-markers-remain' | 'conflict-file-unreadable';
+  /** 해결이 멎은 충돌 파일(worktree 상대 경로). */
+  failedFile?: string;
   inputChars?: number;
   /** 병합 결과가 양쪽 판 중 작은 쪽의 절반 아래로 줄었다 — 통째로 날린 것으로 보고 해결 실패로 친다. */
   sizeCollapse?: Array<{ file: string; ours: number; theirs: number; merged: number }>;
@@ -107,6 +109,20 @@ function addSizeChange(size: LlmMergeSizeChange, file: string, before: string, a
 
 export function formatLlmMergeOutcome(outcome: LlmMergeOutcome): string {
   const files = outcome.resolvedFiles?.length ? ` (LLM 종합 ${outcome.resolvedFiles.length}파일: ${outcome.resolvedFiles.join(', ')})` : '';
+  if (outcome.status === 'conflict-unresolved') {
+    // ⛔ reason·failedFile 은 «선택» 칸이다 — 공급자 오류·시험 선언 유실·크기 붕괴 출구는 계약상 reason 이 없다.
+    //   있는 칸만 싣고, 그 출구들은 자기 실제 결과(어느 판정이 멈췄나)를 싣는다 — 「사유 undefined」 금지.
+    const parts = [
+      ...(outcome.reason ? [`사유 ${outcome.reason}`] : []),
+      ...(outcome.failedFile ? [`파일 ${outcome.failedFile}`] : []),
+      ...(outcome.providerFailure?.length ? [`공급자 오류 문구 ${outcome.providerFailure.join(', ')}`] : []),
+      ...(outcome.testDeclarationLoss?.length
+        ? [`시험 선언 유실 ${outcome.testDeclarationLoss.map((l) => `${l.file} ${l.ours}/${l.theirs}→${l.merged}`).join(', ')}`] : []),
+      ...(outcome.sizeCollapse?.length
+        ? [`크기 붕괴 ${outcome.sizeCollapse.map((c) => `${c.file} ${c.ours}/${c.theirs}→${c.merged}줄`).join(', ')}`] : []),
+    ];
+    return `${outcome.status}${files}${parts.length ? `; ${parts.join(' · ')}` : ''}`;
+  }
   if (outcome.status !== 'llm-resolved') return `${outcome.status}${files}`;
   const size = outcome.sizeChange;
   if (size === undefined) return `${outcome.status}${files}; 규모 변화: 못 쟀다`;
@@ -211,6 +227,10 @@ export async function mergeMainWithLlmResolve(
     ...outcome,
     ...(testDeclarationUnmeasured.length ? { testDeclarationUnmeasured } : {}),
   });
+  const unresolved = (outcome: LlmMergeOutcome & { status: 'conflict-unresolved'; failedFile: string }): LlmMergeOutcome => {
+    debug.log('self-dev.merge', 'conflict-unresolved', { reason: outcome.reason, failedFile: outcome.failedFile, resolvedCount: resolvedFiles.length });
+    return measuredOutcome(outcome);
+  };
   for (const f of files) {
     const abs = join(worktreePath, f);
     let conflicted: string;
@@ -219,7 +239,7 @@ export async function mergeMainWithLlmResolve(
       conflicted = git.readFile(abs);
     } catch {
       git.abort(worktreePath);
-      return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles });
+      return unresolved({ status: 'conflict-unresolved', reason: 'conflict-file-unreadable', failedFile: f, resolvedFiles });
     }
     try {
       // release/next.md: concurrent landings each append a line — keep both without asking the LLM (REL7c).
@@ -227,7 +247,7 @@ export async function mergeMainWithLlmResolve(
       merged = deterministic ?? await resolve(f, conflicted);
     } catch (error) {
       git.abort(worktreePath); // LLM 예외 → base 유지
-      return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles,
+      return unresolved({ status: 'conflict-unresolved', resolvedFiles, failedFile: f,
         ...(error instanceof MergeConflictInputTooLarge
           ? { reason: 'conflict-input-too-large' as const, inputChars: error.inputChars }
           : { reason: 'conflict-resolver-interrupted' as const }),
@@ -235,11 +255,11 @@ export async function mergeMainWithLlmResolve(
     }
     if (PROVIDER_FAILURE_TEXT.test(merged)) {
       git.abort(worktreePath); // 해결기가 공급자 오류 문구를 «내용»으로 돌려줬다 → base 유지
-      return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles, providerFailure: [f] });
+      return unresolved({ status: 'conflict-unresolved', resolvedFiles, failedFile: f, providerFailure: [f] });
     }
     if (hasConflictMarkers(merged)) {
       git.abort(worktreePath); // LLM 이 종합 못 함(마커 잔존) → base 유지
-      return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles });
+      return unresolved({ status: 'conflict-unresolved', reason: 'conflict-markers-remain', failedFile: f, resolvedFiles });
     }
     try {
       const ours = countTestDeclarations(git.readIndexStage(worktreePath, 2, f));
@@ -248,7 +268,7 @@ export async function mergeMainWithLlmResolve(
       if (mergedDeclarations < Math.min(ours, theirs)) {
         const testDeclarationLoss = [{ file: f, ours, theirs, merged: mergedDeclarations }];
         git.abort(worktreePath);
-        return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles, testDeclarationLoss });
+        return unresolved({ status: 'conflict-unresolved', resolvedFiles, failedFile: f, testDeclarationLoss });
       }
     } catch {
       testDeclarationUnmeasured.push(f);
@@ -260,7 +280,7 @@ export async function mergeMainWithLlmResolve(
       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 }] });
+        return unresolved({ status: 'conflict-unresolved', resolvedFiles, failedFile: f, sizeCollapse: [{ file: f, ours, theirs, merged: mergedLines }] });
       }
     } catch {
       /* 한쪽 판이 없는 충돌(삭제·추가) — 크기 비교 대상이 아니다 */

package/src/away/presence.ts

@@ -0,0 +1,40 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+
+/** AWAY-MODE-1 — 대표가 자리를 비웠나. 한 파일(`<instance>/presence.json`)이 정본이고 CLI·텔레그램 /away 가 같이 쓴다. */
+export interface Presence {
+  away: boolean;
+  /** 마지막으로 바꾼 시각(ISO). 한 번도 안 바꿨으면 없음. */
+  since?: string;
+  /** 누가 바꿨나 — cli · telegram · pwa. */
+  by?: string;
+}
+
+export function presencePath(root: string = effectiveInstanceRoot()): string {
+  return join(root, 'presence.json');
+}
+
+/** 못 읽으면 «자리에 있음»으로 읽는다 — 외출 알림은 켠 사람만 받는다. */
+export function readPresence(path: string = presencePath()): Presence {
+  try {
+    const value: unknown = JSON.parse(readFileSync(path, 'utf8'));
+    if (!value || typeof value !== 'object') return { away: false };
+    const rec = value as Partial<Presence>;
+    return {
+      away: rec.away === true,
+      ...(typeof rec.since === 'string' ? { since: rec.since } : {}),
+      ...(typeof rec.by === 'string' ? { by: rec.by } : {}),
+    };
+  } catch { return { away: false }; }
+}
+
+export function writePresence(away: boolean, by: string, opts: { path?: string; now?: Date } = {}): Presence {
+  const path = opts.path ?? presencePath();
+  const presence: Presence = { away, since: (opts.now ?? new Date()).toISOString(), by };
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(presence)}\n`);
+  renameSync(tmp, path);
+  return presence;
+}