elanous 0.2.18 → 0.2.19

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

@@ -0,0 +1,106 @@
+// GATE-PARTIAL (0.2.19 · 10-07): a re-gate after `release cut-branch --append` runs only the test files that can have
+// changed — not the whole 24-shard sweep again (0.2.18: two timeout fixes on top of an 84-minute gate meant another full
+// gate). The plan is opt-in (`release resume --from gate --partial`) and fail-closed: any non-test source change, a prior
+// gate record for another commit, or a missing record means «full gate», never a guess.
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+
+export interface PartialPlan {
+  version: string;
+  /** Commit the previous (full) gate measured — its recorded failures are carried for every file not re-run. */
+  priorCommit: string;
+  /** The commit this plan is for — a gate on any other commit ignores it. */
+  forCommit: string;
+  /** Test files re-run: changed test files ⊕ files of the prior failures. */
+  files: string[];
+  priorFailures: string[];
+  priorErrors: string[];
+}
+
+export const partialPlanPath = (root: string, version: string) => join(root, 'release', version, 'gate-partial.json');
+/** The same test-file set the gate sweep runs (`git ls-files` filtered by this suffix). */
+const TEST_FILE = /^(?:[\w.-]+\/)*[\w.-]+\.test\.(?:tsx?|jsx?|mts|cts)$/;
+/** Changes that cannot alter a test result on their own: Markdown that is not test input. A fixture (any file under a
+ *  test/, fixtures, __fixtures__ or __snapshots__ path), JSON or script is not inert — the gate runs in full. */
+const INERT_MD = /\.md$/;
+const TEST_INPUT = /(?:^|\/)(?:test|tests|fixtures|__fixtures__|__snapshots__|__mocks__)\//;
+const isInert = (file: string) => INERT_MD.test(file) && !TEST_INPUT.test(file);
+
+/** The test file of a failure id (`<file> > <case>`). One rule for the gate and the partial plan: ids come only from the
+ *  gate's output parsers, which accept `dir/….test.ts(x)` — anything else (a root file, `..`, no case) is unsafe. */
+export function testFileOfId(id: string): string {
+  const file = id.split(' > ', 1)[0]!;
+  if (!id.includes(' > ') || !/^(?:[\w.-]+\/)+[\w.-]+\.test\.tsx?$/.test(file) || file.split('/').includes('..')) throw new Error(`unsafe test path: ${file}`);
+  return file;
+}
+
+/** Decide whether a partial re-gate is safe for `changedFiles` (prior → for). Never guesses: any doubt is a full gate. */
+export function planPartialRegate(input: { version: string; priorCommit: string; forCommit: string; changedFiles: readonly string[];
+  priorFailures: readonly string[]; priorErrors: readonly string[] }):
+  { ok: true; plan: PartialPlan } | { ok: false; reason: string } {
+  if (!/^[0-9a-f]{40}$/i.test(input.priorCommit) || !/^[0-9a-f]{40}$/i.test(input.forCommit)) return { ok: false, reason: 'commit is not a full sha' };
+  if (input.priorCommit === input.forCommit) return { ok: false, reason: 'no new commit since the prior gate' };
+  const source = input.changedFiles.filter((file) => !TEST_FILE.test(file) && !isInert(file));
+  if (source.length) return { ok: false, reason: `non-test change → full gate: ${source.slice(0, 5).join(', ')}${source.length > 5 ? ` (+${source.length - 5})` : ''}` };
+  let failureFiles: string[];
+  try { failureFiles = [...input.priorFailures, ...input.priorErrors].map(testFileOfId); }
+  catch (error) { return { ok: false, reason: String(error instanceof Error ? error.message : error) }; }
+  const files = [...new Set([...input.changedFiles.filter((file) => TEST_FILE.test(file)), ...failureFiles])].sort();
+  if (!files.length) return { ok: false, reason: 'nothing to re-run' };
+  return { ok: true, plan: { version: input.version, priorCommit: input.priorCommit, forCommit: input.forCommit, files,
+    priorFailures: [...input.priorFailures], priorErrors: [...input.priorErrors] } };
+}
+
+export function writePartialPlan(root: string, plan: PartialPlan): string {
+  const path = partialPlanPath(root, plan.version);
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(plan, null, 2)}\n`, { mode: 0o600 });
+  renameSync(temp, path);
+  return path;
+}
+
+export function clearPartialPlan(root: string, version: string): void {
+  const path = partialPlanPath(root, version);
+  if (existsSync(path)) rmSync(path);
+}
+
+/** The plan for exactly this commit, or null. A malformed plan is an error (never silently a full or partial gate). */
+export function readPartialPlan(roots: readonly string[], version: string, commit: string): PartialPlan | null {
+  for (const root of roots) {
+    const path = partialPlanPath(root, version);
+    if (!existsSync(path)) continue;
+    const raw = JSON.parse(readFileSync(path, 'utf8')) as Partial<PartialPlan>;
+    if (raw.version !== version || typeof raw.priorCommit !== 'string' || !/^[0-9a-f]{40}$/i.test(raw.priorCommit)
+      || typeof raw.forCommit !== 'string' || !/^[0-9a-f]{40}$/i.test(raw.forCommit) || raw.priorCommit === raw.forCommit
+      || !Array.isArray(raw.files) || raw.files.length === 0 || !raw.files.every((file) => typeof file === 'string' && TEST_FILE.test(file) && !file.split('/').includes('..'))
+      || !Array.isArray(raw.priorFailures) || !Array.isArray(raw.priorErrors)) throw new Error(`invalid gate partial plan: ${path}`);
+    // Every prior failure's file is re-run (planPartialRegate guarantees it) — a plan that would carry a failure it did
+    // not re-run is malformed, not «partial».
+    const rerun = new Set(raw.files);
+    let failureFiles: string[];
+    try { failureFiles = [...raw.priorFailures, ...raw.priorErrors].map((id) => testFileOfId(String(id))); }
+    catch { throw new Error(`invalid gate partial plan: ${path}`); }
+    if (failureFiles.some((file) => !rerun.has(file))) throw new Error(`invalid gate partial plan (prior failure not re-run): ${path}`);
+    if (raw.forCommit !== commit) continue;
+    return raw as PartialPlan;
+  }
+  return null;
+}
+
+/** Cut failures after a partial re-run: prior results for files not re-run ⊕ this run's results for the re-run files. */
+export function mergePartialFailures(plan: PartialPlan, measured: { failures: string[]; errors: string[] }): { failures: string[]; errors: string[] } {
+  const rerun = new Set(plan.files);
+  const keep = (ids: readonly string[]) => ids.filter((id) => !rerun.has(testFileOfId(id)));
+  return { failures: [...keep(plan.priorFailures), ...measured.failures], errors: [...keep(plan.priorErrors), ...measured.errors] };
+}
+
+/** Files changed between two commits — both sides of a rename (`--no-renames`), so moving a source file into a test or
+ *  Markdown name still shows the source path that disappeared. */
+export function changedFilesBetween(repo: string, from: string, to: string): string[] {
+  // git-spawn-allow: read-only diff of two release commits.
+  const result = spawnSync('git', ['diff', '--name-only', '--no-renames', `${from}..${to}`], { cwd: repo, encoding: 'utf8' });
+  if (result.status !== 0 || result.error) throw new Error(`git diff failed: ${(result.stderr || result.error || 'no output').toString().trim()}`);
+  return result.stdout.split(/\r?\n/).filter(Boolean);
+}

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

@@ -0,0 +1,120 @@
+// F5 GATE-TIMING-REPORT — 게이트 한 판의 «시간 비용»을 보이게 한다(GATE-SPEED 의 자).
+// 입력 = 게이트 로그 디렉토리(`<ledger>/release/<version>/gate-logs/cut`)의 `pod-*.json`.
+//   첫 판 샤드 = `pod-<n>.json` · 재시도 = 그 밖의 모든 `pod-*.json`(`-c<k>`·`-c<k>-file-<m>`·`-retry` …).
+// ⛔ 측정이 없으면 `measured:false` 로 표시한다 — 0 을 «잰 값»처럼 내지 않는다.
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { releaseLedgerRoot } from '../../src/instance/resolve.js';
+
+export interface ShardTiming { name: string; min: number; files: number; plannedMin: number | null }
+
+export interface GateTimingReport {
+  dir: string;
+  /** 읽은 pod-*.json 중 durationMs 를 가진 것이 하나라도 있었나. false 면 아래 수는 «측정 없음». */
+  measured: boolean;
+  /** JSON 파싱 실패·durationMs 부재로 건너뛴 파일 이름. */
+  unreadable: string[];
+  firstPass: { shards: number; sumMin: number; medianMin: number; maxMin: number; failedShards: string[] };
+  retries: { runs: number; sumMin: number; medianMin: number };
+  /** 재시도 합 / (첫 판 합 + 재시도 합). 측정이 없으면 null. */
+  retryShare: number | null;
+  slowestShards: ShardTiming[];
+}
+
+const FIRST_PASS = /^pod-\d+\.json$/;
+const POD_JSON = /^pod-.+\.json$/;
+
+const round1 = (n: number) => Math.round(n * 10) / 10;
+
+function median(xs: number[]): number {
+  if (xs.length === 0) return 0;
+  const s = [...xs].sort((a, b) => a - b);
+  const m = s.length >> 1;
+  return s.length % 2 ? s[m]! : (s[m - 1]! + s[m]!) / 2;
+}
+
+interface PodRecord { durationMs?: unknown; rc?: unknown; files?: unknown; plannedSeconds?: unknown; jobFailed?: unknown }
+
+export function gateTiming(dir: string): GateTimingReport {
+  const names = existsSync(dir) && statSync(dir).isDirectory()
+    ? readdirSync(dir).filter((n) => POD_JSON.test(n)).sort((a, b) => a.localeCompare(b, 'en', { numeric: true }))
+    : [];
+  const first: Array<ShardTiming & { failed: boolean }> = [];
+  const retryMin: number[] = [];
+  const unreadable: string[] = [];
+  for (const name of names) {
+    let rec: PodRecord;
+    try { rec = JSON.parse(readFileSync(join(dir, name), 'utf8')) as PodRecord; } catch { unreadable.push(name); continue; }
+    if (!rec || typeof rec !== 'object' || typeof rec.durationMs !== 'number' || !Number.isFinite(rec.durationMs)) { unreadable.push(name); continue; }
+    const min = rec.durationMs / 60_000;
+    if (FIRST_PASS.test(name)) {
+      first.push({
+        name: name.replace(/\.json$/, ''),
+        min,
+        files: Array.isArray(rec.files) ? rec.files.length : 0,
+        plannedMin: typeof rec.plannedSeconds === 'number' ? rec.plannedSeconds / 60 : null,
+        failed: rec.jobFailed === true || (typeof rec.rc === 'number' && rec.rc !== 0),
+      });
+    } else {
+      retryMin.push(min);
+    }
+  }
+  const firstMins = first.map((s) => s.min);
+  const firstSum = firstMins.reduce((a, b) => a + b, 0);
+  const retrySum = retryMin.reduce((a, b) => a + b, 0);
+  const total = firstSum + retrySum;
+  const measured = first.length + retryMin.length > 0;
+  return {
+    dir,
+    measured,
+    unreadable,
+    firstPass: {
+      shards: first.length,
+      sumMin: round1(firstSum),
+      medianMin: round1(median(firstMins)),
+      maxMin: round1(firstMins.length ? Math.max(...firstMins) : 0),
+      failedShards: first.filter((s) => s.failed).map((s) => s.name),
+    },
+    retries: { runs: retryMin.length, sumMin: round1(retrySum), medianMin: round1(median(retryMin)) },
+    retryShare: measured && total > 0 ? Math.round((retrySum / total) * 1000) / 1000 : null,
+    slowestShards: [...first].sort((a, b) => b.min - a.min).slice(0, 5)
+      .map(({ name, min, files, plannedMin }) => ({ name, min: round1(min), files, plannedMin: plannedMin === null ? null : round1(plannedMin) })),
+  };
+}
+
+/** `<version>` 이면 원장 루트(`releaseLedgerRoot()`)의 `release/<version>/gate-logs/cut`, 경로처럼 보이면 그대로. */
+export function resolveGateLogDir(arg: string, ledgerRoot: string = releaseLedgerRoot()): string {
+  if (arg.includes('/') || arg.startsWith('.') || existsSync(arg)) return arg;
+  return join(ledgerRoot, 'release', arg, 'gate-logs', 'cut');
+}
+
+export function formatGateTiming(r: GateTimingReport): string {
+  if (!r.measured) {
+    return [`게이트 시간 — 측정 없음 (${r.dir})`, '  pod-*.json 에 durationMs 가 하나도 없다 · 0 은 «잰 값»이 아니다',
+      ...(r.unreadable.length ? [`  읽지 못한 파일 ${r.unreadable.length}개`] : [])].join('\n');
+  }
+  const f = r.firstPass;
+  const lines = [
+    `게이트 시간 (${r.dir})`,
+    `  첫 판   샤드 ${f.shards}개 · 합 ${f.sumMin}분 · 중앙 ${f.medianMin}분 · 최대 ${f.maxMin}분 · 실패 샤드 ${f.failedShards.length}개${f.failedShards.length ? ` (${f.failedShards.join(', ')})` : ''}`,
+    `  재시도  ${r.retries.runs}회 · 합 ${r.retries.sumMin}분 · 중앙 ${r.retries.medianMin}분`,
+    `  재시도 비중 ${r.retryShare === null ? '측정 없음' : `${round1(r.retryShare * 100)}%`} (재시도 합 / 전체 합)`,
+    '  느린 샤드 상위 5:',
+    ...r.slowestShards.map((s) => `    ${s.name}  ${s.min}분 · 파일 ${s.files}개 · 계획 ${s.plannedMin === null ? '—' : `${s.plannedMin}분`}`),
+  ];
+  if (r.unreadable.length) lines.push(`  ⚠ 읽지 못한 파일 ${r.unreadable.length}개: ${r.unreadable.slice(0, 5).join(', ')}${r.unreadable.length > 5 ? ' …' : ''}`);
+  return lines.join('\n');
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const json = args.includes('--json');
+  const target = args.find((a) => !a.startsWith('--'));
+  if (!target) {
+    console.error('사용법: bun scripts/release-loop/gate-timing.ts <version|dir> [--json]');
+    process.exit(2);
+  }
+  const report = gateTiming(resolveGateLogDir(target));
+  console.log(json ? JSON.stringify(report, null, 2) : formatGateTiming(report));
+  if (!report.measured) process.exit(1);
+}

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

@@ -2,12 +2,13 @@
 // 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 { 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 +25,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 +109,66 @@ 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');
   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, ...(deps.root || deps.runBash ? { deps: { ...(deps.root ? { 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

@@ -19,6 +19,8 @@ export interface ReleaseLoopConfig {
   gatePodBunCache?: string;
   gatePodShards?: number;
   gatePodShardTimeoutSeconds?: 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[];

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 });