elanous 0.2.17 → 0.2.18

package/scripts/skills/public-check.ts

@@ -1,13 +1,14 @@
 #!/usr/bin/env bun
-/** Static readiness inventory for the public (core) skills; never executes a skill. */
-import { existsSync, lstatSync, readdirSync, readFileSync } from 'node:fs';
-import { join, relative } from 'node:path';
+/** Public (core) skill readiness inventory; optional builds never execute a skill. */
+import { cpSync, existsSync, lstatSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, isAbsolute, join, relative, sep, win32 } from 'node:path';
 import { computeSkillBoundaries, type SkillBoundaryReport } from '../skill-boundary.js';
 
 export type PublicCheckKey = 'header' | 'entry' | 'free' | 'portable' | 'install';
 export interface PublicSkillRow {
   readonly skill: string;
-  readonly checks: Readonly<Record<PublicCheckKey, boolean | 'N/A'>>;
+  readonly checks: Readonly<Record<PublicCheckKey, boolean | 'N/A'> & { build?: SkillBuildResult }>;
   readonly violations: readonly string[];
 }
 export interface PublicCheckReport {
@@ -68,6 +69,44 @@ function executableEntries(files: readonly string[], dir: string, docs: string):
     && (commanded.has(file) || file.startsWith('bin/') || ENTRY_NAME.test(file)));
 }
 
+export type SkillBuildResult = 'OK' | 'FAIL' | 'N/A';
+
+/** Build only selected TS/JS entries from an isolated skill copy, never from the repository. */
+export function buildSkillEntries(
+  dir: string,
+  entries: readonly string[],
+  run: (args: string[], cwd: string) => boolean = (args, cwd) => Bun.spawnSync(args, {
+    cwd, stdout: 'ignore', stderr: 'ignore',
+  }).exitCode === 0,
+): SkillBuildResult {
+  const buildable = entries.filter((entry) => /\.(?:ts|tsx|js|mjs|cjs)$/iu.test(entry));
+  if (buildable.length === 0) return 'N/A';
+  if (buildable.some((entry) => isAbsolute(entry) || win32.isAbsolute(entry) || entry.split(/[\\/]/u).includes('..'))) return 'FAIL';
+  const temp = mkdtempSync(join(tmpdir(), 'skill-public-build-'));
+  try {
+    const skill = join(temp, 'skill');
+    cpSync(dir, skill, {
+      recursive: true,
+      filter: (source) => source === dir || !['.git', 'node_modules', '__pycache__'].includes(basename(source)) && !lstatSync(source).isSymbolicLink(),
+    });
+    const copiedRoot = realpathSync(skill);
+    for (const entry of buildable) {
+      const target = realpathSync(join(skill, entry));
+      const inside = relative(copiedRoot, target);
+      if (inside === '..' || inside.startsWith(`..${sep}`) || isAbsolute(inside) || !lstatSync(target).isFile()) return 'FAIL';
+    }
+    if (existsSync(join(skill, 'package.json')) && !run(['bun', 'install', '--ignore-scripts'], skill)) return 'FAIL';
+    for (const [index, entry] of buildable.entries()) {
+      if (!run(['bun', 'build', entry, '--target=bun', '--outfile', join(temp, `entry-${index}.js`)], skill)) return 'FAIL';
+    }
+    return 'OK';
+  } catch {
+    return 'FAIL';
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}
+
 function freeValid(doc: string, entries: ReadonlySet<string>): boolean {
   const section = /(?:^|\n)#{1,4}\s*[^\n]*(?:무료|free)[^\n]*\n([\s\S]*?)(?=\n#{1,4}\s|$)/giu;
   for (const match of doc.matchAll(section)) {
@@ -97,7 +136,7 @@ function installValid(doc: string, dir: string): boolean {
 }
 
 /** `boundary` is injectable for pure fixture tests; production always derives it from the repository. */
-export function checkPublicSkills(root: string, boundary: SkillBoundaryReport = computeSkillBoundaries(root)): PublicCheckReport {
+export function checkPublicSkills(root: string, boundary: SkillBoundaryReport = computeSkillBoundaries(root), build = false): PublicCheckReport {
   const errors = [...boundary.errors];
   const skills: PublicSkillRow[] = [];
   const skillsDir = join(root, 'skills');
@@ -133,6 +172,7 @@ export function checkPublicSkills(root: string, boundary: SkillBoundaryReport =
       free: freeValid(docs, entries),
       portable: matches.length === 0,
       install: installValid(docs, dir),
+      ...(build ? { build: buildSkillEntries(dir, [...entries]) } : {}),
     };
     const violations = [
       ...(!checks.header ? ['SKILL.md 머리(name·description) 없음/불일치'] : []),
@@ -140,6 +180,7 @@ export function checkPublicSkills(root: string, boundary: SkillBoundaryReport =
       ...(!checks.free ? ['키/.env 없이 쓰는 무료 경로가 문서에 없음'] : []),
       ...matches.map((file) => `${file}: 개인 경로/내부 표지 문자열`),
       ...(!checks.install ? ['의존 manifest와 문서의 한 줄 설치 명령이 없음'] : []),
+      ...(checks.build === 'FAIL' ? ['스킬 실행 파일 빌드 실패'] : []),
     ];
     skills.push({ skill, checks, violations });
   }
@@ -147,23 +188,32 @@ export function checkPublicSkills(root: string, boundary: SkillBoundaryReport =
 }
 
 export function formatPublicCheck(report: PublicCheckReport): string {
-  const columns: PublicCheckKey[] = ['header', 'entry', 'free', 'portable', 'install'];
+  const columns: (PublicCheckKey | 'build')[] = ['header', 'entry', 'free', 'portable', 'install'];
+  if (report.skills.some((row) => row.checks.build !== undefined)) columns.push('build');
   return [
     `skill                              ${columns.map((key) => key.padEnd(9)).join(' ')} result`,
-    ...report.skills.map((row) => `${row.skill.padEnd(34)} ${columns.map((key) => (row.checks[key] === 'N/A' ? 'N/A' : row.checks[key] ? 'OK' : 'FAIL').padEnd(9)).join(' ')} ${row.violations.length ? row.violations.join('; ') : 'OK'}`),
+    ...report.skills.map((row) => `${row.skill.padEnd(34)} ${columns.map((key) => { const value = row.checks[key]; return (typeof value === 'string' ? value : value ? 'OK' : 'FAIL').padEnd(9); }).join(' ')} ${row.violations.length ? row.violations.join('; ') : 'OK'}`),
     ...report.errors.map((error) => `ERROR ${error}`),
     `PUBLIC-CHECK ${report.ok ? 'PASS' : 'FAIL'} (${report.skills.length} public skills)`,
   ].join('\n');
 }
 
+export function runPublicCheck(root: string, args: readonly string[], boundary?: SkillBoundaryReport): { output: string; exitCode: number } {
+  const report = checkPublicSkills(root, boundary, args.includes('--build'));
+  return {
+    output: args.includes('--json') ? JSON.stringify(report, null, 2) : formatPublicCheck(report),
+    exitCode: report.ok ? 0 : 1,
+  };
+}
+
 if (import.meta.main) {
   const args = process.argv.slice(2);
-  if (args.some((arg) => arg !== '--json')) {
-    console.error('Usage: bun scripts/skills/public-check.ts [--json]');
+  if (args.some((arg) => arg !== '--json' && arg !== '--build')) {
+    console.error('Usage: bun scripts/skills/public-check.ts [--json] [--build]');
     process.exitCode = 2;
   } else {
-    const report = checkPublicSkills(join(import.meta.dir, '..', '..'));
-    console.log(args.includes('--json') ? JSON.stringify(report, null, 2) : formatPublicCheck(report));
-    if (!report.ok) process.exitCode = 1;
+    const result = runPublicCheck(join(import.meta.dir, '..', '..'), args);
+    console.log(result.output);
+    process.exitCode = result.exitCode;
   }
 }

package/scripts/test-deterministic.ts

@@ -57,7 +57,10 @@ const HARNESS_TEST_ENV_KEYS = [
 // Discovery: rg -n "process\.env\.ELANOUS_(HOST|RUN|ORIGIN|SUPERVISOR|PARENT)" src
 // These are ambient execution identities, not inputs to a deterministic test.
 // debug.log also attributes SUBSTRATE and ARM_ID to every plain-object record.
-const GIT_LOCATION_ENV_KEYS = ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR'] as const;
+export const GIT_LOCATION_ENV_KEYS = [
+  'GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR', 'GIT_INDEX_FILE',
+  'GIT_OBJECT_DIRECTORY', 'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+] as const;
 
 const EXECUTION_ORIGIN_ENV_KEYS = [
   'ELANOUS_HOST_ID',
@@ -123,7 +126,7 @@ export type DeterministicRunnerDeps = {
   childGraceMs?: number;
   killProcessGroup?: KillProcessGroup;
   getProcessGroupId?: GetProcessGroupId;
-  gitConfig?: (cwd: string, args: string[]) => string;
+  gitConfig?: (cwd: string, args: string[]) => string | undefined;
 };
 
 export function isLivePid(pid: number): boolean {
@@ -273,14 +276,17 @@ export async function terminateDirectChild(
   reportVisible(`failed to terminate child pid=${pid}`, report);
 }
 
-function gitConfig(cwd: string, args: string[]): string {
+function gitConfig(cwd: string, args: string[]): string | undefined {
   const env = { ...process.env };
   for (const key of GIT_LOCATION_ENV_KEYS) delete env[key];
   const result = spawnSync('git', args, { cwd, env, encoding: 'utf8' });
   if (result.error || (result.status !== 0 && !(result.status === 1 && args.includes('--get-all') && !result.stderr))) {
     throw new Error(`git ${args.join(' ')} failed: ${result.error?.message ?? result.stderr}`);
   }
-  return result.stdout.trim();
+  if (result.status === 1) return undefined;
+  // --null --get-all terminates each complete value with NUL, even when
+  // a value itself contains newlines or is empty.
+  return args.includes('--get-all') ? result.stdout : result.stdout.trim();
 }
 
 export function prepareIsolatedTestEnv(sourceEnv: NodeJS.ProcessEnv, testRoot: string): NodeJS.ProcessEnv {
@@ -406,33 +412,45 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
   const cwd = deps.cwd ?? process.cwd();
   const config = deps.gitConfig ?? gitConfig;
   const commonDir = config(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  if (commonDir === undefined) throw new Error('git common directory is unset');
   const configFile = join(resolve(cwd, commonDir), 'config');
-  const bareArgs = ['config', '--file', configFile];
-  const readBare = () => config(cwd, [...bareArgs, '--get-all', 'core.bare']);
-  const bareBefore = readBare();
-  let bareChanged = false;
-  let bareChecked = false;
-  const checkBare = (): void => {
-    bareChecked = true;
-    let bareAfter = '<unreadable>';
-    const visible = (values: string) => values ? values.replaceAll('\n', ',') : '<unset>';
-    try {
-      bareAfter = readBare();
-      if (bareAfter === bareBefore) return;
-      bareChanged = true;
-      const originalValues = bareBefore ? bareBefore.split('\n') : [];
-      if (originalValues.length > 0) {
-        config(cwd, [...bareArgs, '--replace-all', 'core.bare', originalValues[0]!]);
-        for (const value of originalValues.slice(1)) config(cwd, [...bareArgs, '--add', 'core.bare', value]);
-      } else if (bareAfter) {
-        config(cwd, [...bareArgs, '--unset-all', 'core.bare']);
+  const configArgs = ['config', '--file', configFile];
+  const watchedKeys = ['core.bare', 'user.name', 'user.email'] as const;
+  // Legacy injected gitConfig fixtures supply newline-delimited results and
+  // return '' for an absent key. Real Git uses NUL-delimited complete values.
+  const readConfig = (key: string): string[] => {
+    const value = config(cwd, [...configArgs, '--null', '--get-all', key]);
+    if (value === undefined || (deps.gitConfig && value === '')) return [];
+    if (deps.gitConfig && !value.includes('\0')) return value.split('\n');
+    if (!value.endsWith('\0')) throw new Error(`unterminated git config value for ${key}`);
+    return value.slice(0, -1).split('\0');
+  };
+  const before = new Map(watchedKeys.map((key) => [key, readConfig(key)]));
+  let configChanged = false;
+  let configChecked = false;
+  const checkConfig = (): void => {
+    configChecked = true;
+    const visible = (values: string[]) => values.length === 0 ? '<unset>' : values.map((value) => value === '' ? '<empty>' : value.replaceAll('\n', ',')).join(',');
+    for (const key of watchedKeys) {
+      const original = before.get(key)!;
+      let after: string[] = ['<unreadable>'];
+      try {
+        after = readConfig(key);
+        if (JSON.stringify(after) === JSON.stringify(original)) continue;
+        configChanged = true;
+        if (original.length > 0) {
+          config(cwd, [...configArgs, '--replace-all', key, original[0]!]);
+          for (const value of original.slice(1)) config(cwd, [...configArgs, '--add', key, value]);
+        } else {
+          config(cwd, [...configArgs, '--unset-all', key]);
+        }
+        const restored = readConfig(key);
+        if (JSON.stringify(restored) !== JSON.stringify(original)) throw new Error(`expected ${visible(original)}, got ${visible(restored)}`);
+        report(`[test-deterministic] ${key} changed ${visible(original)} -> ${visible(after)}; restored ${visible(original)}; failing run`);
+      } catch (error) {
+        configChanged = true;
+        report(`[test-deterministic] ${key} changed ${visible(original)} -> ${visible(after)}; restore failed: ${formatError(error)}`);
       }
-      const restored = readBare();
-      if (restored !== bareBefore) throw new Error(`expected ${visible(bareBefore)}, got ${visible(restored)}`);
-      report(`[test-deterministic] core.bare changed ${visible(bareBefore)} -> ${visible(bareAfter)}; restored ${visible(bareBefore)}; failing run`);
-    } catch (error) {
-      bareChanged = true;
-      report(`[test-deterministic] core.bare changed ${visible(bareBefore)} -> ${visible(bareAfter)}; restore failed: ${formatError(error)}`);
     }
   };
   // ⛔ 사람이 «경로»를 직접 준 창에서는 아무것도 빼지 않는다 — 그 창은 「이것만 돌려라」다.
@@ -494,7 +512,7 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
       });
       cleanupTemporaryRoot(testRoot, { rmSync: deps.rmSync, report });
       rootCleanupAttempted = true;
-      checkBare();
+      checkConfig();
       gate?.dispose();
       gate = undefined;
       if (deps.killSelf) {
@@ -509,8 +527,8 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
     }
 
     cleanupRoot();
-    checkBare();
-    return bareChanged ? 1 : (outcome.code ?? 1);
+    checkConfig();
+    return configChanged ? 1 : (outcome.code ?? 1);
   } catch (error) {
     if (child) {
       try {
@@ -529,7 +547,7 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
   } finally {
     gate?.dispose();
     cleanupRoot();
-    if (!bareChecked) checkBare();
+    if (!configChecked) checkConfig();
   }
 }
 

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/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 {
       /* 한쪽 판이 없는 충돌(삭제·추가) — 크기 비교 대상이 아니다 */