elanous 0.2.18 → 0.2.20

package/scripts/release-loop/resume-release.ts

@@ -2,12 +2,14 @@
 // The saved version-release output is re-pointed at the new branch tip (fast-forward only, state backed up first), so
 // every later node reads the repaired commit without anyone hand-editing the run state.
 import { spawnSync } from 'node:child_process';
-import { constants, copyFileSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { constants, copyFileSync, existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../../src/debug/log.js';
-import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
+import { effectiveInstanceRoot, releaseLedgerRoot } from '../../src/instance/resolve.js';
 import { lastJsonObject, runGraph, type GraphRunState } from '../../src/graph-runner/runner.js';
+import { releaseRunUniverse } from './release-universe.js';
 import { isReleaseVersion } from './release-version.js';
+import { changedFilesBetween, clearPartialPlan, planPartialRegate, writePartialPlan } from './gate-partial.js';
 
 const GRAPH = join(import.meta.dir, '../../graphs/release/release-loop.yaml');
 
@@ -24,6 +26,8 @@ export interface ResumeReleaseDeps {
   /** Node command runner for the resumed graph (tests record each node's context instead of running it). */
   runBash?: NonNullable<NonNullable<Parameters<typeof runGraph>[1]>['deps']>['runBash'];
   now?: () => Date;
+  /** Machine release ledger (gate-failures.json of the prior gate) — default releaseLedgerRoot(). */
+  ledgerRoot?: string;
 }
 
 export interface TipRefresh { version: string; branch: string; from: string; to: string; changed: boolean; statePath: string; backup?: string }
@@ -106,10 +110,68 @@ export function refreshReleaseBranchTip(runId: string, deps: ResumeReleaseDeps =
   return { version, branch, from: recorded, to, changed: true, statePath, backup };
 }
 
+/** GATE-PARTIAL outcome of a resume — applied (plan written) or the reason it fell back to a full gate. */
+export type PartialOutcome = { requested: false } | { requested: true; applied: true; files: number; priorCommit: string } | { requested: true; applied: false; reason: string };
+
+/** Build (or clear) the partial re-gate plan for the new tip. Fail-closed: any doubt leaves a full gate. */
+function preparePartial(tip: TipRefresh, opts: { from: string; partial?: boolean }, deps: ResumeReleaseDeps): PartialOutcome {
+  const root = deps.root ?? effectiveInstanceRoot();
+  // Any resume starts from no plan: one without --partial (from whatever node) never inherits an older plan.
+  clearPartialPlan(root, tip.version);
+  if (!opts.partial) return { requested: false };
+  const fallback = (reason: string): PartialOutcome => {
+    debug.log('release-loop.resume', 'partial-fallback', { version: tip.version, reason });
+    return { requested: true, applied: false, reason };
+  };
+  if (opts.from !== 'gate') return fallback('--partial only applies to --from gate');
+  if (!tip.changed) return fallback('release branch tip unchanged — nothing new to re-check');
+  let prior: { commit?: unknown; failures?: unknown; errors?: unknown } | undefined;
+  for (const location of [...new Set([deps.ledgerRoot ?? releaseLedgerRoot(), root])]) {
+    const path = join(location, 'release', tip.version, 'gate-failures.json');
+    if (!existsSync(path)) continue;
+    let record: typeof prior;
+    try { record = JSON.parse(readFileSync(path, 'utf8')) as typeof prior; }
+    catch { return fallback(`unreadable gate record: ${path}`); }
+    if (record?.commit === tip.from) { prior = record; break; }
+  }
+  if (!prior || !Array.isArray(prior.failures) || !(prior.errors === undefined || Array.isArray(prior.errors))) {
+    return fallback(`no complete gate record for ${tip.from.slice(0, 12)} (a stalled or errored gate keeps none)`);
+  }
+  // Both sides of a rename count (`--no-renames`): a source moved to a test/Markdown name is still a source change.
+  let changed: string[];
+  try {
+    changed = deps.git
+      ? deps.git(['diff', '--name-only', '--no-renames', `${tip.from}..${tip.to}`]).split(/\r?\n/).filter(Boolean)
+      : changedFilesBetween(deps.repo ?? process.cwd(), tip.from, tip.to);
+  } catch (error) {
+    // The tip is already refreshed — a failed diff must not strand the resume: run the full gate and say why.
+    return fallback(`changed files unreadable: ${String(error instanceof Error ? error.message : error).slice(0, 200)}`);
+  }
+  const planned = planPartialRegate({ version: tip.version, priorCommit: tip.from, forCommit: tip.to, changedFiles: changed,
+    priorFailures: prior.failures as string[], priorErrors: (prior.errors ?? []) as string[] });
+  if (!planned.ok) return fallback(planned.reason);
+  const path = writePartialPlan(root, planned.plan);
+  debug.log('release-loop.resume', 'partial-planned', { version: tip.version, priorCommit: tip.from, commit: tip.to, files: planned.plan.files.length, path });
+  return { requested: true, applied: true, files: planned.plan.files.length, priorCommit: tip.from };
+}
+
+/** The graph file the run started from — a snapshot run refuses any other path (the installed CLI's own copy differs). */
+function savedGraphPath(statePath: string): string | undefined {
+  try {
+    const saved = JSON.parse(readFileSync(statePath, 'utf8')) as { graphPath?: unknown };
+    return typeof saved.graphPath === 'string' && saved.graphPath ? saved.graphPath : undefined;
+  } catch { return undefined; }
+}
+
 /** Refresh the branch tip, then restart the failed run at `from` with the saved graph snapshot. */
-export async function resumeReleaseRun(opts: { runId: string; from: string }, deps: ResumeReleaseDeps = {}): Promise<{ tip: TipRefresh; state: GraphRunState }> {
+export async function resumeReleaseRun(opts: { runId: string; from: string; partial?: boolean }, deps: ResumeReleaseDeps = {}): Promise<{ tip: TipRefresh; partial: PartialOutcome; state: GraphRunState }> {
   if (opts.from === 'version-release') throw new Error('--from version-release would cut again — resume at a later node');
+  // RELEASE-LEDGER-UNIVERSE: decide the universe once; the run lookup and every resumed node use it.
+  deps = { ...deps, root: releaseRunUniverse({ root: deps.root }) };
   const tip = refreshReleaseBranchTip(opts.runId, deps, opts.from);
-  const state = await (deps.graph ?? runGraph)(deps.graphPath ?? GRAPH, { resumeRunId: opts.runId, fromNodeId: opts.from, ...(deps.root || deps.runBash ? { deps: { ...(deps.root ? { root: deps.root } : {}), ...(deps.runBash ? { runBash: deps.runBash } : {}) } } : {}) });
-  return { tip, state };
+  const partial = preparePartial(tip, opts, deps);
+  // Resume the graph at the path it was started from (its snapshot is used); only tests inject another path.
+  const graphPath = deps.graphPath ?? savedGraphPath(tip.statePath) ?? GRAPH;
+  const state = await (deps.graph ?? runGraph)(graphPath, { resumeRunId: opts.runId, fromNodeId: opts.from, pinChildUniverse: true, deps: { root: deps.root, ...(deps.runBash ? { runBash: deps.runBash } : {}) } });
+  return { tip, partial, state };
 }

package/scripts/release-loop/shard-plan.ts

@@ -1,5 +1,21 @@
 import { readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { debug } from '../../src/debug/log.js';
+
+/** Plan weights for a Pod sweep: wall-scaled when the previous cut recorded shard wall times, junit seconds otherwise. */
+export function planDurations(durationSource: string | undefined): { durations: Map<string, number>; wall?: { shards: number; scaledFiles: number } } {
+  if (!durationSource) return { durations: new Map() };
+  const junit = readFileDurations(durationSource);
+  const wall = readFileWallWeights(durationSource, junit);
+  return wall ? { durations: wall.weights, wall: { shards: wall.shards, scaledFiles: wall.scaledFiles } } : { durations: junit };
+}
+
+/** Observation for GATE-PLAN-WALLTIME, emitted once the shards are planned so `maxPlannedMin` is the heaviest shard. */
+export function logPlanWalltime(wall: { shards: number; scaledFiles: number } | undefined, shards: ReadonlyArray<{ plannedSeconds: number }>): void {
+  if (!wall) return;
+  const maxPlannedSeconds = Math.max(0, ...shards.map((shard) => shard.plannedSeconds));
+  debug.log('release-loop.gate', 'plan-walltime', { shards: wall.shards, scaledFiles: wall.scaledFiles, maxPlannedMin: Math.round(maxPlannedSeconds / 6) / 10 });
+}
 
 /** Read per-file seconds from previous cut Pod reports; missing or damaged reports are not estimates. */
 export function readFileDurations(dir: string): Map<string, number> {
@@ -62,3 +78,52 @@ export function planShards(files: string[], durations: Map<string, number>, coun
   }
   return shards.filter((shard) => shard.files.length > 0);
 }
+
+/**
+ * GATE-PLAN-WALLTIME: junit testsuite times run far below a shard's real wall time (0.2.18 pod-23: planned 2.7 min,
+ * measured 33.3 min), so LPT balanced the wrong quantity. When the previous cut left `pod-*.json` records
+ * (`durationMs` ⊕ `files`), each file's junit seconds are scaled so its shard's planned total equals the measured wall
+ * time; files without junit take that shard's average per-file wall time. A file measured in several records takes
+ * its first-pass shard (`pod-<n>.json` — the shape the next cut plans) over descent/retry children, whose per-Pod
+ * install overhead lands on one or two files; among equals, the record with the fewest files.
+ * Returns undefined when no usable record exists, so callers keep the junit-only behaviour.
+ */
+export function readFileWallWeights(dir: string, junit: Map<string, number>): { weights: Map<string, number>; shards: number; scaledFiles: number } | undefined {
+  let names: string[];
+  try { names = readdirSync(dir).filter((name) => /^pod-.*\.json$/.test(name)).sort(); }
+  catch { return undefined; }
+  const records: Array<{ wallSeconds: number; files: string[]; firstPass: boolean }> = [];
+  for (const name of names) {
+    try {
+      const meta = JSON.parse(readFileSync(join(dir, name), 'utf8')) as { durationMs?: unknown; files?: unknown };
+      if (typeof meta.durationMs !== 'number' || !Number.isFinite(meta.durationMs) || meta.durationMs <= 0) continue;
+      if (!Array.isArray(meta.files) || !meta.files.length || !meta.files.every((file) => typeof file === 'string')) continue;
+      records.push({ wallSeconds: meta.durationMs / 1000, files: [...new Set(meta.files as string[])], firstPass: /^pod-\d+\.json$/.test(name) });
+    } catch { /* One damaged record must not discard the others. */ }
+  }
+  if (!records.length) return undefined;
+  const valid = (value: number | undefined): value is number => value !== undefined && Number.isFinite(value) && value >= 0;
+  const best = new Map<string, { rank: number; seconds: number }>();
+  for (const record of records) {
+    const unknownCount = record.files.filter((file) => !valid(junit.get(file))).length;
+    const junitSum = record.files.reduce((sum, file) => { const value = junit.get(file); return sum + (valid(value) ? value : 0); }, 0);
+    const average = record.wallSeconds / record.files.length;
+    const remaining = record.wallSeconds - unknownCount * average;
+    for (const file of record.files) {
+      const seconds = junit.get(file);
+      const weight = valid(seconds) && junitSum > 0 && remaining > 0 ? seconds * (remaining / junitSum) : average;
+      const prior = best.get(file);
+      const rank = (record.firstPass ? 0 : 1_000_000) + record.files.length;
+      if (!prior || rank < prior.rank) best.set(file, { rank, seconds: weight });
+    }
+  }
+  // Files timed by junit but absent from every record (new or renamed since the cut) take the overall scale, so the
+  // plan never mixes wall seconds with raw junit seconds.
+  let scaledSum = 0;
+  let junitSum = 0;
+  for (const [file, { seconds }] of best) { const value = junit.get(file); if (valid(value) && value > 0) { scaledSum += seconds; junitSum += value; } }
+  const overall = junitSum > 0 ? scaledSum / junitSum : 1;
+  const weights = new Map([...junit].map(([file, seconds]) => [file, seconds * overall] as [string, number]));
+  for (const [file, { seconds }] of best) weights.set(file, seconds);
+  return { weights, shards: records.length, scaledFiles: best.size };
+}

package/scripts/release-loop/unattended-release.ts

@@ -9,6 +9,7 @@ import { getSchedule } from '../../src/release-loop/release-schedule.js';
 import { isLandingFreezeRefusal, readLandingFreeze, LandingFrozenError } from '../../src/release-loop/landing-freeze.js';
 import { debug } from '../../src/debug/log.js';
 import { runGraph, type GraphRunState } from '../../src/graph-runner/runner.js';
+import { releaseRunUniverse } from './release-universe.js';
 import { baseVersion, isStableVersion, nextPrereleaseVersion, type PrereleaseKind } from './release-version.js';
 
 const VERSION = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
@@ -18,7 +19,14 @@ export interface ReleaseLoopConfig {
   gatePodPool?: string;
   gatePodBunCache?: string;
   gatePodShards?: number;
+  /** GATE-TIMEOUT-HEAL — the per-shard deadline floor; each shard gets planned × 1.5 above it (capped). */
   gatePodShardTimeoutSeconds?: number;
+  /** GATE-INSTALL-CACHE — concurrent `bun install`s per gate node (default 4 · 0 = off). */
+  gatePodInstallSlots?: number;
+  /** GATE-MEM-ADMIT — seconds a gate shard waits for pool admission (memory headroom) before launching anyway with `admission-timeout` (default 300 · 0 = off). */
+  gatePodAdmissionWaitSeconds?: number;
+  /** GATE-SPEED A3①: gate shard Pod CPU — `2` (request = limit) or `{ request, limit }`. Omitted = request 1 / limit 4. */
+  gatePodCpu?: number | string | { request?: number | string; limit?: number | string };
   gateRemote?: string;
   gateRemoteMirror?: string;
   opsHosts?: string[];
@@ -40,7 +48,7 @@ export interface UnattendedReleaseDeps {
   ledgerRoot?: string;
   config?: ReleaseLoopConfig;
   configPath?: string;
-  graph?: (path: string, options: { input: ReleaseRunInput }) => Promise<GraphRunState>;
+  graph?: (path: string, options: { input: ReleaseRunInput; pinChildUniverse?: boolean; deps?: { root?: string } }) => Promise<GraphRunState>;
   checklist?: (version: string) => Pick<ReturnType<typeof cutChecklistGate>, 'ok' | 'red' | 'undecided' | 'blocked'>;
   freezeRoot?: string;
   /** Names already taken for prerelease numbering (remote release branches and tags). */
@@ -140,7 +148,9 @@ export async function runUnattendedRelease(
   }
   const beforeGraph = readLandingFreeze(deps.freezeRoot);
   if (beforeGraph && !opts.forceFreeze) throw new LandingFrozenError(beforeGraph);
-  const state = await (deps.graph ?? runGraph)(GRAPH, { input });
+  // RELEASE-LEDGER-UNIVERSE: one universe for the run ledger, the release ledger and every node subprocess.
+  const root = releaseRunUniverse({ root: deps.ledgerRoot });
+  const state = await (deps.graph ?? runGraph)(GRAPH, { input, pinChildUniverse: true, deps: { root } });
   // A freeze switched on while the graph ran stops gate or publish inside it. Only a failed gate/publish node whose own
   // record is the freeze refusal is reported as the freeze; any other failure keeps its own reason.
   if (state.status === 'failed' && !opts.forceFreeze) {

package/scripts/release-story/draft.ts

@@ -55,7 +55,7 @@ function userFacingLines(markdown: string): { lines: string[]; internalDropped:
 }
 
 function firstPhrase(title: string): string {
-  let quote: '»' | '"' | '`' | undefined;
+  let quote: '»' | '"' | '`' | '”' | '’' | '」' | undefined;
   let angleStart = -1;
   for (let i = 0; i < title.length; i++) {
     const char = title[i]!;
@@ -64,6 +64,10 @@ function firstPhrase(title: string): string {
       continue;
     }
     if (char === '«') { quote = '»'; angleStart = i; continue; }
+    if (char === '“') { quote = '”'; continue; }
+    // 여는 ‘ 는 생략 부호로 안 쓰이니 짝을 기다린다 — ASCII ' 는 한국어 생략 부호라 짝으로 보지 않는다.
+    if (char === '‘') { quote = '’'; continue; }
+    if (char === '「') { quote = '」'; continue; }
     if (char === '"' || char === '`') { quote = char; continue; }
     if (/[:：]/.test(char) || (/[—·–]/.test(char) && /\s/.test(title[i - 1] ?? '') && /\s/.test(title[i + 1] ?? ''))) {
       return title.slice(0, i).trim();

package/scripts/retro/shadow-compare.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env bun
+/**
+ * RETRO-DAILY 그림자 대조 — 매일 회고 그래프를 «정답지»(RFC §0 다섯 반복 문제) 위에서 돌려 맞혔는지 본다.
+ *
+ *   bun scripts/retro/shadow-compare.ts [--facts <facts.json>] [--key <answer-key.json>] [--json]
+ *
+ * 기본 입력 = test/fixtures/retro/ 의 10-07 사실 ⊕ 정답지. 그래프는 임시 우주(mkdtemp)에서 shadow 로만 돈다 —
+ * 운영 회고 파일·체크리스트·메시지 어느 것도 건드리지 않는다. 놓친 주제가 있으면 exit 1.
+ */
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { runGraph } from '../../src/graph-runner/runner.js';
+import { retroDayFile } from '../../src/retro/daily.js';
+
+const repo = resolve(import.meta.dir, '..', '..');
+export const RETRO_DAILY_GRAPH = join(repo, 'graphs', 'retro', 'daily.yaml');
+export const DEFAULT_FACTS = join(repo, 'test', 'fixtures', 'retro', 'rfc0-2026-10-07-facts.json');
+export const DEFAULT_KEY = join(repo, 'test', 'fixtures', 'retro', 'rfc0-answer-key.json');
+
+type Theme = { theme: string; title: string; recurring: boolean; reBrokeAfterGreen: boolean; rank: number };
+type Key = { day: string; greenCells?: unknown[]; expected: { theme: string; title: string; reBrokeAfterGreen?: boolean }[]; notRecurring?: string[] };
+export type ShadowComparison = {
+  ok: boolean; status: string; day: string; detected: string[]; missed: string[]; falsePositives: string[];
+  reBrokeMismatch: string[]; firstRank: string | null; actions: number; summary: string[]; wroteChecklist: boolean; mode: string;
+};
+
+export function compareWithKey(dayFile: { themes: Theme[]; actions: unknown[]; summary: string[]; mode: string }, key: Key, status = 'done'): Omit<ShadowComparison, 'wroteChecklist'> {
+  const recurring = dayFile.themes.filter(t => t.recurring);
+  const detected = recurring.map(t => t.theme);
+  const missed = key.expected.filter(e => !detected.includes(e.theme)).map(e => e.theme);
+  // 정답지 밖의 반복 주제는 전부 오탐이다(목록에 적은 것만 보지 않는다).
+  const expected = new Set(key.expected.map(e => e.theme));
+  const falsePositives = [...new Set([...detected.filter(t => !expected.has(t)), ...(key.notRecurring ?? []).filter(t => detected.includes(t))])];
+  const reBrokeMismatch = key.expected.filter(e => e.reBrokeAfterGreen !== undefined
+    && recurring.find(t => t.theme === e.theme)?.reBrokeAfterGreen !== e.reBrokeAfterGreen).map(e => e.theme);
+  const firstRank = recurring.sort((a, b) => a.rank - b.rank)[0]?.theme ?? null;
+  // «초록 뒤 재발»이 정답지에 있으면 그것이 1순위여야 한다(RFC §1 recur).
+  const mustLead = key.expected.find(e => e.reBrokeAfterGreen)?.theme;
+  const ok = status === 'done' && !missed.length && !falsePositives.length && !reBrokeMismatch.length
+    && (!mustLead || firstRank === mustLead) && dayFile.actions.length <= 3 && dayFile.summary.length === 3;
+  return { ok, status, day: key.day, detected, missed, falsePositives, reBrokeMismatch, firstRank, actions: dayFile.actions.length, summary: dayFile.summary, mode: dayFile.mode };
+}
+
+export async function runShadowComparison(factsFile = DEFAULT_FACTS, keyFile = DEFAULT_KEY): Promise<ShadowComparison> {
+  const key = JSON.parse(readFileSync(keyFile, 'utf8')) as Key;
+  const root = mkdtempSync(join(tmpdir(), 'retro-shadow-'));
+  try {
+    const run = await runGraph(RETRO_DAILY_GRAPH, { input: { factsFile: resolve(factsFile), day: key.day, greenCells: key.greenCells ?? [], mode: 'shadow' }, deps: { root } });
+    if (run.status !== 'done') return { ok: false, status: run.status, day: key.day, detected: [], missed: key.expected.map(e => e.theme), falsePositives: [], reBrokeMismatch: [], firstRank: null, actions: 0, summary: [], wroteChecklist: false, mode: 'shadow' };
+    const dayFile = JSON.parse(readFileSync(retroDayFile(root, key.day), 'utf8'));
+    const act = run.nodes.find(n => n.nodeId === 'act');
+    const wroteChecklist = typeof act?.output === 'string' && /"wroteChecklist":true/.test(act.output);
+    const result = compareWithKey(dayFile, key, run.status);
+    return { ...result, ok: result.ok && !wroteChecklist && dayFile.mode === 'shadow', wroteChecklist };
+  } finally { rmSync(root, { recursive: true, force: true }); }
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const flag = (name: string) => { const i = args.indexOf(name); return i >= 0 ? args[i + 1] : undefined; };
+  const result = await runShadowComparison(flag('--facts'), flag('--key'));
+  console.log(args.includes('--json') ? JSON.stringify(result) : [
+    `retro-daily 그림자 대조 ${result.ok ? 'OK' : 'MISS'} · ${result.day} · status=${result.status} · mode=${result.mode}`,
+    `잡음: ${result.detected.join(', ') || '없음'}`,
+    `놓침: ${result.missed.join(', ') || '없음'} · 오탐: ${result.falsePositives.join(', ') || '없음'} · 초록뒤재발 불일치: ${result.reBrokeMismatch.join(', ') || '없음'}`,
+    `1순위: ${result.firstRank ?? '없음'} · 조치 초안 ${result.actions} · 체크리스트 쓰기 ${result.wroteChecklist}`,
+    ...result.summary.map(line => `  ${line}`),
+  ].join('\n'));
+  if (!result.ok) process.exitCode = 1;
+}

package/scripts/rhythm/daily.ts

@@ -16,6 +16,7 @@ import { kindRouteTarget, mainHomeTarget } from '../../src/domains/telegram-kind
 import { recordOutbound } from '../../src/domains/outbound-alert.js';
 import { listSelfDevRuns, runSummaryLine, selfDevRunsDir } from '../../src/self-dev/run-store.js';
 import { runDraftSweep } from '../../src/self-dev/draft-sweep.js';
+import { retroBriefingLines } from '../../src/retro/daily.js';
 
 export type Section<T> = { status: 'ok'; value: T } | { status: 'unreadable'; reason: string };
 export type Landing = { title: string; seat: string; mergedAt: string; prNumber?: number };
@@ -529,6 +530,10 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
     .map(suggestion => `- ${suggestion.title} — ${suggestion.reason} (${suggestion.source}) [proact:${suggestion.key}]`).join('\n');
   const recorded = [retained, newSuggestions].filter(Boolean).join('\n');
   if (recorded) review.markdown += `\n## PROACT1-LITE 제안\n${recorded}\n`;
+  // RETRO-DAILY — 어젯밤 22:40 회고가 live 로 쓴 세 줄만 싣는다(shadow 회고는 브리핑에 안 나간다).
+  const retroLines = retroBriefingLines(deps.root ?? effectiveInstanceRoot(), kstDay(new Date(now.getTime() - 86_400_000)));
+  const retroBlock = retroLines.length ? `\n\n## 회고 세 줄\n${retroLines.map(line => `- ${line}`).join('\n')}` : '';
+  if (retroBlock) review.markdown += `${retroBlock.slice(1)}\n`;
   const file = join(deps.root ?? effectiveInstanceRoot(), 'rhythm', 'daily', `${kstDay(now)}.md`);
   if (!options.dryRun) {
     mkdirSync(dirname(file), { recursive: true });
@@ -548,7 +553,7 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
   let chars = 0;
   let target = 'unknown';
   if (!options.dryRun && options.stage !== 'collect' && enabled) {
-    const text = `${review.header}\n\n## 위험 톱 5\n${review.risks.map((r, i) => `${i + 1}. ${r.name} — ${r.score}점 · ${r.reason}`).join('\n') || '확인된 위험 없음'}${recorded ? `\n\n## PROACT1-LITE 제안\n${recorded}` : ''}\n\n${file}`;
+    const text = `${review.header}\n\n## 위험 톱 5\n${review.risks.map((r, i) => `${i + 1}. ${r.name} — ${r.score}점 · ${r.reason}`).join('\n') || '확인된 위험 없음'}${recorded ? `\n\n## PROACT1-LITE 제안\n${recorded}` : ''}${retroBlock}\n\n${file}`;
     chars = `${text}\n${receiptKey}`.length;
     let resolved: ReturnType<typeof recipient> = null;
     try { resolved = recipient(deps); }

package/scripts/video/scene-table.ts

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

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

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