elanous 0.2.11 → 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/lib/telegram-inject-args.ts

@@ -0,0 +1,31 @@
+import { existsSync } from 'node:fs';
+
+export function parseInjectArgs(
+  argv: string[],
+  env: { TELEGRAM_TEST_BOT?: string | undefined },
+): { to: string; text?: string; photos: string[]; caption?: string } {
+  const value = (flag: string): string | undefined => {
+    const index = argv.indexOf(flag);
+    if (index < 0) return undefined;
+    const next = argv[index + 1];
+    if (!next || next.startsWith('--')) throw new Error(`옵션 값 없음: ${flag}`);
+    return next;
+  };
+  const to = value('--to') ?? env.TELEGRAM_TEST_BOT;
+  const text = value('--text');
+  const photos: string[] = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] !== '--photo') continue;
+    const photo = argv[++i];
+    if (!photo || photo.startsWith('--') || !existsSync(photo)) {
+      throw new Error(`사진 파일 경로 없음: ${photo ?? '(미지정)'}`);
+    }
+    photos.push(photo);
+  }
+  if (!to || (!text && photos.length === 0)) {
+    throw new Error('사용: telegram-inject.ts --to @monad_test_bot --text "<objective>"');
+  }
+  return photos.length > 0
+    ? { to, photos, ...(text !== undefined ? { caption: text } : {}) }
+    : { to, text, photos };
+}

package/scripts/measure-pod-memory-by-goal.ts

@@ -0,0 +1,130 @@
+#!/usr/bin/env bun
+/** Seven-day read-only measurement of self-implement Pod memory by goal kind. */
+import { existsSync } from 'node:fs';
+import { LogStore, logsDbPath, type LogStoreRow } from '../src/mss/logging/log-store.js';
+
+export const GOAL_TYPES = ['test', 'code', 'pwa-build', 'docs'] as const;
+export type GoalType = typeof GOAL_TYPES[number];
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const MIB = 1024 * 1024;
+
+type Observation = Pick<LogStoreRow, 'ts_ms' | 'event' | 'data' | 'category'>;
+type Run = { type: GoalType | null; limit: string | null; peakMiB: number | null; samples: number; terminated: boolean; oomKilled: boolean };
+type MemorySample = { cgroupBytes?: unknown };
+export type MemoryMeasurement = {
+  window: { since: string; until: string };
+  sources: { logs: string; observations: number; samples: number; unclassifiedRuns: number; classification: 'goal-fields-or-space-id'; peakCoverage: 'recorded-samples-only' };
+  byGoalType: Array<{ goalType: GoalType; runs: number; measured: number; missingPeak: number; samples: number; memoryLimits: Record<string, number>; terminations: number; oomKilled: number; peakMiB: { p50: number | null; p95: number | null; max: number | null } }>;
+};
+
+function payload(raw: string | null): Record<string, unknown> {
+  try {
+    const parsed: unknown = JSON.parse(raw ?? 'null');
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+  } catch { return {}; }
+}
+
+/** Infer only unambiguous kinds from free text; never turn an unknown title into code. */
+export function goalTypeOf(description: string): GoalType | null {
+  const kinds: GoalType[] = [];
+  if (/\b(?:pwa|next\.js|frontend|front-end|web app)[-\s]+(?:build|compile|typecheck|bundle)\b/i.test(description)) kinds.push('pwa-build');
+  if (/\b(?:test|tests|testing|spec|coverage|gate)\b/i.test(description) || /시험|테스트|검증/.test(description)) kinds.push('test');
+  if (/\b(?:docs?|documentation|readme|manual|report)\b/i.test(description) || /문서|보고서/.test(description)) kinds.push('docs');
+  if (/\b(?:implement|implementation|coding|code|cli)\b/i.test(description) || /구현|코드/.test(description)) kinds.push('code');
+  return kinds.length === 1 ? kinds[0]! : null;
+}
+
+function recordedGoalType(data: Record<string, unknown>, spaceId: string): GoalType | null {
+  if ('goalType' in data) return GOAL_TYPES.find((type) => type === data.goalType) ?? null;
+  if ('goalKind' in data) return GOAL_TYPES.find((type) => type === data.goalKind) ?? null;
+  const descriptions = [data.goalTitle, data.goalDescription, data.feature].filter((value): value is string => typeof value === 'string' && value.trim().length > 0);
+  return descriptions.length ? goalTypeOf(descriptions.join(' ')) : goalTypeOf(spaceId);
+}
+
+function percentile(sorted: readonly number[], fraction: number): number | null {
+  if (!sorted.length) return null;
+  const index = (sorted.length - 1) * fraction;
+  const low = Math.floor(index);
+  return Math.round((sorted[low]! + (sorted[Math.ceil(index)]! - sorted[low]!) * (index - low)) * 100) / 100;
+}
+
+/** All rows are read before aggregation: log query's default 100-row limit is not a seven-day census. */
+export function measurePodMemoryByGoal(rows: readonly Observation[], nowMs: number = Date.now(), logs = logsDbPath()): MemoryMeasurement {
+  const sinceMs = nowMs - WEEK_MS;
+  const windowRows = rows.filter((row) => row.ts_ms >= sinceMs && row.ts_ms <= nowMs && row.category === 'self-implement.pod');
+  const runs = new Map<string, Run>();
+  const jobToSpace = new Map<string, string>();
+  let samples = 0;
+  const ordered = [...windowRows].sort((a, b) => a.ts_ms - b.ts_ms);
+  for (const row of ordered) {
+    if (row.event !== 'memory-limit') continue;
+    const data = payload(row.data);
+    const id = typeof data.spaceId === 'string' ? data.spaceId : '';
+    if (!id) continue;
+    runs.set(id, { type: recordedGoalType(data, id), limit: typeof data.memoryLimit === 'string' ? data.memoryLimit : null,
+      peakMiB: null, samples: 0, terminated: false, oomKilled: false });
+  }
+  for (const row of ordered) {
+    const data = payload(row.data);
+    const job = typeof data.job === 'string' ? data.job : '';
+    const directId = typeof data.spaceId === 'string' ? data.spaceId : '';
+    if (row.event === 'job-applied' && job && runs.has(directId)) jobToSpace.set(job, directId);
+    const run = runs.get(directId || jobToSpace.get(job) || '');
+    if (!run) continue;
+    if (row.event === 'job-finished') {
+      run.terminated = true;
+      run.oomKilled ||= data.containerReason === 'OOMKilled';
+    }
+    if (row.event === 'oom-evidence') { run.terminated = true; run.oomKilled = true; }
+    if (data.reason === 'OOMKilled') { run.terminated = true; run.oomKilled = true; }
+    if (row.event !== 'oom-evidence' && row.event !== 'memory-last') continue;
+    const rawSamples: unknown[] = row.event === 'oom-evidence' && Array.isArray(data.samples) ? data.samples : [data.sample];
+    for (const raw of rawSamples) {
+      const record = raw && typeof raw === 'object' ? raw as MemorySample : {};
+      const bytes = record.cgroupBytes;
+      if (typeof bytes !== 'number' || !Number.isSafeInteger(bytes) || bytes < 0) continue;
+      const reading = bytes / MIB;
+      run.peakMiB = Math.max(run.peakMiB ?? 0, reading);
+      run.samples++;
+      samples++;
+    }
+  }
+  return {
+    window: { since: new Date(sinceMs).toISOString(), until: new Date(nowMs).toISOString() },
+    sources: { logs, observations: windowRows.length, samples, unclassifiedRuns: [...runs.values()].filter((run) => run.type === null).length,
+      classification: 'goal-fields-or-space-id', peakCoverage: 'recorded-samples-only' },
+    byGoalType: GOAL_TYPES.map((goalType) => {
+      const group = [...runs.values()].filter((run) => run.type === goalType);
+      const peaks = group.flatMap((run) => run.peakMiB === null ? [] : [run.peakMiB]).sort((a, b) => a - b);
+      const memoryLimits: Record<string, number> = {};
+      for (const run of group) if (run.limit) memoryLimits[run.limit] = (memoryLimits[run.limit] ?? 0) + 1;
+      return { goalType, runs: group.length, measured: peaks.length, missingPeak: group.length - peaks.length,
+        samples: group.reduce((count, run) => count + run.samples, 0), memoryLimits,
+        terminations: group.filter((run) => run.terminated).length, oomKilled: group.filter((run) => run.oomKilled).length,
+        peakMiB: { p50: percentile(peaks, 0.5), p95: percentile(peaks, 0.95), max: peaks.at(-1) ?? null } };
+    }),
+  };
+}
+
+export function readPodMemoryMeasurement(path: string = logsDbPath(), nowMs: number = Date.now()): MemoryMeasurement {
+  if (!existsSync(path)) throw new Error(`log store not found: ${path}`);
+  const store = LogStore.openReadOnly(path);
+  try {
+    return measurePodMemoryByGoal(store.queryAll({ exactCategories: ['self-implement.pod'], sinceMs: nowMs - WEEK_MS, untilMs: nowMs }), nowMs, path);
+  } finally { store.close(); }
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const usage = 'Usage: bun scripts/measure-pod-memory-by-goal.ts [--json] [--logs-db <existing-logs.db>] [--help]';
+  const dbArg = args.indexOf('--logs-db');
+  const db = dbArg === -1 ? logsDbPath() : args[dbArg + 1];
+  if (!db || (dbArg !== -1 && (db.startsWith('--') || args.lastIndexOf('--logs-db') !== dbArg))
+    || args.some((arg, index) => !['--json', '--help', '--logs-db'].includes(arg) && index !== dbArg + 1)) throw new Error(usage);
+  if (args.includes('--help')) console.log(usage);
+  else {
+    const result = readPodMemoryMeasurement(db);
+    if (args.includes('--json')) console.log(JSON.stringify(result, null, 2));
+    else for (const group of result.byGoalType) console.log(`${group.goalType}: runs=${group.runs} measured=${group.measured} peak p50=${group.peakMiB.p50 ?? 'n/a'} MiB p95=${group.peakMiB.p95 ?? 'n/a'} MiB OOMKilled=${group.oomKilled}`);
+  }
+}

package/scripts/release-loop/auto-approve-node.ts

@@ -15,7 +15,7 @@ const outcomeMetric = (name: string, node: Record<string, unknown> | undefined):
 });
 
 /** Rows shown in auto-approval.md but never counted toward the 8 blocking metrics. */
-const WARNING_ONLY = new Set(['tui-regress', 'mac-smoke']);
+export const WARNING_ONLY = new Set(['tui-regress', 'mac-smoke']);
 
 /** `ok` · `warn` (a failure) · `unmeasured` (error or no output) — the macOS smoke never blocks publishing. */
 function macSmokeLevel(node: Record<string, unknown> | undefined): 'ok' | 'warn' | 'unmeasured' {

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

@@ -11,10 +11,11 @@ export function runChecklistGate(context: GraphContext = readGraphContext()) {
   if (gate.ok && gate.moved.length) {
     const [major, minor, patch] = version.split('.').map(Number);
     const next = `${major}.${minor}.${patch! + 1}`;
+    // 이월은 «같은 칸»을 다음 판으로 옮기는 것 — 다른 판 id 충돌 검사(CKID #23407)의 대상이 아니다.
     for (const id of gate.moved) {
       const item = data.items.find((candidate) => candidate.id === id)!;
       if (listChecklist(next).items.some((candidate) => candidate.id === id)) continue;
-      try { addItem(next, { id, title: item.title, ...(item.owner !== undefined ? { owner: item.owner } : {}), ...(item.kind !== undefined ? { kind: item.kind } : {}) }); }
+      try { addItem(next, { id, title: item.title, ...(item.owner !== undefined ? { owner: item.owner } : {}), ...(item.kind !== undefined ? { kind: item.kind } : {}) }, { allowDuplicateId: true }); }
       catch (error) {
         if (!listChecklist(next).items.some((candidate) => candidate.id === id)) throw error;
       }

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;
@@ -124,7 +125,8 @@ export const POD_MEMORY_SOURCE = 'docs/measurements/td1-whole-gate-mechanical-20
 /** GT1 — files per retry chunk when a root shard fails (0.2.7: bundles of 54+ files OOMed at 16Gi, smaller passed). */
 export const POD_SHARD_FILE_CAP = 27;
 
-export const POD_SWEEP_INTEGRATION_ONLY: readonly string[] = ['scripts/install.test.ts'];
+// review-model-ab: Pod 에서 출력 없이 멈춤 2/2(10-04 0.2.11 · 로컬 단독 4/0 · 1.7s) — GATE-STALL 수리 전까지 Pod 밖.
+export const POD_SWEEP_INTEGRATION_ONLY: readonly string[] = ['scripts/install.test.ts', 'scripts/review-model-ab.test.ts'];
 /** Nightly-only whole-repository cases; gate runs the fixture cases in these same files. */
 export const GATE_NIGHTLY_AUDITS: readonly string[] = [
   // Replaces F12's real-repo bucket B apps/pwa scope check and its whole-repo export partition check.
@@ -267,7 +269,7 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
     }, 0);
     const knownTimes = assignable.map((file) => durations.get(file)).filter((value): value is number => value !== undefined && Number.isFinite(value) && value >= 0).sort((a, b) => a - b);
     const unknownSeconds = knownTimes.length ? (knownTimes[Math.floor((knownTimes.length - 1) / 2)]! + knownTimes[Math.floor(knownTimes.length / 2)]!) / 2 : 1;
-    const runShard = async (paths: string[], shard: number, depth = 0, branch = ''): Promise<{ runs: ShardRun[]; stalled: NonNullable<GateResult['stalledShards']> }> => {
+    const runShard = async (paths: string[], shard: number, depth = 0, branch = '', retriedNoOutput = false): Promise<{ runs: ShardRun[]; stalled: NonNullable<GateResult['stalledShards']> }> => {
       const ignores = cdpPatterns.filter((pattern) => paths.includes(pattern))
         .flatMap((pattern) => ['--path-ignore-patterns', pattern]);
       // 파일별 소요는 junit 으로 남긴다 — 콘솔 요약(판정 원천)은 그대로이고, 느린 시험 목록(K10 D4)·계층 분리(D2)의 자가 된다.
@@ -321,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`);
@@ -354,6 +358,11 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
           }
         }
       }
+      if (reason === 'no-output' && !retriedNoOutput) {
+        const retry = await runShard(paths, shard, depth, `${branch}-retry`, true);
+        debug.log('release-loop.gate', 'pod-shard-retry', { shard, files: paths, reason, outcome: retry.stalled[0]?.reason ?? 'ok' });
+        return retry;
+      }
       if (reason) {
         // 깊이 2 에서 «이름 없는 실패»·«불완전»도 파일 단위로 가른다 — 아니면 149파일 조각의 실패 하나가 끝까지 주인 없이 남는다(09-30 G1e 7번 조각: 요약 28 · 이름 27).
         // 로그 없이 죽은 조각(`no-output` · OOM)도 같다 — 09-30 G1f ② 4-0-0 은 150파일이 격리 0 으로 남았다.
@@ -394,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).
@@ -407,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,
@@ -544,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;
@@ -595,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);
@@ -624,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;
@@ -684,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);
@@ -708,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' {
@@ -766,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 });