elanous 0.2.7 → 0.2.9

package/plugins/geo-check/graphs/run-step.ts

@@ -158,18 +158,42 @@ async function run(step: string): Promise<void> {
     if (!table.length) throw new Error('missing score table');
     const gaps = table.filter(cell => cell.error || !cell.mention || cell.citation === false).map(cell => ({ question: cell.question, engine: cell.engine, error: cell.error ?? null, mention: cell.mention, citation: cell.citation }));
     if (!gaps.length) { output({ suggestions: [] }); return; }
-    try {
-      const raw = parseArray(reply(await invoke(['ask', '--json', `Using ONLY this score table, return a JSON array of 3 to 5 improvement suggestions. Each must have "suggestion" (FAQ question, FAQPage/Organization structured data, comparison document, etc.) and "evidence" containing a question and engine from the missing cells. Evidence cells: ${JSON.stringify(gaps)}. Score table: ${JSON.stringify(table)}`])));
-      if (!Array.isArray(raw) || raw.length < 3 || raw.length > 5) throw new Error('invalid suggestion count');
-      const suggestions = raw.map(item => {
+    // A5c — the model often rewords a question or the engine name; one such item used to fail the whole step,
+    // so the same input passed and failed by turns. Evidence is now picked by id, matched leniently, and a wrong
+    // item is dropped (not fatal). Only «no valid suggestion at all» retries once, with a stricter prompt.
+    const cells = gaps.map((cell, id) => ({ id, ...cell }));
+    const norm = (value: unknown) => text(value).toLowerCase().replace(/["'“”‘’`]/g, '').replace(/\s+/g, ' ').trim();
+    const pick = (evidence: unknown) => {
+      if (typeof evidence === 'number') return cells[evidence];
+      const ev = object(evidence);
+      if (typeof ev.id === 'number' && cells[ev.id]) return cells[ev.id];
+      const q = norm(ev.question), e = norm(ev.engine);
+      const exact = cells.find(cell => norm(cell.question) === q && (!e || norm(cell.engine) === e));
+      if (exact) return exact;
+      const byQuestion = cells.filter(cell => q && (norm(cell.question).includes(q) || q.includes(norm(cell.question))));
+      return byQuestion.length === 1 ? byQuestion[0] : undefined;
+    };
+    const ask = async (strict: boolean) => parseArray(reply(await invoke(['ask', '--json', `Using ONLY this score table, return a JSON array of 3 to 5 improvement suggestions. Each item: {"suggestion": "<FAQ question, FAQPage/Organization structured data, comparison document, etc.>", "evidence": <id of one cell below>}.${strict ? ' The evidence MUST be one of the listed ids as a number. Return only the JSON array.' : ''} Evidence cells (pick by id): ${JSON.stringify(cells)}. Score table: ${JSON.stringify(table)}`])));
+    const collect = (raw: unknown) => {
+      if (!Array.isArray(raw)) return [];
+      const seen = new Set<string>();
+      return raw.slice(0, 5).flatMap(item => {
         const candidate = object(item);
-        const evidence = object(candidate.evidence);
-        const match = gaps.find(cell => cell.question === evidence.question && cell.engine === evidence.engine);
-        if (!text(candidate.suggestion) || !match) throw new Error('suggestion missing valid score evidence');
-        return { suggestion: text(candidate.suggestion), evidence: { question: match.question, engine: match.engine } };
+        const match = pick(candidate.evidence);
+        const suggestion = text(candidate.suggestion);
+        if (!suggestion || !match || seen.has(suggestion)) return [];
+        seen.add(suggestion);
+        return [{ suggestion, evidence: { question: match.question, engine: match.engine } }];
       });
-      output({ suggestions }, 1);
-    } catch (e) { output({ outcome: 'fail', suggestions: [], error: errorLine(e) }, 1, 1); }
+    };
+    let calls = 0;
+    try {
+      calls++;
+      let suggestions = collect(await ask(false));
+      if (!suggestions.length) { calls++; suggestions = collect(await ask(true)); }
+      if (!suggestions.length) throw new Error('suggestion missing valid score evidence');
+      output({ suggestions }, calls);
+    } catch (e) { output({ outcome: 'fail', suggestions: [], error: errorLine(e) }, calls || 1, 1); }
   } else if (step === 'report') {
     const table = rows(object(outputs.score).table);
     const answers = rows(object(outputs.answers).answers);

package/scripts/field-feed/deliver-node.ts

@@ -5,7 +5,7 @@
 // ⛔ 인스타그램에 올리지 않는다 — 실제 Meta 게시는 다음 판.
 import { copyFileSync, existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { sendOutbound } from '../../src/domains/outbound-alert.js';
+import { deliver as sendReport } from '../../src/domains/outbound-alert.js';
 import { coverHtml, readContext, readDraft, result, screenshot, slideHtml, writeDraft } from './lib.js';
 
 try {
@@ -41,12 +41,17 @@ try {
   if (reel) copyFileSync(join(folder, draft.reel!), reel);
 
   // FIELD_FEED_NOTIFY=0 — 시험·리허설에서 텔레그램으로 나가지 않게.
-  const sent = process.env.FIELD_FEED_NOTIFY === '0' ? false : sendOutbound([
+  // 경로(daemon=/v1/outbound 수락 · direct=텔레그램 직접 · false=실패)를 그대로 남긴다 — 10-01 운영 실측에서
+  // «notified:true» 만 있고 그래프 자식은 debug.log 가 꺼져 있어 도착 근거가 0 이었다. 사람이 «최종 게시»를 누른
+  // 직후라 야간 무음 보류는 걸지 않는다(sendOutbound 의 보류 대신 바로 보낸다).
+  const notify = process.env.FIELD_FEED_NOTIFY === '0' ? 'off' : sendReport([
     `✅ 승인됨 · 게시 준비 완료 — ${draft.event.title} (${draft.event.date})`,
     `캐러셀 ${included.length + 1}장${reel ? ' ⊕ 릴스 1편' : ''} · 초안 r${draft.revision}${draft.updatedBy === 'human' ? '(사람이 고침)' : ''}`,
     '', text, '', `묶음: ${ready}`, '(인스타그램 게시는 아직 사람이 한다 — 자동 게시는 다음 판)',
   ].join('\n'), 'report');
-  result({ ready, slides: included.length + 1, reel: Boolean(reel), redrawn, revision: draft.revision, notified: sent });
+  const delivered = { at: new Date().toISOString(), path: notify === false ? 'failed' : notify, revision: draft.revision };
+  writeDraft(folder, { ...(readDraft(folder) ?? draft), delivered } as typeof draft);
+  result({ ready, slides: included.length + 1, reel: Boolean(reel), redrawn, revision: draft.revision, notified: notify === 'daemon' || notify === 'direct', notifyPath: delivered.path });
 } catch (error) {
   console.log(JSON.stringify({ outcome: 'fail', reason: error instanceof Error ? error.message : String(error) }));
 }

package/scripts/field-feed/lib.ts

@@ -18,6 +18,8 @@ export type FeedDraft = {
   hashtags: string[];
   location: string | null;
   reel: string | null;
+  /** deliver 가 남긴다 — 알림 경로(daemon·direct·failed·off)와 시각. 도착의 근거는 아니고 «어디로 보냈나»다. */
+  delivered?: { at: string; path: 'daemon' | 'direct' | 'failed' | 'off'; revision: number };
 };
 
 export const ENGINE = resolve(import.meta.dir, '../../skills/explainer-video/engine');

package/scripts/install.sh

@@ -177,7 +177,7 @@ for command in "${REQUIRED_COMMANDS[@]}"; do
   fi
 done
 for command in "${HARNESS_COMMANDS[@]}"; do
-  command -v "$command" >/dev/null 2>&1 || echo "⚠️ harness command missing: $command" >&2
+  command -v "$command" >/dev/null 2>&1 || echo "$(t "⚠️ harness command missing: $command (see Next below)" "⚠️ 하니스가 쓰는 명령이 없습니다: $command (아래 «다음» 참고)")" >&2
 done
 
 # bun 의 «실제 실행 파일» — PATH 의 이름이 아니라 bun 이 스스로 말하는 경로(링크를 끝까지 푼 것).
@@ -444,7 +444,7 @@ STEP=1
 # INST1 order: new shell → elanous (first-time setup, which also signs in) → missing tools → harness say.
 case ":$PATH:" in
   *":$PREFIX/bin:"*) ;;
-  *) if [ "$MODIFY_PATH" -eq 1 ]; then echo "  $STEP) $(t "open a new shell (or: source $STARTUP)" "새 셸을 여세요(또는: source $STARTUP)")"; else echo "  $STEP) $(t "add $PREFIX/bin to PATH" "$PREFIX/bin 을 PATH 에 넣으세요")"; fi; STEP=$((STEP + 1)) ;;
+  *) if [ "$START_SETUP" -eq 1 ]; then :; elif [ "$MODIFY_PATH" -eq 1 ]; then echo "  $STEP) $(t "open a new shell (or: source $STARTUP)" "새 셸을 여세요(또는: source $STARTUP)")"; STEP=$((STEP + 1)); else echo "  $STEP) $(t "add $PREFIX/bin to PATH" "$PREFIX/bin 을 PATH 에 넣으세요")"; STEP=$((STEP + 1)); fi ;;
 esac
 if [ "$START_SETUP" -eq 0 ]; then
   echo "  $STEP) $(t "Run: $PREFIX/bin/elanous   # first-time setup (in a new shell: elanous)" "실행: $PREFIX/bin/elanous   # 첫 설정(새 셸에서는: elanous)")"; STEP=$((STEP + 1))
@@ -473,7 +473,7 @@ if ! command -v make >/dev/null 2>&1 || ! command -v c++ >/dev/null 2>&1; then
   if [ -n "$BUILD_HINT" ]; then
     echo "  $STEP) $BUILD_HINT"; STEP=$((STEP + 1))
   fi
-  echo "  $STEP) elanous doctor --fix --yes       # rebuild node-pty after installing build tools"; STEP=$((STEP + 1))
+  echo "  $STEP) elanous doctor --fix --yes       # $(t 'rebuild node-pty after installing build tools' '빌드 도구를 깐 뒤 node-pty 다시 빌드')"; STEP=$((STEP + 1))
 fi
 if ! command -v rg >/dev/null 2>&1; then
   if [ -z "${OS_ID:-}" ] && [ -r "${ELANOUS_INSTALL_OS_RELEASE_FILE:-/etc/os-release}" ]; then
@@ -487,22 +487,22 @@ if ! command -v rg >/dev/null 2>&1; then
     Linux) case " ${OS_ID:-} ${OS_LIKE:-} " in
       *' debian '*|*' ubuntu '*) RG_HINT='sudo apt-get install -y ripgrep' ;;
       *' fedora '*) RG_HINT='sudo dnf install -y ripgrep' ;;
-      *) RG_HINT='install ripgrep (rg) with your package manager' ;;
+      *) RG_HINT="$(t 'install ripgrep (rg) with your package manager' '패키지 관리자로 ripgrep(rg)을 설치하세요')" ;;
     esac ;;
-    *) RG_HINT='install ripgrep (rg) with your package manager' ;;
+    *) RG_HINT="$(t 'install ripgrep (rg) with your package manager' '패키지 관리자로 ripgrep(rg)을 설치하세요')" ;;
   esac
   echo "  $STEP) $RG_HINT"; STEP=$((STEP + 1))
 fi
 if ! command -v codex >/dev/null 2>&1; then
   if ! command -v node >/dev/null 2>&1; then
-    echo "  $STEP) install Node.js 20+ (the Codex CLI runs on node)   # e.g. your package manager or https://nodejs.org"; STEP=$((STEP + 1))
+    echo "  $STEP) $(t 'install Node.js 20+ (the Codex CLI runs on node)   # e.g. your package manager or https://nodejs.org' 'Node.js 20 이상을 설치하세요(Codex CLI 가 node 로 돕니다)   # 예: 패키지 관리자 또는 https://nodejs.org')"; STEP=$((STEP + 1))
   fi
-  echo "  $STEP) npm install -g @openai/codex      # the harness drives the Codex CLI (not yet measured on a fresh machine)"; STEP=$((STEP + 1))
+  echo "  $STEP) npm install -g @openai/codex      # $(t 'the harness drives the Codex CLI' '하니스가 Codex CLI 를 씁니다')"; STEP=$((STEP + 1))
 fi
 if ! command -v gh >/dev/null 2>&1; then
-  echo "  $STEP) install gh, then: gh auth login   # the harness opens pull requests with it"; STEP=$((STEP + 1))
+  echo "  $STEP) $(t 'install gh, then: gh auth login   # the harness opens pull requests with it' 'gh 를 설치한 뒤: gh auth login   # 하니스가 PR 을 열 때 씁니다')"; STEP=$((STEP + 1))
 elif ! gh auth status >/dev/null 2>&1; then
-  echo "  $STEP) gh auth login                     # the harness opens pull requests with it"; STEP=$((STEP + 1))
+  echo "  $STEP) gh auth login                     # $(t 'the harness opens pull requests with it' '하니스가 PR 을 열 때 씁니다')"; STEP=$((STEP + 1))
 fi
 if [ "$ELN_AVAILABLE" -eq 1 ]; then
   echo "  $STEP) $(t 'eln harness say "<one line of what you want>" (or: elanous harness say)' 'eln harness say "<하고 싶은 일 한 줄>" (또는: elanous harness say)')"
@@ -519,8 +519,17 @@ if [ "$START_SETUP" -eq 1 ]; then
     *":$PREFIX/bin:"*) ;;
     *) echo "  $(t "(new shells will find elanous on PATH; this window uses $PREFIX/bin/elanous)" "(새 셸에서는 PATH 로 elanous 를 찾습니다 · 이 창은 $PREFIX/bin/elanous 를 씁니다)")" ;;
   esac
+  # INST3 (10-01 · node-c tmux): a wizard whose stdin is a fresh open of /dev/tty never saw a key on macOS — its event
+  # loop cannot watch that fd (the same binary started from a shell, which hands over the real tty, worked). So give it
+  # the real terminal device; fall back to /dev/tty only when there is none.
+  SETUP_TTY=/dev/tty
+  REAL_TTY="$(ps -o tty= -p $$ 2>/dev/null | tr -d ' ')"
+  case "$REAL_TTY" in
+    ''|'?'|'??') ;;
+    *) if [ -r "/dev/$REAL_TTY" ] && [ -w "/dev/$REAL_TTY" ]; then SETUP_TTY="/dev/$REAL_TTY"; fi ;;
+  esac
   if [ -n "${ELANOUS_INSTALL_SETUP_EXEC:-}" ]; then
-    exec "$ELANOUS_INSTALL_SETUP_EXEC" "$PREFIX/bin/elanous"
+    ELANOUS_INSTALL_SETUP_TTY="$SETUP_TTY" exec "$ELANOUS_INSTALL_SETUP_EXEC" "$PREFIX/bin/elanous"
   fi
-  exec "$PREFIX/bin/elanous" </dev/tty
+  exec "$PREFIX/bin/elanous" <"$SETUP_TTY"
 fi

package/scripts/persona-presets/lint.ts

@@ -0,0 +1,79 @@
+#!/usr/bin/env bun
+// 페르소나 프리셋 문면 검사(PS1 · 2026-10-02) — persona-presets/<id>.yaml
+//   bun scripts/persona-presets/lint.ts   오류가 있으면 rc 1 · 경고만이면 rc 0
+// 지키는 것: 도구는 «지금 설치할 수 있는 것»만(공개 묶음 표 · 저장소 플러그인 · core) · 용어(«캐릭터» 금지) ·
+//           자리(OP·MK·TC·UX)와 이름이 겹치지 않음 · 직함은 선택 속성 · 과장 금지어.
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { parse } from 'yaml';
+
+const ROOT = resolve(import.meta.dir, '../..');
+const DIR = join(ROOT, 'persona-presets');
+
+export type Preset = {
+  personaId: string; displayName: string; names: string[]; role: string; title?: string | null; oneLine: string;
+  voice: { rule: string; examples: string[] }; tasks: Array<{ when: string; what: string }>;
+  tools: Array<{ name: string; from: string; optional?: boolean }>; firstQuestions: string[]; askBefore?: string[]; doesNot: string[]; forWhom: string;
+};
+
+const CORE = new Set(['harness']);
+const TITLES = new Set(['COO', 'CMO', 'CTO', 'CXO']);
+const SEATS = /^(OP|MK|TC|UX)$/i;
+const BANNED = ['캐릭터', '완전 자율', '무엇이든', '유일', '알아서 다'];
+
+/** Official packs and the skills each one lists, read from the public plugin table (the same page users read). */
+export function officialPacks(root = ROOT): Map<string, string> {
+  const table = readFileSync(join(root, 'release/public/docs/plugins.md'), 'utf8');
+  const packs = new Map<string, string>();
+  for (const row of table.split('\n')) {
+    const m = row.match(/^\| `([a-z0-9-]+)` \| (.*) \| (.*) \|$/);
+    if (m && !/not published/i.test(m[3]!)) packs.set(m[1]!, m[2]!);
+  }
+  return packs;
+}
+
+export function lintPreset(p: Preset, file: string, packs: Map<string, string>, root = ROOT): { errors: string[]; warnings: string[] } {
+  const errors: string[] = []; const warnings: string[] = [];
+  const need = (ok: unknown, msg: string) => { if (!ok) errors.push(msg); };
+  need(/^[a-z][a-z0-9-]{1,30}$/.test(p.personaId ?? '') && file.endsWith(`/${p.personaId}.yaml`), 'personaId = 파일 이름(소문자)');
+  need(p.displayName && p.role && p.oneLine && p.forWhom, 'displayName · role · oneLine · forWhom 필요');
+  need(Array.isArray(p.names) && p.names.length >= 2, 'names 후보 둘 이상');
+  need(p.voice?.rule && p.voice.examples?.length === 2, 'voice = rule ⊕ 예시 두 줄');
+  need(p.tasks?.length === 3 && p.tasks.every((t) => t.when && t.what), 'tasks = 할 일 셋(when · what)');
+  need(p.firstQuestions?.length >= 2 && p.firstQuestions.length <= 3, 'firstQuestions = 처음 묻는 칸 둘~셋');
+  need(p.doesNot?.length >= 2, 'doesNot = 하지 않는 것 둘 이상');
+  if (p.title != null && !TITLES.has(p.title)) errors.push(`title 은 없음 또는 ${[...TITLES].join('·')}`);
+  for (const name of p.names ?? []) if (SEATS.test(name)) errors.push(`이름 «${name}» 이 자리(OP·MK·TC·UX)와 겹친다`);
+  const text = JSON.stringify(p);
+  for (const word of BANNED) if (text.includes(word)) errors.push(`금지어 «${word}»`);
+  for (const tool of p.tools ?? []) {
+    if (tool.from === 'core') { if (!CORE.has(tool.name)) errors.push(`core 도구 «${tool.name}» 는 없다`); continue; }
+    const row = packs.get(tool.from);
+    if (row !== undefined) {
+      if (tool.from !== tool.name && !row.includes(`\`${tool.name}\``)) errors.push(`«${tool.name}» 이 묶음 «${tool.from}» 의 목록에 없다`);
+      continue;
+    }
+    // 공식 묶음에 없는 도구 = 저장소 플러그인일 때만 · 반드시 optional(공개 판 사용자는 따로 설치해야 쓴다)
+    if (tool.from !== tool.name || !existsSync(join(root, 'plugins', tool.name, 'plugin.json'))) errors.push(`«${tool.name}» 은 공식 묶음에도 plugins/${tool.name}/plugin.json 에도 없다`);
+    else if (tool.optional !== true) errors.push(`«${tool.name}» 은 공식 묶음에 없다 — optional: true 로 둔다`);
+    else warnings.push(`«${tool.name}» 은 선택 도구(공식 묶음 게재 전)`);
+  }
+  return { errors, warnings };
+}
+
+if (import.meta.main) {
+  const packs = officialPacks();
+  const index = parse(readFileSync(join(DIR, '_index.yaml'), 'utf8')) as { presets: string[] };
+  const files = readdirSync(DIR).filter((f) => f.endsWith('.yaml') && !f.startsWith('_'));
+  let bad = 0; const names = new Map<string, string>();
+  for (const f of files) {
+    const p = parse(readFileSync(join(DIR, f), 'utf8')) as Preset;
+    const { errors, warnings } = lintPreset(p, `persona-presets/${f}`, packs);
+    if (!index.presets.includes(p.personaId)) errors.push('_index.yaml presets 에 없다');
+    for (const n of p.names ?? []) { if (names.has(n)) errors.push(`이름 «${n}» 이 ${names.get(n)} 와 겹친다`); names.set(n, p.personaId); }
+    for (const e of errors) console.log(`✗ ${f}: ${e}`);
+    for (const w of warnings) console.log(`⚠ ${f}: ${w}`);
+    if (errors.length) bad++; else console.log(`✓ ${f} · ${p.displayName} · 도구 ${p.tools.length}`);
+  }
+  process.exit(bad ? 1 : 0);
+}

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

@@ -7,14 +7,14 @@ export function runChecklistGate(context: GraphContext = readGraphContext()) {
   const data = listChecklist(version);
   const gate = checklistGate(version);
   const counts = summarizeChecklist(data);
-  const summary = `확인표 🟢${counts.green} 🟡${counts.yellow}(이동 ${gate.moved.length} · 알려진 문제 ${gate.knownIssues.length} · 막음 ${gate.blocked.length} · 판정 없음 ${gate.undecided.length}) 🔴${counts.red}${gate.red.length ? ` (${gate.red.join(', ')})` : ''}`;
+  const summary = `확인표 🟢${counts.green} 🟡${counts.yellow}(이동 ${gate.moved.length} · 알려진 문제 ${gate.knownIssues.length} · 막음 ${gate.blocked.length} · 판정 없음 ${gate.undecided.length}) 🔴${counts.red}${gate.red.length ? ` (${gate.red.join(', ')})` : ''}${gate.parity?.length ? ` · ⚠ 짝 경고 ${gate.parity.length}(${gate.parity.map((p) => p.id).join(', ')})` : ''}`;
   if (gate.ok && gate.moved.length) {
     const [major, minor, patch] = version.split('.').map(Number);
     const next = `${major}.${minor}.${patch! + 1}`;
     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 } : {}) }); }
+      try { addItem(next, { id, title: item.title, ...(item.owner !== undefined ? { owner: item.owner } : {}), ...(item.kind !== undefined ? { kind: item.kind } : {}) }); }
       catch (error) {
         if (!listChecklist(next).items.some((candidate) => candidate.id === id)) throw error;
       }

package/scripts/release-loop/cutoff.ts

@@ -4,13 +4,14 @@ import { mkdirSync, realpathSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
-import { buildReleaseManifest, type ReleaseLanding } from '../../src/release-loop/manifest.js';
+import { buildReleaseManifest, parseNextMdNotes, type NextMdNote, type ReleaseLanding } from '../../src/release-loop/manifest.js';
 import { readReleaseNotes, releaseNotesDir } from '../../src/release-loop/release-note.js';
 import { queryRunningRuns } from '../../src/self-implement/running-runs.js';
 import { loadFederatedRunLedger } from '../../src/self-implement/run-ledger.js';
 
 const SEED = 'c1cc37478';
 const CLI_DOC = 'release/public/docs/cli.md';
+const NEXT_MD = 'release/next.md';
 
 function git(args: string[], optional = false): string | null {
   const result = spawnSync('git', args, { cwd: process.cwd(), encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
@@ -61,6 +62,22 @@ function landingAt(sha: string, title: string): ReleaseLanding {
   };
 }
 
+/** next.md lines at the cutoff, each tied to the last landing in range whose diff added that exact line. */
+function nextMdNotes(cutoff: string, landings: ReleaseLanding[]): NextMdNote[] {
+  const text = git(['show', `${cutoff}:${NEXT_MD}`], true);
+  if (!text) return [];
+  const addedBy = new Map<string, string>();
+  for (const landing of landings) {
+    if (!landing.changedFiles.includes(NEXT_MD)) continue;
+    const diff = requiredGit(['show', '-m', '--first-parent', '--format=', '-U0', landing.sha, '--', NEXT_MD]);
+    for (const line of diff.split('\n')) if (line.startsWith('+') && !line.startsWith('+++')) addedBy.set(line.slice(1).trim(), landing.sha);
+  }
+  return parseNextMdNotes(text).map((note) => {
+    const sha = note.raw ? addedBy.get(note.raw) : undefined;
+    return { kind: note.kind, line: note.line, ...(sha ? { sha } : {}) };
+  });
+}
+
 function runningGoalPaths(): string[] {
   const repo = process.cwd();
   const paths: string[] = [];
@@ -119,10 +136,11 @@ export function main(args: string[] = process.argv.slice(2)): void {
   const notes = readReleaseNotes(releaseNotesDir(instanceRoot));
   debug.log('release.notes', 'read', { fragments: notes.size, problems: notes.problems });
   const manifest = buildReleaseManifest({
-    version, baseline: { ref: baseline.ref, sha: baselineSha }, cutoff: { sha: cutoff }, landings, notes,
+    version, baseline: { ref: baseline.ref, sha: baselineSha }, cutoff: { sha: cutoff }, landings, notes, nextMd: nextMdNotes(cutoff, landings),
     runningGoalPaths: runningGoalPaths(), publicCommandsBefore: commandsAt(baselineSha), publicCommandsAfter: commandsAt(cutoff),
   });
   const output = { ...manifest, baselineSource: baseline.source };
+  debug.log('release-loop.notes', 'fragments', { version, ...manifest.fragments });
   const directory = join(instanceRoot, 'release', version);
   mkdirSync(directory, { recursive: true });
   writeFileSync(join(directory, 'manifest.json'), JSON.stringify(output, null, 2) + '\n');

package/scripts/release-loop/export-check-node.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env bun
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { finishNode, nodeOutput, readGraphContext, runCommand, type CommandResult, type CommandRunner } from './node-verdict.js';
+
+export interface ExportCheckResult extends Record<string, unknown> {
+  outcome: 'ok' | 'fail';
+  verdict: 'pass' | 'fail';
+  summary: string;
+  step: 'export' | 'build';
+  tail: string;
+}
+
+function failed(step: ExportCheckResult['step'], message: string, result?: CommandResult): ExportCheckResult {
+  const tail = (result ? result.stderr || result.stdout : message).trim().slice(-300);
+  return { outcome: 'fail', verdict: 'fail', summary: `${step} failed: ${message}${result ? ` (rc=${result.status})` : ''}`, step, tail };
+}
+
+/** Check the same public export and PWA build as release prepare, without cloning or writing to a public remote. */
+export function runExportCheck(run: CommandRunner = runCommand, repoRoot = process.cwd()): ExportCheckResult {
+  const context = readGraphContext();
+  const commit = nodeOutput(context, 'version-release', 'commit');
+  if (context.outputs.gate?.outcome !== 'ok') return failed('export', 'gate did not pass');
+  const root = resolve(repoRoot);
+  const out = mkdtempSync(join(tmpdir(), 'elanous-export-check-'));
+  const sourceDir = join(out, 'source');
+  let added = false;
+  let step: ExportCheckResult['step'] = 'export';
+  let result: ExportCheckResult = failed(step, 'check incomplete');
+  try {
+    const modulesRoot = dirname(realpathSync(join(root, 'node_modules')));
+    const add = run('git', ['worktree', 'add', '-q', '--detach', sourceDir, commit], root);
+    if (add.status !== 0) result = failed('export', 'git worktree add', add);
+    else {
+      added = true;
+      const head = run('git', ['rev-parse', 'HEAD'], sourceDir);
+      if (head.status !== 0 || head.stdout.trim() !== commit) result = failed('export', 'cut commit mismatch', head);
+      else {
+        const version = (JSON.parse(readFileSync(join(sourceDir, 'package.json'), 'utf8')) as { version?: string }).version;
+        if (version !== context.input.version) result = failed('export', `package.json version ${version} != ${context.input.version}`);
+        else {
+          symlinkSync(join(modulesRoot, 'node_modules'), join(sourceDir, 'node_modules'), 'dir');
+          const exported = run('bun', ['scripts/public-export.ts', '--out', join(out, 'export')], sourceDir);
+          if (exported.status !== 0) result = failed('export', 'public export', exported);
+          else {
+            step = 'build';
+            const publicDir = join(out, 'export');
+            symlinkSync(join(modulesRoot, 'node_modules'), join(publicDir, 'node_modules'), 'dir');
+            const pwaModules = join(modulesRoot, 'apps', 'pwa', 'node_modules');
+            if (existsSync(pwaModules) && existsSync(join(publicDir, 'apps', 'pwa'))) symlinkSync(pwaModules, join(publicDir, 'apps', 'pwa', 'node_modules'), 'dir');
+            const built = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], publicDir);
+            result = built.status === 0 && existsSync(join(publicDir, 'apps', 'pwa', 'out', 'index.html'))
+              ? { outcome: 'ok', verdict: 'pass', summary: `public export and PWA build ${commit.slice(0, 12)}`, step: 'build', tail: '' }
+              : failed('build', 'PWA build or out/index.html missing', built);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    result = failed(step, error instanceof Error ? error.message : String(error));
+  } finally {
+    try {
+      if (added) {
+        const removed = run('git', ['worktree', 'remove', '--force', sourceDir], root);
+        if (removed.status !== 0) result = failed(step, 'git worktree remove', removed);
+      }
+    } catch (error) {
+      result = failed(step, `git worktree remove: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      rmSync(out, { recursive: true, force: true });
+    }
+  }
+  return result;
+}
+
+if (import.meta.main) {
+  let version = '';
+  try {
+    version = readGraphContext().input.version;
+    process.exitCode = finishNode('export-check', version, runExportCheck());
+  } catch (error) {
+    process.exitCode = finishNode('export-check', version, failed('export', error instanceof Error ? error.message : String(error)));
+  }
+}

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

@@ -10,7 +10,7 @@ import { getElanousConfigDirOverride } from '../../src/elanous-config-dir.js';
 import { diffFailures, junitFailures, parseFailures } from './gate-diff';
 import { loadEnvKnownFailures, splitKnownEnv } from './env-known-failures';
 import { baselineFromCutLogs } from './baseline-from-logs';
-import { planShards, readFileDurations } from './shard-plan';
+import { planShards, readFileDurations, readFileMemory } from './shard-plan';
 import { deriveCdpTestPatterns } from '../test-deterministic';
 import { emitNodeResult, readGraphContext } from './node-verdict.js';
 import { runPodCommand, type RunPodCommandOptions, type PodCommandResult } from '../../src/task-orchestrator/surfaces/pod-command-job.js';
@@ -112,11 +112,27 @@ const summaryCount = (output: string, label: string) => Number(lastMatch(output,
 /** bun reads a bare positional as a substring filter (`test` matches every *.test.ts); `./` makes it a path. */
 const asPath = (path: string) => path.startsWith('./') || path.startsWith('/') ? path : `./${path}`;
 export const POD_ISOLATION_MEMORY_LIMIT = '32Gi';
+/** GT1b — a file whose measured peak is at least this runs alone at the isolation limit from the start: one such file
+ *  sank a whole 203-file root shard at 16Gi (0.2.6 shard 12 · `unwired-exports` 9.9 GB) and cost two halving rounds. */
+export const POD_HEAVY_FILE_MB = 4096;
+/** Per-file peak memory, read from the cut tree (absent → no heavy files; the halving path still catches OOM). */
+export const POD_MEMORY_SOURCE = 'docs/measurements/td1-whole-gate-mechanical-2026-10-01.tsv';
 /** Integration tests that the Pod sweep does not run — each is judged by a real run elsewhere at the cut.
  *  0.2.7 run 5 (10-01): `scripts/install.test.ts` (real `bun pm pack` → `bun add` installs, 301 s alone on node-b)
  *  sat in a shard of its own past the 1200 s deadline with no output and stopped the whole gate. Judged on the
  *  mbp at the cut instead (TD1 moves it to the integration line). Keep this list short and explained. */
+/** 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'];
+/** Whole-repository audits run alone in the nightly test-diet graph, not in release-gate shards. */
+export const GATE_NIGHTLY_AUDITS: readonly string[] = [
+  'test/f12-sweep.test.ts', // Sweeps the whole repository; 7.8 GB even after TD1a.
+  'scripts/unwired-exports.test.ts', // Compiles and scans all exports; 9.9 GB.
+  'test/guardian/dispatch-surface-contract.test.ts', // Compiles repository-wide dispatch contracts; 8.3 GB.
+  'test/pwa-build-typecheck.test.ts', // Builds and typechecks the whole PWA; 4.2 GB.
+  'test/user-config-mcp.test.ts', // 2.1 GB peak; keep the gate below the 2 GB audit budget.
+];
 const tail40 = (output: string) => output.trimEnd().split(/\r?\n/).slice(-40).join('\n');
 const lastStartedTestFile = (output: string, paths: string[]): string | undefined => {
   let last: string | undefined;
@@ -203,12 +219,21 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
     // CDP 시험은 `test:deterministic` 이 스스로 뺀다 — 조각에 그것만 남으면 bun «시험 없음» exit 1 을 «불완전»으로 읽었다(09-30 G1d 실측 둘).
     // bun 의 탐색은 숨은 디렉터리(`.x/`)를 안 연다 — 사람의 `bun test` 가 한 번도 안 돌리는 빈 픽스처가 조각에 혼자 남아 «Ran 0 tests» 를 «불완전»으로 읽었다(09-30 G1e 5번 조각).
     const assignable = files.filter((file) => !cdpPatterns.includes(file) && !POD_SWEEP_INTEGRATION_ONLY.includes(file)
-      && !file.split('/').some((part) => part.startsWith('.')));
+      && !GATE_NIGHTLY_AUDITS.includes(file) && !file.split('/').some((part) => part.startsWith('.')));
     const integrationOnly = files.filter((file) => POD_SWEEP_INTEGRATION_ONLY.includes(file));
     if (integrationOnly.length) debug.log('release-loop.gate', 'pod-sweep-integration-only', { files: integrationOnly });
+    const nightlyAudits = files.filter((file) => GATE_NIGHTLY_AUDITS.includes(file));
+    if (nightlyAudits.length) debug.log('release-loop.gate', 'pod-sweep-nightly-audit', { files: nightlyAudits });
     if (!assignable.length) throw new Error('sweep incomplete: no tests ran');
     const durations = pod.durationSource ? readFileDurations(pod.durationSource) : new Map<string, number>();
-    const shards = planShards(assignable, durations, shardCount);
+    const memory = readFileMemory(join(tree, POD_MEMORY_SOURCE));
+    const heavy = new Set(assignable.filter((file) => (memory.get(file) ?? 0) >= POD_HEAVY_FILE_MB));
+    const light = assignable.filter((file) => !heavy.has(file));
+    const shards = [
+      ...(light.length ? planShards(light, durations, shardCount) : []),
+      ...[...heavy].map((file) => ({ files: [file], plannedSeconds: durations.get(file) ?? 0 })),
+    ];
+    if (heavy.size) debug.log('release-loop.gate', 'pod-heavy-alone', { files: [...heavy], thresholdMb: POD_HEAVY_FILE_MB, memoryLimit: POD_ISOLATION_MEMORY_LIMIT });
     const known = assignable.filter((file) => durations.has(file)).length;
     debug.log('release-loop.gate', 'pod-shard-plan', {
       shards: shards.length, known, unknown: assignable.length - known,
@@ -259,7 +284,7 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
           pool: pod.pool, poolScheduler, clone: true, source: { kind: 'commit', sha: commit }, deadlineSeconds,
           ...(bunCache ? { bunCache } : {}),
           // 실패 뒤 다시 도는 파일 하나짜리 Job 은 메모리 한도를 올린다 — 16Gi 에선 무거운 한 파일이 혼자서도 OOM 이었다(09-30 `unwired-exports`).
-          ...(paths.length === 1 && depth >= 1 ? { memoryLimit: POD_ISOLATION_MEMORY_LIMIT } : {}),
+          ...(paths.length === 1 && (depth >= 1 || heavy.has(paths[0]!)) ? { memoryLimit: POD_ISOLATION_MEMORY_LIMIT } : {}),
           name: `gate-${randomUUID()}`,
           command: ['bash', '-lc', `mkdir -p "$HOME/outbox"; ${cachePrefix}(cd .. && cd repo && bun install && (cd apps/pwa && bun install) && ${args}) 2>&1 | tee "$HOME/outbox/shard.log"; echo \${PIPESTATUS[0]} > "$HOME/outbox/shard.rc"`],
         });
@@ -350,6 +375,15 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
           ...(lastFile ? { lastFile } : {}),
           ...(reason === 'unattributed' ? { summaryFailures: fails, namedFailures, ...(unattributedDetail ? { detail: unattributedDetail } : {}) } : {}),
         }] };
+        // GT1 — a big shard that failed at the root goes straight to cap-sized chunks instead of halving twice: memory
+        // piles up when one bun process runs many files (0.2.7: only bundles of 54+ OOMed), and each halving round costs
+        // a Pod start, an install and a rerun. A failing chunk then isolates its files (depth 2), as before.
+        if (depth === 0 && paths.length > POD_SHARD_FILE_CAP) {
+          const chunks = Array.from({ length: Math.ceil(paths.length / POD_SHARD_FILE_CAP) }, (_, i) => paths.slice(i * POD_SHARD_FILE_CAP, (i + 1) * POD_SHARD_FILE_CAP));
+          debug.log('release-loop.gate', 'pod-shard-cap-split', { shard, files: paths.length, chunks: chunks.length, cap: POD_SHARD_FILE_CAP, reason });
+          const children = await Promise.all(chunks.map((chunk, i) => runShard(chunk, shard, 2, `${branch}-c${i}`)));
+          return { runs: children.flatMap((child) => child.runs), stalled: children.flatMap((child) => child.stalled) };
+        }
         debug.log('release-loop.gate', 'pod-shard-split', { shard, depth, files: paths, reason });
         const middle = Math.ceil(paths.length / 2);
         const children = await Promise.all([
@@ -403,9 +437,10 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
       const outputs: string[] = [];
       let total = { pass: 0, fail: 0, errors: 0, ran: 0, files: 0 };
       for (const group of groups) {
-        if (!group.paths.length || !files.some((f) => group.paths.some((p) => f === p || f.startsWith(`${p}/`)))) continue;
+        if (!group.paths.length || !files.some((f) => !GATE_NIGHTLY_AUDITS.includes(f) && group.paths.some((p) => f === p || f.startsWith(`${p}/`)))) continue;
         const start = Date.now();
-        const groupIgnores = cdpPatterns.filter((pattern) => group.paths.some((p) => pattern === p || pattern.startsWith(`${p}/`)))
+        const groupIgnores = [...new Set([...cdpPatterns, ...GATE_NIGHTLY_AUDITS])]
+          .filter((pattern) => files.includes(pattern) && group.paths.some((p) => pattern === p || pattern.startsWith(`${p}/`)))
           .flatMap((pattern) => ['--path-ignore-patterns', pattern]);
         const run = await command('bun', ['run', 'test:deterministic', ...groupIgnores, ...group.paths.map(asPath)], tree);
         if (logDir) {
@@ -584,7 +619,10 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     };
     let baseline: SweepFailures | undefined = trusted ? { failures: trusted.failures, errors: trusted.errors ?? [] } : undefined;
     if (!baseline) {
-      const baseRun = await runner.sweep(await getBaseTree(), join(root, 'release', opts.version, 'gate-logs', 'baseline'));
+      // K9b — with no reusable ledger the baseline is swept on the same Pod pool as the cut, not on this host (0.2.6: an
+      // 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');
     }
     for (const id of [...baseline.failures, ...baseline.errors, ...cut.failures, ...cut.errors]) fileOf(id);

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

@@ -57,6 +57,11 @@ export function errorResult(error: unknown): { outcome: 'error'; verdict: 'fail'
   return { outcome: 'error', verdict: 'fail', summary: error instanceof Error ? error.message : String(error) };
 }
 
+/** A cut whose notes would show users nothing fails the cutoff instead of shipping a «Plus N internal changes.» page. */
+export function cutoffNotesEmpty(data: Record<string, unknown> | undefined): boolean {
+  return Array.isArray(data?.escalate) && (data.escalate as Array<{ kind?: string }>).some((item) => item?.kind === 'notes-empty');
+}
+
 // Existing cutoff/PWA/TUI programs have different output conventions; normalize them at the graph boundary.
 if (import.meta.main) {
   const node = process.argv[2];
@@ -78,7 +83,9 @@ if (import.meta.main) {
     const baseline = data?.baseline as { sha?: string } | undefined;
     const outcome: NodeOutcome = node === 'cutoff' ? run.status === 0 && data?.version === version && (data?.cutoff as { sha?: string } | undefined)?.sha === commit && typeof baseline?.sha === 'string' ? 'ok' : 'error'
       : run.status === 0 && (verdict === 'pass' || verdict === 'flaky') ? 'ok' : run.status === 1 ? 'fail' : 'error';
-    result = { ...data, outcome, verdict: outcome === 'ok' ? verdict === 'flaky' ? 'flaky' : 'pass' : 'fail',
+    if (node === 'cutoff' && outcome === 'ok' && cutoffNotesEmpty(data)) {
+      result = { ...data, outcome: 'fail', verdict: 'fail', summary: 'cutoff notes-empty — 사용자에게 보일 변경 줄이 0이다(release/next.md 와 PR 노트 조각을 확인하라)' };
+    } else result = { ...data, outcome, verdict: outcome === 'ok' ? verdict === 'flaky' ? 'flaky' : 'pass' : 'fail',
       summary: outcome === 'ok' ? `${node} ${verdict === 'flaky' ? 'flaky' : 'pass'}` : `${node} ${data?.error || run.stderr.trim() || data?.verdict || 'failed'} (rc=${run.status})` };
   } catch (error) { result = errorResult(error); }
   process.exitCode = finishNode(node ?? 'unknown', version, result);

package/scripts/release-loop/npm-publish-node.ts

@@ -1,11 +1,11 @@
 #!/usr/bin/env bun
 import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 import { sendOutbound } from '../../src/domains/outbound-alert.js';
-import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
+import { effectiveInstanceRoot, prodInstanceRoot } from '../../src/instance/resolve.js';
 import { emitNodeResult, readGraphContext, type GraphContext } from './node-verdict.js';
 
 type Result = { outcome: 'ok' | 'fail'; verdict: 'pass' | 'fail'; summary: string; npm?: 'published' | 'already-published' | 'staged-not-visible'; humanAction?: 'npm-support' };
@@ -16,6 +16,8 @@ export interface NpmPublishDeps {
   registry?: Registry;
   sleep?: (ms: number) => Promise<void>;
   stateDir?: string;
+  /** Test seam — the production root whose secrets/npm-token is the last fallback. */
+  productionRoot?: string;
   alert?: (text: string, kind: string) => boolean;
   log?: (version: string, waitedMinutes: number) => void;
 }
@@ -48,7 +50,10 @@ export async function runNpmPublish(context: GraphContext = readGraphContext(),
   try {
     if (context.outputs.publish?.outcome !== 'ok') throw new Error('publish must succeed before npm publish');
     const stateDir = deps.stateDir ?? effectiveInstanceRoot();
-    const candidate = join(stateDir, 'release', version, 'prepared', 'dist', 'elanous.tgz');
+    // REL3 — the archive prepare actually built (its output) wins over this process's universe: a resumed run can
+    // resolve another universe (10-01 0.2.7: prepared in the pilot test universe, resumed in production).
+    const prepared = context.outputs.prepare?.candidate;
+    const candidate = typeof prepared === 'string' && prepared.endsWith('.tgz') ? prepared : join(stateDir, 'release', version, 'prepared', 'dist', 'elanous.tgz');
     const run = deps.exec ?? exec;
     const readRegistry = deps.registry ?? registry;
     const wait = deps.sleep ?? sleep;
@@ -71,7 +76,8 @@ export async function runNpmPublish(context: GraphContext = readGraphContext(),
     const before = await inspect();
     if (before.tagged) return { outcome: 'ok', verdict: 'pass', npm: 'already-published', summary: `npm ${version} already published with latest tag` };
     if (!before.visible) {
-      const tokenFile = context.input.npmTokenFile ?? join(stateDir, 'secrets', 'npm-token');
+      // The npm token is a machine secret (like the GitHub App key): input → this universe → the production root.
+      const tokenFile = context.input.npmTokenFile ?? [join(stateDir, 'secrets', 'npm-token'), join(deps.productionRoot ?? prodInstanceRoot(), 'secrets', 'npm-token')].find((p) => existsSync(p)) ?? join(stateDir, 'secrets', 'npm-token');
       if (typeof tokenFile !== 'string' || !tokenFile.trim()) throw new Error('input.npmTokenFile must be a path');
       token = readFileSync(tokenFile, 'utf8').trim();
       if (!token) throw new Error('npm token file empty');