elanous 0.2.29 → 0.2.31

package/src/release-loop/placement.ts

@@ -6,7 +6,7 @@ import { resolveRepositoryName } from '../harness/repository-name.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { userConfigPath } from '../user-config.js';
-import { addItem, checklistHistory, listChecklist, ownerMatches, parseOwner, setItem, validateCeoLoad, type ChecklistItem } from './checklist.js';
+import { addItem, checklistHistory, inspectChecklistTargetPaths, listChecklist, ownerMatches, parseOwner, setItem, validateCeoLoad, type ChecklistItem } from './checklist.js';
 import { assignedVersions, move, releasedVersion } from './feature-store.js';
 import { debug } from '../debug/log.js';
 import { kstDay, listSchedules, type ReleaseSchedule } from './release-schedule.js';
@@ -110,6 +110,12 @@ function validCeoCap(cap: number): number {
 
 export function placementCeoDailyCap(): number { return validCeoCap(placementConfig().ceoDailyCap ?? 30); }
 
+/** One configuration snapshot for the read-only pull-forward caller. */
+export function pullForwardPlacementConfig(): { seatCap: Record<string, number>; ceoDailyCap: number; ceoCalendar: CeoCalendar } {
+  const config = placementConfig();
+  return { seatCap: config.seatCap ?? {}, ceoDailyCap: validCeoCap(config.ceoDailyCap ?? 30), ceoCalendar: config.ceoCalendar ?? {} };
+}
+
 function validDay(day: string): boolean {
   return typeof day === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(day) && Number.isFinite(Date.parse(`${day}T00:00:00Z`))
     && new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) === day;
@@ -406,6 +412,91 @@ export function rebalance(version: string, deps: PlacementDeps = {}): RebalanceR
   return result;
 }
 
+export interface PullForwardDeps {
+  now: Date;
+  schedules: readonly ReleaseSchedule[];
+  checklists: ReadonlyMap<string, readonly ChecklistItem[]>;
+  released: string;
+  merged24h: number;
+  seatCap: Record<string, number>;
+  ceoDailyCap: number;
+  ceoCalendar: CeoCalendar;
+  signal: { order?: readonly string[]; hold?: readonly string[] };
+  targetPathExists: (path: string) => boolean;
+  backlog?: readonly string[];
+}
+
+/** Read-only plan: every operational input is supplied by the caller. */
+export function planPullForward(deps: PullForwardDeps): RebalanceResult {
+  if (typeof deps.targetPathExists !== 'function') throw new CliUserError('대상 저장소 경로 판정기가 필요하다');
+  const rows = [...deps.schedules].sort((a, b) => versionOrder(a.version, b.version));
+  const now = deps.now.getTime();
+  const backlog = deps.backlog ?? BACKLOG_VERSIONS;
+  const released = deps.released;
+  const open = rows.filter((row) => (!released || versionOrder(row.version, released) > 0) && available(row, now, backlog));
+  const target = open[0];
+  if (!target) throw new CliUserError('당겨올 판이 없다 — 착지 마감이 안 지난 판이 필요하다');
+  const result: RebalanceResult = { decisions: [], blocked: [] };
+  const source = rows.find((row) => versionOrder(row.version, target.version) > 0 && !backlog.includes(row.version));
+  if (!source || !available(source, now, backlog)) return result;
+  const sources = [...new Set([...rows.map((row) => row.version), ...deps.checklists.keys(), ...backlog])];
+  const snapshots = new Map(sources.map((version) => [version, [...(deps.checklists.get(version) ?? [])]]));
+  const remainingP0 = snapshots.get(target.version)!.filter((item) => item.priority === 'P0' && item.status !== 'green' && item.status !== 'done').length;
+  const hold = new Set(deps.signal?.hold ?? []);
+  const rank = new Map<string, number>();
+  for (const [index, id] of (deps.signal?.order ?? []).entries()) if (!rank.has(id)) rank.set(id, index);
+  // Untyped legacy cells are fail-closed on human-action words in either language. These
+  // conservative markers may exclude code about approvals, but must never move a manual gate.
+  const human = /\uD83D\uDC51|실기기|실기 |사람|대표|손|라이브 1회|녹화|세미나|수동|승인|검토|결정|HITL|manual|human|approval|sign.off|review|operator|ceo/i;
+  const complete = new Set<string>();
+  const incomplete = new Set<string>();
+  for (const items of snapshots.values()) for (const item of items) {
+    if (item.status === 'green' || item.status === 'done') complete.add(item.id);
+    else incomplete.add(item.id);
+  }
+  const targetPathsReady = (title: string): boolean => {
+    const check = inspectChecklistTargetPaths({ title }, { existsAtMain: deps.targetPathExists });
+    return check.targets.length > 0 && check.warnings.length === 0;
+  };
+  const candidates = snapshots.get(source.version)!.filter((item) =>
+    (item.priority === 'P0' || item.priority === 'P1') && item.status !== 'green' && item.status !== 'done'
+    && !hold.has(item.id) && !human.test(item.title) && (!item.dispatchKind || item.dispatchKind === 'code')
+    && (item.ceoMinutes === undefined || item.ceoMinutes === 0)
+    && targetPathsReady(item.title)
+    && (item.predecessors ?? []).every((id) => complete.has(id) && !incomplete.has(id)))
+    .map((item, index) => ({ item, index }))
+    .sort((a, b) => (rank.get(a.item.id) ?? Infinity) - (rank.get(b.item.id) ?? Infinity)
+      || (a.item.priority === 'P0' ? 0 : 1) - (b.item.priority === 'P0' ? 0 : 1) || a.index - b.index);
+  if (!candidates.length) return result;
+  if (Date.parse(target.landBy ?? target.cutAt) - now < 4 * 60 * 60 * 1000) {
+    for (const { item } of candidates)
+      result.blocked.push({ id: item.id, from: source.version, to: target.version, reason: `지금 판 ${target.version} 착지 마감까지 4시간 미만 — 당겨오기 보류` });
+    return result;
+  }
+  if (remainingP0 > 3) {
+    for (const { item } of candidates)
+      result.blocked.push({ id: item.id, from: source.version, to: target.version, reason: `지금 판 ${target.version} 남은 P0 ${remainingP0} > 3 — 당겨오기 보류` });
+    return result;
+  }
+  const rate = deps.merged24h;
+  if (!Number.isInteger(rate) || rate < 0) throw new CliUserError('24시간 병합 PR 수가 잘못됐다');
+  const caps = deps.seatCap;
+  const ceoCap = validCeoCap(deps.ceoDailyCap);
+  const calendar = deps.ceoCalendar;
+  for (const { item } of candidates) {
+    if (result.decisions.length >= 5) break;
+    const from = source.version;
+    // The pull-forward contract uses the schedule's cutAt only when landBy is absent.
+    const destination = { ...target, landBy: target.landBy ?? target.cutAt };
+    const violation = moveConstraint(item, destination, backlog, snapshots, now, rate, caps, rows, ceoCap, calendar, released);
+    if (violation) { result.blocked.push({ id: item.id, from, to: target.version, reason: violation }); continue; }
+    result.decisions.push({ id: item.id, from, version: target.version, reason: `다음 판 ${from} → 지금 판 ${target.version} 당겨오기 · 남은 P0 ${remainingP0} ≤ 3 · 착지 마감 ≥ 4h`, displaced: [] });
+    snapshots.set(from, snapshots.get(from)!.filter((cell) => cell.id !== item.id));
+    snapshots.get(target.version)!.push(item);
+  }
+  return result;
+}
+
 /** Reasons that justify a second forward rollover of the same cell (대표 10-10 «계속 이월되지 않게»). */
 const SECOND_ROLLOVER_REASON_PREFIXES: readonly string[] = ['쪼개기:', '닫기:', '\u{1F451}:'];
 

package/src/release-loop/rehearsal-shard-plan.ts

@@ -0,0 +1,149 @@
+import { spawnSync } from 'node:child_process';
+import { availableParallelism, cpus as hostCpus, freemem, totalmem } from 'node:os';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { selectGateTestFiles } from '../self-implement/gate-cli.js';
+import { readFileMemory } from '../../scripts/release-loop/shard-plan.js';
+import { gateShardsPath, readGateShards } from './gate-shards.js';
+import { LIGHT_RC_ALWAYS_FILE, LIGHT_RC_DEFAULT_SHARDS, parseAlwaysIncludeList, previousCutBase } from './light-rc.js';
+
+const FILE_MEMORY_SOURCE = 'docs/measurements/td1-whole-gate-mechanical-2026-10-01.tsv';
+
+export interface RehearsalShardPlan {
+  shards: number;
+  testFiles: number | null;
+  /** Observed on the tick host, not necessarily the remote gate host. */
+  resources: { cpus: number; freeBytes: number; totalBytes: number };
+  gatePlanShards: number | null;
+  /** Local preflight budget, not a measured remote peak-RSS or a workload-specific guarantee. */
+  capacity?: { reserveBytes: number; bytesPerShard: number; memoryShards: number | null; requiredBytes: number; measuredFiles: number; peakFileBytes: number | null };
+  unmeasured: string | null;
+  /** The remote host's capacity is checked by the actual RC, after this preflight. */
+  remoteCapacityPending?: boolean;
+  rssRevisionPending?: boolean;
+  planningGaps?: string[];
+  remoteCapacityVerifiedBy?: string;
+}
+
+export interface RehearsalShardPlanDeps {
+  /** Rehearsal light RC dispatches remotely; local CPU/memory is evidence only, not a gate-host limit. */
+  remoteGate?: boolean;
+  select?: (checkout: string, options: { base: string; alwaysInclude: string[]; includeImporterTests: true }) => { testFiles: string[]; alwaysIncludeMissing?: readonly string[]; lookupFailed?: string | null; unrunImporterTotal?: number | null; skipTestStep?: boolean; routeLookupFailures?: readonly unknown[]; unverified?: readonly string[]; callerTestsOverflow?: readonly unknown[] };
+  resources?: () => RehearsalShardPlan['resources'];
+  board?: typeof readGateShards;
+  readAlways?: (path: string) => string;
+  resolveBase?: (version: string, checkout: string, root: string) => string;
+  fileMemory?: (path: string) => Map<string, number>;
+}
+
+/** Preflight only: the gate still performs its own selection at execution time. The local budget uses measured
+ * selected-file peak RSS with a 2 GiB floor per shard and reserves 1 GiB for the host. The RC result is the
+ * authority for whether execution on its actual gate host succeeded. */
+const GIB = 1024 ** 3;
+const RESERVE_BYTES = GIB;
+const BYTES_PER_SHARD = 2 * GIB;
+
+/** The dated TSV has no dependency graph/revision. Require the whole checkout to match its source commit;
+ * otherwise RSS is provisional until a completed RC measures this actual checkout on its gate host. */
+function measurementMatchesCheckout(checkout: string): boolean {
+  const source = spawnSync('git', ['log', '-1', '--format=%H', '--', FILE_MEMORY_SOURCE], { cwd: checkout, encoding: 'utf8' });
+  const commit = source.stdout?.trim();
+  if (source.status !== 0 || !/^[0-9a-f]{40}$/.test(commit ?? '')) return false;
+  const diff = spawnSync('git', ['diff', '--quiet', commit!, 'HEAD', '--', '.'], { cwd: checkout, encoding: 'utf8' });
+  if (diff.status !== 0) return false;
+  const working = spawnSync('git', ['status', '--porcelain', '--untracked-files=all'], { cwd: checkout, encoding: 'utf8' });
+  return working.status === 0 && !working.stdout?.trim();
+}
+
+/** OS free memory can describe the entire host rather than the tick's container; bound it by cgroup headroom. */
+export function rehearsalHostResources(read: (path: string) => string = (path) => readFileSync(path, 'utf8')): RehearsalShardPlan['resources'] {
+  const cpus = Math.max(1, Number(availableParallelism?.() ?? hostCpus()?.length ?? 1) || 1);
+  let freeBytes = freemem(), totalBytes = totalmem();
+  for (const [limitPath, usagePath] of [
+    ['/sys/fs/cgroup/memory.max', '/sys/fs/cgroup/memory.current'],
+    ['/sys/fs/cgroup/memory/memory.limit_in_bytes', '/sys/fs/cgroup/memory/memory.usage_in_bytes'],
+  ]) {
+    try {
+      const limit = Number(read(limitPath).trim()), usage = Number(read(usagePath).trim());
+      if (Number.isSafeInteger(limit) && limit > 0 && limit < totalBytes && Number.isSafeInteger(usage) && usage >= 0) {
+        totalBytes = limit;
+        freeBytes = Math.min(freeBytes, Math.max(0, limit - usage));
+        break;
+      }
+    } catch { /* not running inside this cgroup version */ }
+  }
+  return { cpus, freeBytes, totalBytes };
+}
+
+export function planRehearsalShards(version: string, root: string, checkout: string, deps: RehearsalShardPlanDeps = {}): RehearsalShardPlan {
+  const reasons: string[] = [];
+  let rssRevisionPending = false;
+  let resources: RehearsalShardPlan['resources'];
+  try { resources = (deps.resources ?? rehearsalHostResources)(); }
+  catch (error) {
+    resources = { cpus: 0, freeBytes: 0, totalBytes: 0 };
+    reasons.push(`host resource probe failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let gatePlanShards: number | null = null;
+  try {
+    const board = (deps.board ?? readGateShards)(gateShardsPath(version, root));
+    gatePlanShards = board?.version === version && board.shards.length && new Set(board.shards.map(shard => shard.id)).size === board.shards.length ? board.shards.length : null;
+  } catch (error) { reasons.push(`persisted gate shard plan unreadable: ${error instanceof Error ? error.message : String(error)}`); }
+  let testFiles: number | null = null;
+  let measuredFiles = 0;
+  let peakFileBytes: number | null = null;
+  try {
+    const path = join(checkout, LIGHT_RC_ALWAYS_FILE);
+    const text = deps.readAlways ? deps.readAlways(path) : existsSync(path) ? readFileSync(path, 'utf8') : undefined;
+    if (text === undefined) throw new Error(`${LIGHT_RC_ALWAYS_FILE} missing`);
+    const base = (deps.resolveBase ?? ((v, cwd, ledgerRoot) => previousCutBase(v, { cwd, ledgerRoot })))(version, checkout, root);
+    const selection = (deps.select ?? ((cwd, opts) => selectGateTestFiles(cwd, opts)))(checkout, { base, alwaysInclude: parseAlwaysIncludeList(text), includeImporterTests: true });
+    const files = [...new Set(selection.testFiles)];
+    testFiles = files.length;
+    try {
+      const memory = (deps.fileMemory ?? readFileMemory)(join(checkout, FILE_MEMORY_SOURCE));
+      const peaks = files.map(file => memory.get(file)).filter((value): value is number => value !== undefined && Number.isFinite(value) && value > 0);
+      measuredFiles = peaks.length;
+      if (peaks.length) peakFileBytes = Math.ceil(peaks.reduce((largest, value) => Math.max(largest, value), 0) * 1_000_000);
+      if (measuredFiles !== testFiles) reasons.push(`selected file memory not measured: ${testFiles - measuredFiles}/${testFiles}`);
+      if (!deps.fileMemory && files.length && !measurementMatchesCheckout(checkout)) {
+        if (deps.remoteGate) rssRevisionPending = true;
+        else reasons.push('selected file RSS measurement revision not verified against checkout');
+      }
+    } catch (error) { reasons.push(`selected file memory unavailable: ${error instanceof Error ? error.message : String(error)}`); }
+    if (selection.alwaysIncludeMissing?.length) reasons.push(`always-include missing: ${selection.alwaysIncludeMissing.join(', ')}`);
+    if (selection.lookupFailed) reasons.push(`importer lookup failed: ${selection.lookupFailed}`);
+    if (selection.unrunImporterTotal === undefined) reasons.push('importer coverage not reported');
+    if (selection.unrunImporterTotal === null || (selection.unrunImporterTotal ?? 0) > 0) reasons.push(`importer tests not run: ${selection.unrunImporterTotal ?? 'unknown'}`);
+    if (selection.routeLookupFailures?.length) reasons.push(`route lookup failed: ${selection.routeLookupFailures.length}`);
+    if (selection.unverified?.length) reasons.push(`unverified scope: ${selection.unverified.length}`);
+    if (selection.callerTestsOverflow?.length) reasons.push(`caller tests overflow: ${selection.callerTestsOverflow.length}`);
+    if (selection.skipTestStep) reasons.push('gate test step skipped');
+    if (!testFiles) reasons.push('selected test files empty');
+  } catch (error) { reasons.push(`test selection unavailable: ${error instanceof Error ? error.message : String(error)}`); }
+  if (gatePlanShards === null) reasons.push('persisted gate shard plan unavailable');
+  const cpuValid = Number.isSafeInteger(resources.cpus) && resources.cpus > 0;
+  const memoryValid = Number.isFinite(resources.freeBytes) && resources.freeBytes >= 0 && Number.isFinite(resources.totalBytes) && resources.totalBytes > 0 && resources.freeBytes <= resources.totalBytes;
+  if (!deps.remoteGate && (!cpuValid || !memoryValid)) reasons.push('host resources unavailable');
+  const bytesPerShard = Math.max(BYTES_PER_SHARD, peakFileBytes ?? 0);
+  const memoryShards = memoryValid ? Math.max(0, Math.floor((resources.freeBytes - RESERVE_BYTES) / bytesPerShard)) : null;
+  const candidate = Math.max(1, Math.min(gatePlanShards ?? LIGHT_RC_DEFAULT_SHARDS, testFiles ?? LIGHT_RC_DEFAULT_SHARDS, deps.remoteGate ? Number.MAX_SAFE_INTEGER : cpuValid ? resources.cpus : LIGHT_RC_DEFAULT_SHARDS));
+  if (!deps.remoteGate && peakFileBytes !== null && memoryValid && resources.freeBytes < RESERVE_BYTES + peakFileBytes) {
+    reasons.push(`selected file peak exceeds host memory: peak ${peakFileBytes}, free ${resources.freeBytes}, reserve ${RESERVE_BYTES} bytes`);
+  }
+  // Never treat a 0-slot host as sufficient for one shard. The caller must leave an unrun step retryable.
+  const shards = deps.remoteGate || memoryShards === null ? candidate : Math.max(1, Math.min(candidate, memoryShards));
+  const capacity = { reserveBytes: RESERVE_BYTES, bytesPerShard, memoryShards, requiredBytes: RESERVE_BYTES + shards * bytesPerShard, measuredFiles, peakFileBytes };
+  if (!deps.remoteGate && memoryShards === 0) reasons.push(`host memory insufficient: free ${resources.freeBytes} < required ${capacity.requiredBytes} bytes for 1 shard`);
+  // The exported local planner has no local RC caller to validate aggregate workload capacity. A prior board's
+  // shard count and individual file peaks cannot prove that hundreds of tests fit one shard.
+  if (!deps.remoteGate) reasons.push('local gate shard workload sufficiency not measured');
+  // A complete selected-file measurement plus the persisted shard count and a valid host budget is enough to
+  // select a candidate. Execution on another host is judged by the RC result, not by a permanent preflight warning.
+  const remoteCapacityReason = 'remote gate host resources unmeasured before RC';
+  const rssRevisionReason = 'selected file RSS measurement revision not verified before RC';
+  return { shards, testFiles, resources, gatePlanShards, capacity,
+    ...(deps.remoteGate ? { remoteCapacityPending: true, rssRevisionPending, planningGaps: reasons } : {}),
+    unmeasured: reasons.length || deps.remoteGate ? [...reasons, ...(rssRevisionPending ? [rssRevisionReason] : []), ...(deps.remoteGate ? [remoteCapacityReason] : [])].join('; ') : null,
+  };
+}

package/src/release-loop/rehearsal.ts

@@ -1,11 +1,14 @@
 import { spawnSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-import { existsSync, linkSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, linkSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { sendOutbound } from '../domains/outbound-alert.js';
 import { releaseLedgerRoot } from '../instance/resolve.js';
-import { runLightRc, type LightRcResult } from './light-rc.js';
+import { isValidGateHost } from '../self-implement/gate-remote.js';
+import { LIGHT_RC_UNKNOWN_HOST, runLightRc, type LightRcResult } from './light-rc.js';
+import { planRehearsalShards, type RehearsalShardPlan, type RehearsalShardPlanDeps } from './rehearsal-shard-plan.js';
 import { listSchedules, type ReleaseSchedule } from './release-schedule.js';
 
 export type StepId = 'rc-7h' | 'rc-150m';
@@ -50,6 +53,9 @@ export interface RehearsalStamp {
   summary?: string;
   regressionFiles?: string[];
   result?: LightRcResult;
+  shardPlan?: RehearsalShardPlan;
+  leakCheck?: { outcome: 'ok' | 'fail'; sha: string; exitCode: number | null };
+  selection?: { shards?: number; remote?: string };
   notifiedAt?: string;
   ownerPid?: number;
 }
@@ -58,14 +64,19 @@ export interface RehearsalOptions {
   apply?: boolean;
   checkout?: string;
   ledgerRoot?: string;
+  shards?: number;
+  remote?: string;
 }
 
 export interface RehearsalDeps {
   now?: () => Date;
   schedules?: (root: string) => ReleaseSchedule[];
-  lightRc?: (version: string, checkout: string) => Promise<LightRcResult>;
+  lightRc?: (version: string, checkout: string, selection: { shards?: number; remote?: string }) => Promise<LightRcResult>;
+  shardPlan?: typeof planRehearsalShards;
+  shardPlanDeps?: RehearsalShardPlanDeps;
   notify?: (text: string) => void | boolean | Promise<void | boolean>;
   git?: (args: string[], cwd: string) => { rc: number | null; stdout: string; stderr?: string };
+  leakCheck?: (checkout: string) => { status: number | null };
 }
 
 export type RehearsalTickResult = RehearsalPlan & { applied?: boolean; stamps?: RehearsalStamp[]; notificationFailures?: number };
@@ -86,6 +97,17 @@ function gitResult(git: NonNullable<RehearsalDeps['git']>, args: string[], check
   return result.stdout.trim();
 }
 
+/** Public export checks the pinned rehearsal checkout before any remote RC work. Its output is private and ephemeral. */
+function runRehearsalLeakCheck(checkout: string): { status: number | null } {
+  const out = mkdtempSync(join(tmpdir(), 'elanous-rehearsal-export-'));
+  try {
+    const result = spawnSync('bun', ['scripts/public-export.ts', '--out', join(out, 'export')], {
+      cwd: checkout, encoding: 'utf8', timeout: 1_800_000, maxBuffer: 64 * 1024 * 1024,
+    });
+    return { status: result.status };
+  } finally { rmSync(out, { recursive: true, force: true }); }
+}
+
 function oneLine(text: string): string { return text.replace(/\s+/g, ' ').trim(); }
 
 function outcomeLine(stamp: RehearsalStamp): string {
@@ -95,7 +117,11 @@ function outcomeLine(stamp: RehearsalStamp): string {
   if (!stamp.result) return `${head}${stamp.summary ? ` · ${stamp.summary}` : ''}`;
   const result = stamp.result;
   const duration = Math.max(0, Math.round((Date.parse(stamp.endedAt!) - Date.parse(stamp.startedAt)) / minute));
-  return `${head} · 새 회귀 ${result.introduced ?? '못 쟀다'} · 기존 ${result.preexisting ?? '못 쟀다'} · 미분류 ${result.unclassified ?? '못 쟀다'} · ${result.remote ?? 'local'} · ${duration}분${stamp.outcome === 'error' ? ` · gate rc ${result.gateExitCode}${!result.ok ? ' · RC 실패' : ''}` : ''}${stamp.regressionFiles?.length ? ` · 파일 ${stamp.regressionFiles.slice(0, 3).join(', ')}` : ''}`;
+  const planningGap = stamp.shardPlan?.unmeasured
+    || (stamp.selection?.shards !== undefined && result.shards !== stamp.selection.shards)
+    || (stamp.selection?.remote !== undefined && result.remote !== stamp.selection.remote);
+  const detail = stamp.summary && (stamp.outcome === 'unmeasured' || stamp.outcome === 'error' && planningGap) ? ` · ${stamp.summary}` : '';
+  return `${head} · 새 회귀 ${result.introduced ?? '못 쟀다'} · 기존 ${result.preexisting ?? '못 쟀다'} · 미분류 ${result.unclassified ?? '못 쟀다'} · ${result.remote ?? 'local'} · ${duration}분${stamp.outcome === 'error' ? ` · gate rc ${result.gateExitCode}${!result.ok ? ' · RC 실패' : ''}` : ''}${stamp.regressionFiles?.length ? ` · 파일 ${stamp.regressionFiles.slice(0, 3).join(', ')}` : ''}${detail}`;
 }
 
 function persistStamp(path: string, stamp: RehearsalStamp): void {
@@ -207,6 +233,12 @@ function interruptStamp(path: string, saved: RehearsalStamp, now: Date): Rehears
 
 /** wx claim is permanent per version/step; a crashed run is reported as interrupted without running RC twice. */
 export async function runRehearsalTick(opts: RehearsalOptions = {}, deps: RehearsalDeps = {}): Promise<RehearsalTickResult> {
+  if (opts.shards !== undefined && (!Number.isSafeInteger(opts.shards) || opts.shards < 1)) {
+    throw new Error(`release rehearsal tick: invalid --shards count: ${opts.shards}`);
+  }
+  if (opts.remote !== undefined && !isValidGateHost(opts.remote)) {
+    throw new Error(`release rehearsal tick: invalid --remote host: ${opts.remote}`);
+  }
   const root = opts.ledgerRoot ?? releaseLedgerRoot();
   const now = (deps.now ?? (() => new Date()))();
   const schedules = (deps.schedules ?? listSchedules)(root);
@@ -289,26 +321,50 @@ export async function runRehearsalTick(opts: RehearsalOptions = {}, deps: Rehear
             gitResult(git, ['checkout', '-q', '--detach', 'origin/main'], checkout);
             stamp.sha = gitResult(git, ['rev-parse', 'HEAD'], checkout);
             if (!stamp.sha) throw new Error('git rev-parse HEAD returned no sha');
+            const leak = (deps.leakCheck ?? runRehearsalLeakCheck)(checkout);
+            stamp.leakCheck = { outcome: leak.status === 0 ? 'ok' : 'fail', sha: stamp.sha, exitCode: leak.status };
+            if (leak.status !== 0) throw new Error(`public export leak-check failed (rc=${leak.status ?? 'spawn'})`);
             const regressionFiles: string[] = [];
-            const result = await (deps.lightRc ?? ((version, cwd) => runLightRc(version, { ledgerRoot: root, head: stamp.sha, rehearsalTui: true, log: (line) => {
-              for (const entry of line.split(/\r?\n/)) {
-                const file = /^- introduced: (.+?)(?: > |$)/.exec(entry)?.[1];
-                if (file && regressionFiles.length < 3) regressionFiles.push(file);
-              }
-              console.error(line);
-            } }, { cwd })))(plan.version, checkout);
+            const shardPlan = opts.shards === undefined ? (deps.shardPlan ?? planRehearsalShards)(plan.version, root, checkout, { ...deps.shardPlanDeps, remoteGate: true }) : undefined;
+            if (shardPlan) stamp.shardPlan = shardPlan;
+            const selection = { shards: opts.shards ?? shardPlan?.shards, remote: opts.remote };
+            stamp.selection = selection;
+            const result = await (deps.lightRc ?? ((version, cwd) => runLightRc(version, { ledgerRoot: root, head: stamp.sha, ...selection, rehearsalTui: true, log: (line) => {
+                for (const entry of line.split(/\r?\n/)) {
+                  const file = /^- introduced: (.+?)(?: > |$)/.exec(entry)?.[1];
+                  if (file && regressionFiles.length < 3) regressionFiles.push(file);
+                }
+                console.error(line);
+              } }, { cwd })))(plan.version, checkout, selection);
             stamp.result = result;
             if (regressionFiles.length) stamp.regressionFiles = regressionFiles;
-            stamp.outcome = result.introduced === null || result.unclassified === null ? 'unmeasured'
-              : result.introduced > 0 ? 'regression'
-              : result.unclassified > 0 ? 'unmeasured'
-              : !result.ok || result.gateExitCode !== 0 ? 'error' : 'ok';
-            stamp.summary = oneLine(`introduced ${result.introduced} · preexisting ${result.preexisting ?? 'unmeasured'} · unclassified ${result.unclassified} · ${result.remote ?? 'local'} · gate rc ${result.gateExitCode}${!result.ok ? ' · RC 실패' : ''}`);
+            const shardMismatch = selection.shards !== undefined && result.shards !== selection.shards
+              ? `selected shards ${selection.shards} but RC reported ${result.shards}` : null;
+            const remoteMismatch = opts.remote && result.remote !== opts.remote
+              ? `requested remote ${opts.remote} but RC reported ${result.remote ?? 'local'}` : null;
+            if (shardPlan?.remoteCapacityPending && result.remote && result.remote !== LIGHT_RC_UNKNOWN_HOST
+              && !remoteMismatch && result.unmeasured === null
+              && result.introduced !== null && result.unclassified === 0 && result.ok
+              && result.gateExitCode === 0 && !shardMismatch) {
+              // Only the completed RC can validate capacity of the actual remote host. Keep independent
+              // selection/RSS gaps; clear just the provisional remote-capacity gap.
+              stamp.shardPlan = { ...shardPlan, remoteCapacityPending: false, rssRevisionPending: false,
+                remoteCapacityVerifiedBy: result.remote,
+                unmeasured: shardPlan.planningGaps?.length ? shardPlan.planningGaps.join('; ') : null };
+            }
+            const planningGap = stamp.shardPlan?.unmeasured || shardMismatch || remoteMismatch;
+            const missingEvidence = result.introduced === null || result.unclassified === null
+              || result.unmeasured !== null || result.unclassified > 0 || !!planningGap;
+            stamp.outcome = result.introduced !== null && result.introduced > 0 ? missingEvidence ? 'unmeasured' : 'regression'
+              : result.introduced === null || result.unclassified === null || result.unmeasured !== null || result.unclassified > 0 ? 'unmeasured'
+              : result.unmeasured === null && (!result.ok || result.gateExitCode !== 0) ? 'error'
+              : planningGap ? 'unmeasured' : 'ok';
+            stamp.summary = oneLine(`introduced ${result.introduced} · preexisting ${result.preexisting ?? 'unmeasured'} · unclassified ${result.unclassified} · ${result.remote ?? 'local'} · gate rc ${result.gateExitCode}${!result.ok ? ' · RC 실패' : ''}${result.unmeasured !== null ? ` · unmeasured: ${result.unmeasured || 'RC reason empty'}` : ''}${stamp.shardPlan?.unmeasured ? ` · unmeasured: ${stamp.shardPlan.unmeasured}` : ''}${shardMismatch ? ` · unmeasured: ${shardMismatch}` : ''}${remoteMismatch ? ` · unmeasured: ${remoteMismatch}` : ''}`);
           }
         }
       } catch (error) {
         stamp.outcome = 'error';
-        stamp.summary = oneLine(String(error instanceof Error ? error.message : error).split(/\r?\n/, 1)[0] ?? 'unknown error');
+        stamp.summary = oneLine(`${String(error instanceof Error ? error.message : error).split(/\r?\n/, 1)[0] ?? 'unknown error'}${stamp.shardPlan?.unmeasured ? ` · unmeasured: ${stamp.shardPlan.unmeasured}` : ''}`);
       }
       await finish(path, stamp);
     }

package/src/repl/index.ts

@@ -30,6 +30,7 @@ import {
 import {
   resolveSessionId,
   loadSession,
+  listSessions,
   setActiveSessionId,
   getActiveSessionId,
 } from '../session/index.js';
@@ -41,6 +42,7 @@ import {
 } from '../user-config.js';
 import { setAmbientSessionId, debug } from '../debug/log.js';
 import { decideSigintAction } from './sigint.js';
+import { decideSessionStart, observeSessionStart } from '../session/session-start.js';
 import { buildReplayTurnsFromSession } from './replay.js';
 import type { LLMToolSpec, ContentBlock } from '../llm.js';
 import { inspectActiveProvider } from '../provider-summary.js';
@@ -58,6 +60,8 @@ export interface ReplOpts {
   initialSessionId: string | undefined;
   /** Force a fresh session even if active marker exists. */
   forceNew: boolean;
+  /** `--continue`/`--resume` — 활성 세션 이어하기(명시). 대표 #73: 기본은 새 세션. */
+  continueActive?: boolean;
   /** Enable the tool loop (Read/Grep/Bash/...). Default true — REPL
    *  is the agent surface; users opt out with --no-tools. */
   enableTools: boolean;
@@ -445,11 +449,25 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
       return 1;
     }
     initialId = id;
-  } else if (!opts.forceNew) {
-    initialId = getActiveSessionId() ?? undefined;
   }
+  const startDecision = decideSessionStart({
+    ...(initialId ? { explicitSessionId: initialId } : {}),
+    continueActive: opts.continueActive === true,
+    forceNew: opts.forceNew,
+    activeSessionId: () => getActiveSessionId(),
+    // TUI-H8-FOLLOW ① — 활성 표지가 사라진 세션이면 최신 세션으로.
+    sessionExists: (id) => loadSession(id) !== null,
+    latestSessionId: () => listSessions({ limit: 1 })[0]?.id ?? null,
+  });
+  initialId = startDecision.sessionIdHint;
   const session = ensureCliSession(cfg, initialId);
   setActiveSessionId(session.id);
+  observeSessionStart({
+    surface: 'repl',
+    origin: initialId && session.id === initialId ? startDecision.origin : 'new',
+    reason: initialId && session.id !== initialId ? 'resume-target-missing' : startDecision.reason,
+    sessionId: session.id,
+  });
   setAmbientSessionId(session.id);
   if (!opts.jsonOutput && (!initialId || session.id !== initialId)) {
     try {