elanous 0.2.12 → 0.2.13

package/scripts/lecture-note/node.ts

@@ -0,0 +1,256 @@
+#!/usr/bin/env bun
+import { spawnSync } from 'node:child_process';
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, extname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+import { debug } from '../../src/debug/log.js';
+import { streamLLM } from '../../src/llm.js';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkGfm from 'remark-gfm';
+import remarkRehype from 'remark-rehype';
+import rehypeSanitize from 'rehype-sanitize';
+import rehypeStringify from 'rehype-stringify';
+
+export type Stage = 'collect' | 'draft' | 'render' | 'html' | 'pdf';
+export interface Input { name: string; kind: 'pdf' | 'image' | 'markdown'; text: string }
+export interface Counts { inputs: number; diagrams: number; rendered: number; html: 'yes' | 'no'; pdf: 'yes' | 'skipped' }
+export interface StageResult extends Counts { outcome: 'ok' | 'skipped' }
+export interface StageOptions {
+  llm?: (prompt: string) => Promise<string>;
+  toolsPath?: string;
+  referenceRoot?: string;
+}
+
+const ownRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../skills');
+const kinds: Record<string, Input['kind']> = {
+  '.pdf': 'pdf', '.md': 'markdown', '.png': 'image', '.jpg': 'image', '.jpeg': 'image', '.webp': 'image',
+};
+const mermaid = /^```mermaid\s*\n([\s\S]*?)^```\s*$/gm;
+const escapeHtml = (text: string) => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+
+function pathStatus(path: string): ReturnType<typeof lstatSync> | undefined {
+  try { return lstatSync(path); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return undefined;
+    throw error;
+  }
+}
+
+function outputDir(folder: string): string {
+  if (!lstatSync(folder).isDirectory()) throw new Error(`강의 폴더가 아니다: ${folder}`);
+  const dir = join(resolve(folder), 'lecture-note');
+  const status = pathStatus(dir);
+  if (status && (status.isSymbolicLink() || !status.isDirectory())) throw new Error('lecture-note 출력 폴더가 안전하지 않다');
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function artifact(dir: string, name: string): string {
+  const path = join(dir, name);
+  const status = pathStatus(path);
+  if (status && (status.isSymbolicLink() || !status.isFile())) throw new Error(`출력 파일이 안전하지 않다: ${path}`);
+  return path;
+}
+
+function binary(name: string, path = process.env.PATH ?? ''): string | undefined {
+  for (const part of path.split(':').filter(Boolean)) {
+    const at = join(part, name);
+    if (existsSync(at) && statSync(at).isFile()) return at;
+  }
+  return undefined;
+}
+
+function run(bin: string, args: string[], dir: string, timeout: number): ReturnType<typeof spawnSync> {
+  return spawnSync(bin, args, { cwd: dir, encoding: 'utf8', timeout, maxBuffer: 20 * 1024 * 1024,
+    env: { ...process.env, HOME: dir, XDG_CACHE_HOME: dir, XDG_CONFIG_HOME: dir, UV_CACHE_DIR: dir, PYTHONDONTWRITEBYTECODE: '1' } });
+}
+
+function readInputs(dir: string): Input[] {
+  const value: unknown = JSON.parse(readFileSync(join(dir, 'inputs.json'), 'utf8'));
+  if (!Array.isArray(value) || !value.every((item) => item && typeof item.name === 'string' && typeof item.kind === 'string' && typeof item.text === 'string')) {
+    throw new Error('inputs.json 형식 오류');
+  }
+  return value as Input[];
+}
+
+function counts(dir: string): Counts {
+  const inputs = existsSync(join(dir, 'inputs.json')) ? readInputs(dir).length : 0;
+  const notes = existsSync(join(dir, 'notes.md')) ? readFileSync(join(dir, 'notes.md'), 'utf8') : '';
+  const diagrams = [...notes.matchAll(mermaid)].length;
+  const rendered = [...Array(diagrams).keys()].filter(i => existsSync(join(dir, `diagram-${i + 1}.png`))).length;
+  return { inputs, diagrams, rendered, html: existsSync(join(dir, 'notes.html')) ? 'yes' : 'no', pdf: existsSync(join(dir, 'notes.pdf')) ? 'yes' : 'skipped' };
+}
+
+export function collect(folder: string, options: StageOptions = {}): StageResult {
+  const dir = outputDir(folder);
+  const files: Input[] = [];
+  const pdfText = binary('pdftotext', options.toolsPath);
+  const sources = resolve(folder, 'sources/common');
+  const scan = [{ base: folder, prefix: '' }, ...(pathStatus(sources)?.isDirectory() && !pathStatus(sources)?.isSymbolicLink()
+    ? [{ base: sources, prefix: 'sources/common/' }] : [])];
+  for (const { base, prefix } of scan) for (const entry of readdirSync(base, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const kind = kinds[extname(entry.name).toLowerCase()];
+    if (!entry.isFile() || !kind) continue;
+    const at = join(base, entry.name);
+    const text = kind === 'markdown' ? readFileSync(at, 'utf8') : kind === 'image' ? '이미지 — 시각 자료 (텍스트 추출 없음)' :
+      pdfText ? (() => {
+        const result = run(pdfText, ['-layout', at, '-'], dir, 60000);
+        return result.status === 0 ? String(result.stdout) : 'PDF 텍스트 없음 — pdftotext 추출 실패';
+      })() : 'PDF 텍스트 없음 — pdftotext 없음';
+    files.push({ name: prefix + entry.name, kind, text });
+  }
+  writeFileSync(artifact(dir, 'inputs.json'), JSON.stringify(files, null, 2) + '\n');
+  return { ...counts(dir), outcome: 'ok' };
+}
+
+const instructions = `강의 자료로 종합 디지털 강의 노트 Markdown만 작성하라.
+강의 진행 순서를 유지하고 손필기/슬라이드의 시각 정보와 요약의 텍스트를 통합하라. 읽지 못한 이미지는 추측하지 말고 출처를 표시하라.
+다이어그램은 Mermaid 우선으로 해당 설명 위치에 \`\`\`mermaid 코드블록으로 내장하라 (곡선·자유형은 코드로 억지 변환하지 않는다).
+비교·분류는 표로, 실제 사례는 별도 사례 박스로, 핵심 원칙은 인용문으로 표시하라.
+수식은 KaTeX 인라인 \\( ... \\) 형식, 강조 수식은 > \\( ... \\) 형식으로 쓰고 $$ 블록 수식이나 볼드/코드 수식은 쓰지 마라.
+강의 개요 바로 아래에 해당 주차 신규 용어집 표(| 약어 | 영문 | 한국어 | 정의 |)를 배치하라.
+목차와 각 헤딩 위의 영문 앵커를 만들고, 맨 끝에 다이어그램 목록 부록을 둬라. 근거 없는 내용은 만들어내지 마라.`;
+
+export async function draft(folder: string, options: StageOptions = {}): Promise<StageResult> {
+  const dir = outputDir(folder);
+  const inputs = readInputs(dir);
+  if (!inputs.length) throw new Error('강의 자료가 없다');
+  const prompt = `${instructions}\n\n자료:\n${inputs.map(i => `### ${i.name} (${i.kind})\n${i.text}`).join('\n\n')}`;
+  const ask = options.llm ?? ((request: string) => streamLLM([{ role: 'user', content: request }], () => {}));
+  const notes = (await ask(prompt)).trim();
+  if (!notes) throw new Error('LLM 초안이 비었다');
+  writeFileSync(artifact(dir, 'notes.md'), notes + '\n');
+  return { ...counts(dir), outcome: 'ok' };
+}
+
+export function render(folder: string, options: StageOptions = {}): StageResult {
+  const dir = outputDir(folder);
+  const notes = readFileSync(join(dir, 'notes.md'), 'utf8');
+  const renderer = join(options.referenceRoot ?? ownRoot, 'diagram-master/references/engines/mermaid/render_mermaid.py');
+  const uv = binary('uv', options.toolsPath);
+  let unavailable = 0;
+  for (const [i, match] of [...notes.matchAll(mermaid)].entries()) {
+    const png = artifact(dir, `diagram-${i + 1}.png`);
+    if (existsSync(png)) rmSync(png);
+    if (!uv || !existsSync(renderer)) { unavailable++; continue; }
+    const mmd = artifact(dir, `diagram-${i + 1}.mmd`);
+    writeFileSync(mmd, match[1]!);
+    const result = run(uv, ['run', 'python', renderer, mmd, '--output', png], dir, 120000);
+    if (result.status !== 0 || !existsSync(png)) {
+      if (existsSync(png)) rmSync(png);
+      throw new Error(`Mermaid 렌더 실패 (diagram-${i + 1}, exit=${result.status}): ${result.error?.message ?? result.stderr ?? result.stdout ?? 'PNG 없음'}`);
+    }
+  }
+  if (unavailable) console.log(`렌더러 없음: ${unavailable}`);
+  return { ...counts(dir), outcome: 'ok' };
+}
+
+function markdownHtml(text: string): string {
+  let suffix = 0;
+  while (text.includes(`LECTUREMATHOPEN${suffix}`) || text.includes(`LECTUREMATHCLOSE${suffix}`)) suffix++;
+  const open = `LECTUREMATHOPEN${suffix}`;
+  const close = `LECTUREMATHCLOSE${suffix}`;
+  const protectedText = text.replace(/\\\(/g, open).replace(/\\\)/g, close);
+  return String(unified().use(remarkParse).use(remarkGfm)
+    .use(remarkRehype).use(rehypeSanitize).use(rehypeStringify).processSync(protectedText))
+    .replaceAll(open, '\\(').replaceAll(close, '\\)');
+}
+
+export function html(folder: string, options: StageOptions = {}): StageResult {
+  const dir = outputDir(folder);
+  const notes = readFileSync(join(dir, 'notes.md'), 'utf8');
+  const template = readFileSync(join(options.referenceRoot ?? ownRoot, 'lecture-note-digitizer/references/html-template.md'), 'utf8');
+  const css = template.match(/```css\n([\s\S]*?)\n```/)?.[1];
+  if (!css) throw new Error('HTML 템플릿 CSS 없음');
+  let n = 0;
+  const withoutAppendix = notes.replace(/\n(?:---\n\n)?(?:<a id="appendix"><\/a>\n)?#+ 부록: 다이어그램 목록[\s\S]*$/u, '');
+  const anchored = withoutAppendix.replace(/^<a id="([a-zA-Z0-9-]+)"><\/a>$/gm, (_match, id: string) => `\n\nLECTURE_ANCHOR_${id}_END\n\n`);
+  const body = markdownHtml(anchored.replace(mermaid, (_block, source: string) => {
+    const png = `diagram-${++n}.png`;
+    return existsSync(join(dir, png)) ? `\n\n![diagram-${n}](${png})\n\n` : `\n\n\`\`\`mermaid\n${source}\`\`\`\n\n`;
+  })).replace(/<p><img src="(diagram-\d+\.png)" alt="(diagram-\d+)"><\/p>/g,
+    '<div class="diagram-container"><img src="$1" alt="$2"></div>')
+    .replace(/<p>LECTURE_ANCHOR_([a-zA-Z0-9-]+)_END<\/p>/g, '<a id="$1"></a>');
+  const title = notes.match(/^# (.+)$/m)?.[1] ?? '강의 노트';
+  const sections: string[] = [];
+  let heading = 0;
+  const numbered = body.replace(/<(h[12])>(.*?)<\/\1>/g, (_m, tag: string, label: string) => {
+    const id = `sec-${++heading}`;
+    sections.push(`<li><a href="#${id}">${label}</a></li>`);
+    return `<${tag} id="${id}">${label}</${tag}>`;
+  });
+  const page = `<!DOCTYPE html>\n<html lang="ko"><head><meta charset="UTF-8"><title>${escapeHtml(title)}</title>` +
+    '<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.11/dist/katex.min.css">' +
+    '<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.11/dist/katex.min.js"></script>' +
+    '<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.11/dist/contrib/auto-render.min.js" onload="renderMathInElement(document.body,{delimiters:[{left:\'\\\\(\',right:\'\\\\)\',display:false}]});"></script>' +
+    `<style>${css}</style></head><body><div class="cover"><h1>${escapeHtml(title)}</h1></div>` +
+    `<div class="toc"><h2>목차</h2><ol>${sections.join('\n')}</ol></div><div class="section">${numbered}</div></body></html>\n`;
+  writeFileSync(artifact(dir, 'notes.html'), page);
+  return { ...counts(dir), outcome: 'ok' };
+}
+
+export function pdf(folder: string, options: StageOptions = {}): StageResult {
+  const dir = outputDir(folder);
+  const source = artifact(dir, 'notes.html');
+  if (!existsSync(source)) throw new Error('notes.html 없음');
+  const converter = join(options.referenceRoot ?? ownRoot, 'lecture-note-digitizer/references/convert_to_pdf.py');
+  const python = binary('python3', options.toolsPath);
+  const target = artifact(dir, 'notes.pdf');
+  if (existsSync(target)) throw new Error('기존 notes.pdf 를 덮어쓰지 않는다');
+  const result = python && existsSync(converter) ? run(python, [converter, source], dir, 120000) : undefined;
+  const engineMissing = !result || (result.status !== 0 && !result.error &&
+    (/^ModuleNotFoundError: No module named ['"]playwright['"]$/m.test(String(result.stderr)) ||
+      /BrowserType\.launch: Executable doesn't exist at/.test(String(result.stderr))));
+  if (engineMissing) {
+    if (existsSync(target)) rmSync(target);
+    console.log('PDF 엔진 없음 — HTML 이 산출물');
+    return { ...counts(dir), pdf: 'skipped', outcome: 'skipped' };
+  }
+  if (result && (result.status !== 0 || !existsSync(target))) {
+    if (existsSync(target)) rmSync(target);
+    throw new Error(`PDF 변환 실패 (exit=${result.status}): ${result.error?.message ?? result.stderr ?? result.stdout ?? 'PDF 없음'}`);
+  }
+  return { ...counts(dir), outcome: 'ok' };
+}
+
+export async function runStage(stage: Stage, folder: string, options: StageOptions = {}): Promise<StageResult> {
+  const result = stage === 'collect' ? collect(folder, options) : stage === 'draft' ? await draft(folder, options) :
+    stage === 'render' ? render(folder, options) : stage === 'html' ? html(folder, options) : pdf(folder, options);
+  debug.log('lecture.note', stage, { inputs: result.inputs, diagrams: result.diagrams, rendered: result.rendered, pdf: result.pdf });
+  return result;
+}
+
+function folderFromContext(): string {
+  const arg = process.argv.indexOf('--folder');
+  if (arg >= 0) {
+    const folder = process.argv[arg + 1];
+    if (!folder) throw new Error('--folder 값 없음');
+    return resolve(folder.replace(/^~(?=\/)/, homedir()));
+  }
+  const context = process.env.ELANOUS_GRAPH_CONTEXT;
+  if (!context) throw new Error('input.folder 필요');
+  const data: unknown = JSON.parse(context.trim().startsWith('{') ? context : readFileSync(context, 'utf8'));
+  const folder = (data as { input?: { folder?: unknown } })?.input?.folder;
+  if (typeof folder !== 'string' || !folder.trim()) throw new Error('input.folder 필요');
+  const expanded = folder.replace(/^~(?=\/)/, homedir());
+  if (!isAbsolute(expanded)) throw new Error('input.folder 절대 경로 필요');
+  return resolve(expanded);
+}
+
+if (import.meta.main) {
+  const stage = process.argv[2];
+  if (!['collect', 'draft', 'render', 'html', 'pdf'].includes(stage ?? '')) throw new Error('stage: collect|draft|render|html|pdf');
+  let folder = '';
+  try {
+    folder = folderFromContext();
+    const result = await runStage(stage as Stage, folder);
+    console.log(`lecture-note ${folder} inputs=${result.inputs} diagrams=${result.diagrams} rendered=${result.rendered} html=${result.html} pdf=${result.pdf}`);
+    console.log(JSON.stringify({ outcome: result.outcome }));
+  } catch (error) {
+    console.error(error);
+    console.log(JSON.stringify({ outcome: 'fail', reason: error instanceof Error ? error.message : String(error) }));
+    process.exitCode = 1;
+  }
+}

package/scripts/release-loop/gate-node.ts

@@ -18,7 +18,7 @@ import { POD_BUN_CACHE_HOST_PATH, parseInstallSeconds, podBunCacheVolume } from
 import { PodPoolScheduler, parsePodPool, checkPodPool } from '../../src/task-orchestrator/surfaces/pod-pool.js';
 import { defaultKubectl } from '../../src/task-orchestrator/surfaces/self-implement-pod.js';
 
-interface CommandResult { rc: number; output: string; passedIds?: string[] }
+interface CommandResult { rc: number; output: string; passedIds?: string[]; stalledEnv?: Array<{ file: string; reason: 'no-output' }> }
 export interface GateRunner {
   command(cmd: string, args: string[], cwd: string): Promise<CommandResult>;
   localCommand(cmd: string, args: string[], cwd: string): Promise<CommandResult>;
@@ -50,6 +50,7 @@ export interface GateResult {
   fixed: number;
   knownEnv: number;
   knownEnvCleared: string[];
+  stalledEnv: Array<{ file: string; reason: 'no-output'; local: 'passed' | 'failed' }>;
   baselineSource?: 'ledger' | 'instance' | 'cut-logs' | 'swept';
   durationMs: number;
   error?: string;
@@ -322,13 +323,15 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
       const ran = clean && lastMatch(clean, /Ran (\d+) tests? across (\d+) files?/);
       const passes = clean === undefined ? NaN : summaryCount(clean, 'pass');
       const fails = clean === undefined ? NaN : summaryCount(clean, 'fail');
+      const errors = clean === undefined ? NaN : summaryCount(clean, 'error');
       let reason: ShardReason | undefined;
       let namedFailures: number | undefined;
       let unattributedDetail: string | undefined;
       if (jobFailed || (jobExitCode !== undefined && jobExitCode !== 0) || (rc !== undefined && rc !== 0 && rc !== 1)) reason = 'job-failed';
       else if (!clean || rc === undefined) reason = 'no-output';
       else if (!ran || !Number.isFinite(passes) || !Number.isFinite(fails)
-        || Number(ran[2]) === 0 || Number(ran[2]) > paths.length || Number(ran[1]) === 0) reason = 'incomplete';
+        || Number(ran[2]) === 0 || Number(ran[2]) > paths.length
+        || (Number(ran[1]) === 0 && !(errors > 0))) reason = 'incomplete';
       else {
         try {
           const attributed = failuresOf({ rc, output: clean }, `pod-${shard} shard`);
@@ -400,7 +403,7 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
         return { runs: children.flatMap((child) => child.runs), stalled: children.flatMap((child) => child.stalled) };
       }
       return { runs: [{ output: clean!, rc: rc!, pass: passes, fail: fails,
-        errors: Number.isNaN(summaryCount(clean!, 'error')) ? 0 : summaryCount(clean!, 'error'),
+        errors: Number.isNaN(errors) ? 0 : errors,
         ran: Number(ran![1]), files: Number(ran![2]), passedIds: junit ? junitPassedIds(junit) : [] }], stalled: [] };
     };
     // 모든 조각이 끝난 뒤 판정한다 — 한 조각의 예외로 먼저 돌아가면 다른 Pod 가 도는 채로 정리가 시작된다(#22002 리뷰 R3).
@@ -413,11 +416,12 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
     const total = measured.reduce((sum, run) => ({ pass: sum.pass + run.pass, fail: sum.fail + run.fail,
       errors: sum.errors + run.errors, ran: sum.ran + run.ran, files: sum.files + run.files }),
     { pass: 0, fail: 0, errors: 0, ran: 0, files: 0 });
-    if (stalledShards.length) throw new StalledPodShards(stalledShards, total);
-    if (total.ran === 0 && total.errors === 0) throw new Error('sweep incomplete: no tests ran');
+    if (stalledShards.some((item) => item.reason !== 'no-output' || item.files.length !== 1)) throw new StalledPodShards(stalledShards, total);
+    if (total.ran === 0 && total.errors === 0 && !stalledShards.length) throw new Error('sweep incomplete: no tests ran');
     const outputs = measured.map((run) => run.output.replace(/(?:^|\n)\s*\d+ (?:pass|fail|errors?)\s*(?=\n|$)/g, '\n').replace(/Ran \d+ tests? across \d+ files?\.?/g, ''));
     return { rc: total.fail + total.errors ? 1 : 0, output: outputs.join('\n') + `\n${total.pass} pass\n${total.fail} fail\n${total.errors} errors\nRan ${total.ran} tests across ${total.files} files.\n`,
-      passedIds: [...new Set(measured.flatMap((run) => run.passedIds))].sort() };
+      passedIds: [...new Set(measured.flatMap((run) => run.passedIds))].sort(),
+      stalledEnv: stalledShards.flatMap((item) => item.files.map((file) => ({ file, reason: 'no-output' as const }))) };
   };
   return {
     command,
@@ -550,7 +554,7 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     return baselineCommit(root, version);
   };
   const repo = resolve(opts.repo ?? process.cwd());
-  const result: GateResult = { outcome: 'error', commit: opts.commit, introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], durationMs: 0 };
+  const result: GateResult = { outcome: 'error', commit: opts.commit, introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], stalledEnv: [], durationMs: 0 };
   let work: string | undefined;
   let baseSnapshot = false;
   let cutFailures: SweepFailures | undefined;
@@ -601,7 +605,38 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     for (const dir of [cutTree, join(cutTree, 'apps/pwa')]) check(await runner.command('bun', ['install'], dir), `bun install ${dir}`);
     const cutRun = await runner.sweep(cutTree, join(root, 'release', opts.version, 'gate-logs', 'cut'),
       opts.pod ? { ...opts.pod, durationSource: join(ledger, 'release', opts.baselineVersion, 'gate-logs', 'cut') } : undefined);
-    const cut = failuresOf(cutRun, 'cut sweep');
+    const localStalled = async (run: CommandResult, tree: string, commit: string, label: string) => {
+      const stalled = run.stalledEnv ?? [];
+      const noCompletedShard = stalled.length && run.rc === 0
+        && /(?:^|\n)0 pass\n0 fail\n0 errors\nRan 0 tests across 0 files\./.test(run.output);
+      const measured: SweepFailures = noCompletedShard ? { failures: [], errors: [] } : failuresOf(run, `${label} sweep`);
+      if (!stalled.length) return measured;
+      let hostTree = tree;
+      const local: GateResult['stalledEnv'] = [];
+      try {
+        if (opts.remote) {
+          hostTree = join(mkdtempSync(join(tmpdir(), 'release-gate-local-')), 'cut');
+          check(await runner.localCommand('git', ['clone', '--quiet', '--shared', '--no-checkout', repo, hostTree], repo), 'host cut clone');
+          check(await runner.localCommand('git', ['checkout', '--quiet', '--detach', commit], hostTree), 'host cut checkout');
+          for (const dir of [hostTree, join(hostTree, 'apps/pwa')]) check(await runner.localCommand('bun', ['install'], dir), `host bun install ${dir}`);
+        }
+        for (const { file, reason } of stalled) {
+          if (!/^(?:[\w.-]+\/)+[\w.-]+\.test\.tsx?$/.test(file) || file.split('/').includes('..')) throw new Error(`unsafe test path: ${file}`);
+          const isolated = await runner.localCommand('bun', ['run', 'test:deterministic', asPath(file)], hostTree);
+          const parsed = failuresOf(isolated, `${label} host isolated ${file}`);
+          if ([...parsed.failures, ...parsed.errors].some((id) => fileOf(id) !== file)) throw new Error(`host isolated run attributed to another file: ${file}`);
+          measured.failures.push(...parsed.failures);
+          measured.errors.push(...parsed.errors);
+          local.push({ file, reason, local: parsed.failures.length || parsed.errors.length ? 'failed' : 'passed' });
+        }
+      } finally {
+        if (opts.remote && hostTree !== tree) rmSync(dirname(hostTree), { recursive: true, force: true });
+      }
+      result.stalledEnv.push(...local);
+      debug.log('release-loop.gate', 'pod-shard-stalled-env', { files: stalled.map(({ file, reason }) => ({ file, reason })), local });
+      return measured;
+    };
+    const cut = await localStalled(cutRun, cutTree, opts.commit, 'cut');
     cutFailures = cut;
     const baseSha = opts.baselineCommit ?? baselineReleaseCommit(opts.baselineVersion);
     const cached = cachedBaseline(opts.baselineVersion, baseSha);
@@ -630,22 +665,24 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
       // hour of local baseline after a 23-minute Pod cut).
       const baseRun = await runner.sweep(await getBaseTree(), join(root, 'release', opts.version, 'gate-logs', 'baseline'),
         opts.pod ? { ...opts.pod, durationSource: join(ledger, 'release', opts.baselineVersion, 'gate-logs', 'cut') } : undefined);
-      baseline = failuresOf(baseRun, 'baseline sweep');
+      baseline = await localStalled(baseRun, baseTree!, baseSha, 'baseline');
     }
     for (const id of [...baseline.failures, ...baseline.errors, ...cut.failures, ...cut.errors]) fileOf(id);
     const known = opts.pod ? loadEnvKnownFailures(repo) : new Set<string>();
     const cutIds = [...cut.failures, ...cut.errors];
+    const cutHostFailed = new Set(cutRun.stalledEnv?.map(({ file }) => file) ?? []);
     const baselineIds = [...baseline.failures, ...baseline.errors];
     const countedCut = splitKnownEnv(cutIds, known);
     const countedBaseline = splitKnownEnv(baselineIds, known);
     result.knownEnv = countedCut.knownEnv.length;
-    result.knownEnvCleared = [...new Set(cutRun.passedIds ?? [])].filter((id) => known.has(id) && !cutIds.includes(id)).sort();
+    result.knownEnvCleared = [...new Set(cutRun.passedIds ?? [])].filter((id) => known.has(id) && !cutIds.includes(id) && !cutRun.stalledEnv?.some(({ file }) => fileOf(id) === file)).sort();
     const diff = diffFailures(countedCut.counted, countedBaseline.counted);
     result.fixed = diff.fixed.length;
     result.preexisting = diff.common.length;
     for (const file of new Set(diff.newFailures.map(fileOf))) {
-      const isolated = await runner.command('bun', ['run', 'test:deterministic', asPath(file)], cutTree);
-      const isolatedCut = failuresOf(isolated, `cut isolated ${file}`);
+      const isolatedCut = cutHostFailed.has(file)
+        ? { failures: cut.failures.filter((id) => fileOf(id) === file), errors: cut.errors.filter((id) => fileOf(id) === file) }
+        : failuresOf(await runner.command('bun', ['run', 'test:deterministic', asPath(file)], cutTree), `cut isolated ${file}`);
       const reproduced = new Set([...isolatedCut.failures, ...isolatedCut.errors]);
       const candidates = diff.newFailures.filter((id) => fileOf(id) === file && reproduced.has(id));
       if (candidates.length === 0) continue;
@@ -690,7 +727,7 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     if (opts.remote) runner.remoteMirror = undefined;
     result.durationMs = Date.now() - start;
   }
-  if (cutFailures && !result.stalledShards?.length) {
+  if (cutFailures && !result.stalledShards?.length && !result.stalledEnv.length) {
     try {
       for (const location of roots) {
         const path = failureFile(location, opts.version);
@@ -714,7 +751,8 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
 export function graphGateResult(result: GateResult, graph: boolean) {
   return { ...result, ...(graph && result.outcome === 'regression' ? { outcome: 'fail' as const } : {}),
     verdict: result.outcome === 'ok' ? 'pass' as const : 'fail' as const,
-    summary: (result.outcome === 'ok' ? `새 회귀 ${result.introduced.length} · 기존 ${result.preexisting} · 고침 ${result.fixed}` : `게이트 ${result.outcome}: ${result.error ?? result.introduced.length + ' new regressions'}`) + ` · 환경 알려진 실패 ${result.knownEnv}` };
+    summary: (result.outcome === 'ok' ? `새 회귀 ${result.introduced.length} · 기존 ${result.preexisting} · 고침 ${result.fixed}` : `게이트 ${result.outcome}: ${result.error ?? result.introduced.length + ' new regressions'}`) + ` · 환경 알려진 실패 ${result.knownEnv}`
+      + (result.stalledEnv.length ? ` · 환경 멈춤 ${result.stalledEnv.length} (Pod 밖 통과 ${result.stalledEnv.filter((item) => item.local === 'passed').length})` : '') };
 }
 
 export function parseOptions(args: string[], env: NodeJS.ProcessEnv): GateOptions | 'help' {
@@ -772,7 +810,7 @@ if (import.meta.main) {
     version = opts.version;
     result = await judgeGate(opts);
   } catch (error) {
-    result = { outcome: 'error', commit: '', introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], durationMs: Date.now() - start, error: String(error) };
+    result = { outcome: 'error', commit: '', introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], stalledEnv: [], durationMs: Date.now() - start, error: String(error) };
   }
   if (result.error) console.error(result.error);
   debug.log('release-loop.gate', 'result', { version, outcome: result.outcome });

package/scripts/release-loop/ops-upgrade-node.ts

@@ -7,7 +7,7 @@ import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runC
 
 interface HostResult { host: string; ok: boolean; before: string; after: string; error?: string; skipped?: string; hooks?: string; restart?: 'no-service' }
 /** Where the internal feed is packed from: a checkout of the release tag, never the run's working tree. */
-export interface FeedSource { checkout: string; commit: string; cleanup: () => void }
+export interface FeedSource { checkout: string; commit: string; deps: 'linked' | 'installed'; cleanup: () => void }
 interface OpsUpgradeDeps { exists?: (path: string) => boolean; installSource?: () => string | null; feedSource?: (version: string) => FeedSource }
 
 /** Detached worktree at refs/tags/v<version> with the PWA built — the feed ships what was released (10-04 0.2.11:
@@ -26,16 +26,28 @@ export function tagFeedSource(run: CommandRunner, repo: string = process.cwd()):
     try {
       const added = run('git', ['worktree', 'add', '--detach', tree, commit], repo);
       if (added.status !== 0) throw new Error(`태그 체크아웃 실패: ${reason(added)}`);
-      symlinkSync(join(repo, 'node_modules'), join(tree, 'node_modules'));
-      if (existsSync(join(repo, 'apps/pwa/node_modules'))) symlinkSync(join(repo, 'apps/pwa/node_modules'), join(tree, 'apps/pwa/node_modules'));
+      const sameDeps = ['bun.lock', 'apps/pwa/bun.lock', 'package.json', 'apps/pwa/package.json'].every((file) => {
+        try { return readFileSync(join(repo, file), 'utf8') === readFileSync(join(tree, file), 'utf8'); }
+        catch { return false; }
+      });
+      const deps: FeedSource['deps'] = sameDeps ? 'linked' : 'installed';
+      if (sameDeps) {
+        symlinkSync(join(repo, 'node_modules'), join(tree, 'node_modules'));
+        if (existsSync(join(repo, 'apps/pwa/node_modules'))) symlinkSync(join(repo, 'apps/pwa/node_modules'), join(tree, 'apps/pwa/node_modules'));
+      } else {
+        for (const cwd of [tree, join(tree, 'apps/pwa')]) {
+          const installed = run('bun', ['install', '--frozen-lockfile'], cwd, 900_000);
+          if (installed.status !== 0) throw new Error(`태그 의존성 설치 실패: ${reason(installed)}`);
+        }
+      }
       // The feed carries the PWA build (apps/pwa/out is ignored, so a fresh tag checkout has none until built).
       const built = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], tree, 900_000);
       if (built.status !== 0) throw new Error(`태그 PWA 빌드 실패: ${reason(built)}`);
+      return { checkout: tree, commit, deps, cleanup };
     } catch (error) {
       cleanup();
       throw error;
     }
-    return { checkout: tree, commit, cleanup };
   };
 }
 
@@ -96,7 +108,7 @@ export function runOpsUpgrade(run: CommandRunner = runCommand, deps: OpsUpgradeD
         const data = lastResult(feed);
         if (feed.status !== 0 || data?.ok !== true || data.version !== version) feedError = `내부 피드 발행 실패: ${feed.status === 0 && data?.ok === true ? `판 불일치 (${String(data.version)})` : reason(feed)}`;
         else if (data.commit !== source.commit) feedError = `내부 피드 발행 실패: 묶은 커밋 ${String(data.commit).slice(0, 12)} ≠ 태그 ${source.commit.slice(0, 12)}`;
-        debug.log('release-loop.ops-upgrade', 'feed-source', { version, commit: source.commit, source: `refs/tags/v${version}`, packed: data?.commit, pwaBuild: data?.pwaBuild });
+        debug.log('release-loop.ops-upgrade', 'feed-source', { version, commit: source.commit, source: `refs/tags/v${version}`, deps: source.deps, packed: data?.commit, pwaBuild: data?.pwaBuild });
       }
     } catch (error) { feedError = `내부 피드 발행 실패: ${firstLine(String(error))}`; }
     finally { source?.cleanup(); }

package/scripts/test-deterministic.ts

@@ -31,8 +31,9 @@
 //     reports the failure.
 
 import { mkdtempSync, rmSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 // The predicate lives in its own side-effect-free module so it can be tested:
 // importing THIS file used to spawn the suite at load time. The runner is now
 // behind `import.meta.main` / `runDeterministicTests()`, but the filter stays
@@ -56,6 +57,8 @@ 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;
+
 const EXECUTION_ORIGIN_ENV_KEYS = [
   'ELANOUS_HOST_ID',
   'ELANOUS_RUN_ID',
@@ -120,6 +123,7 @@ export type DeterministicRunnerDeps = {
   childGraceMs?: number;
   killProcessGroup?: KillProcessGroup;
   getProcessGroupId?: GetProcessGroupId;
+  gitConfig?: (cwd: string, args: string[]) => string;
 };
 
 export function isLivePid(pid: number): boolean {
@@ -269,11 +273,22 @@ export async function terminateDirectChild(
   reportVisible(`failed to terminate child pid=${pid}`, report);
 }
 
+function gitConfig(cwd: string, args: string[]): string {
+  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();
+}
+
 export function prepareIsolatedTestEnv(sourceEnv: NodeJS.ProcessEnv, testRoot: string): NodeJS.ProcessEnv {
   const env = Object.fromEntries(
     Object.entries(sourceEnv).filter(([key]) => !isCredentialKey(key)
       && !HARNESS_TEST_ENV_KEYS.includes(key as typeof HARNESS_TEST_ENV_KEYS[number])
-      && !EXECUTION_ORIGIN_ENV_KEYS.includes(key as typeof EXECUTION_ORIGIN_ENV_KEYS[number])),
+      && !EXECUTION_ORIGIN_ENV_KEYS.includes(key as typeof EXECUTION_ORIGIN_ENV_KEYS[number])
+      && !GIT_LOCATION_ENV_KEYS.includes(key as typeof GIT_LOCATION_ENV_KEYS[number])),
   );
   env.HOME = testRoot;
   // userConfigPath() warns whenever XDG_CONFIG_HOME is set, including when
@@ -392,6 +407,38 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
   const report = deps.report ?? console.error;
   const spawn = deps.spawn ?? defaultSpawn;
   const argv = deps.argv ?? process.argv.slice(2);
+  const cwd = deps.cwd ?? process.cwd();
+  const config = deps.gitConfig ?? gitConfig;
+  const commonDir = config(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  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 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)}`);
+    }
+  };
   // ⛔ 사람이 «경로»를 직접 준 창에서는 아무것도 빼지 않는다 — 그 창은 「이것만 돌려라」다.
   const explicitPaths = argv.some((arg) => !arg.startsWith('-'));
   const cdpPatterns = explicitPaths ? [] : (deps.deriveCdpPatterns ?? deriveCdpTestPatterns)();
@@ -451,6 +498,7 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
       });
       cleanupTemporaryRoot(testRoot, { rmSync: deps.rmSync, report });
       rootCleanupAttempted = true;
+      checkBare();
       gate?.dispose();
       gate = undefined;
       if (deps.killSelf) {
@@ -465,7 +513,8 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
     }
 
     cleanupRoot();
-    return outcome.code ?? 1;
+    checkBare();
+    return bareChanged ? 1 : (outcome.code ?? 1);
   } catch (error) {
     if (child) {
       try {
@@ -484,6 +533,7 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
   } finally {
     gate?.dispose();
     cleanupRoot();
+    if (!bareChecked) checkBare();
   }
 }