elanous 0.2.23 → 0.2.25

package/src/release-loop/light-rc.ts

@@ -3,7 +3,8 @@
  *  gate host (GATE-REMOTE). Read-only for the release ledger: it reads the previous published version and never writes.
  *  It does not touch the landing freeze or launch Pods. */
 import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { runSelfGateCli, type SelfGateCliOptions, type SelfGateCliResult } from '../self-implement/gate-cli.js';
@@ -14,9 +15,14 @@ import { baseVersion, isReleaseVersion } from '../../scripts/release-loop/releas
 export const LIGHT_RC_ALWAYS_FILE = 'release/light-rc-always.txt';
 export const LIGHT_RC_DEFAULT_SHARDS = 4;
 export const LIGHT_RC_NO_PREVIOUS_CUT = '직전 판 컷을 못 찾았다 — --base 로 준다';
+/** RELEASE-DAILY-LIGHT-RC ① — what light-rc measures by default: main as it is on origin, not the tree it started in
+ *  (10-12: the seat tree measured changed=2, a main worktree 52). */
+export const LIGHT_RC_DEFAULT_HEAD = 'origin/main';
 
 export interface LightRcOptions {
   base?: string;
+  /** Commit to measure (RELEASE-DAILY-LIGHT-RC ①). Absent = `origin/main` after `git fetch origin main`. */
+  head?: string;
   /** Gate host; absent = config gateRemote.host (the dispatch's own default). */
   remote?: string;
   /** Run on this machine (the remote child is re-invoked with it). */
@@ -30,6 +36,12 @@ export interface LightRcOptions {
 export interface LightRcResult {
   version: string;
   base: string;
+  /** The commit the gate measured (RELEASE-DAILY-LIGHT-RC ①) — origin/main unless --head was given. */
+  measuredCommit: string;
+  /** HEAD of the tree light-rc was started from; differs from measuredCommit when it ran from a seat/work tree. */
+  worktreeHead: string | null;
+  /** RELEASE-DAILY-LIGHT-RC ② — tests added because they import a changed source; null = not reported. */
+  importerTests: number | null;
   /** New failures vs. the base; null = the gate produced no measurement (never read as green). */
   introduced: number | null;
   preexisting: number | null;
@@ -56,6 +68,9 @@ export interface LightRcDeps {
   dispatch?: (opts: DispatchOptions, deps?: DispatchDeps) => Promise<number>;
   /** Extra dispatch deps (runner · settings) — tests drive the real dispatch with a fake host. */
   dispatchDeps?: Omit<DispatchDeps, 'write'>;
+  /** Detached checkout of `sha` for a local run whose tree is not at the measured commit (default: git worktree add
+   *  --detach in a temp dir ⊕ bun install); `cleanup` removes it. */
+  checkout?: (sha: string, repo: string, log: (line: string) => void) => { dir: string; cleanup: () => void };
 }
 
 /** Shown when the gate ran remotely but the host name did not come back. */
@@ -87,6 +102,51 @@ export function previousCutBase(version: string, deps: LightRcDeps & { cwd: stri
   return sha;
 }
 
+const SHA_RE = /^[0-9a-f]{40}$/;
+
+/** RELEASE-DAILY-LIGHT-RC ① — the commit to measure. Default: fetch origin main, then origin/main (a failed fetch is
+ *  said, and the local origin/main is measured — never silently the tree's HEAD). */
+export function resolveMeasuredCommit(cwd: string, head: string | undefined, deps: LightRcDeps, log: (line: string) => void): { measuredCommit: string; worktreeHead: string | null } {
+  const git = deps.git ?? defaultGit;
+  const ref = head ?? LIGHT_RC_DEFAULT_HEAD;
+  if (head === undefined) {
+    const fetch = git(['fetch', '--quiet', 'origin', 'main'], cwd);
+    if (fetch.rc !== 0) {
+      log(`⚠️ light-rc: git fetch origin main rc=${fetch.rc} — measuring the local ${LIGHT_RC_DEFAULT_HEAD} (may be stale)`);
+      debug.log('release.light-rc', 'fetch-failed', { rc: fetch.rc });
+    }
+  }
+  const parsed = git(['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], cwd);
+  const measuredCommit = parsed.stdout.trim();
+  if (parsed.rc !== 0 || !SHA_RE.test(measuredCommit)) throw new Error(`release light-rc: cannot resolve ${ref} to a commit (rc=${parsed.rc})`);
+  const top = git(['rev-parse', 'HEAD'], cwd);
+  const worktreeHead = top.rc === 0 && SHA_RE.test(top.stdout.trim()) ? top.stdout.trim() : null;
+  if (worktreeHead !== measuredCommit) {
+    log(`ⓘ light-rc measures ${measuredCommit.slice(0, 12)} (${ref}) — this tree's HEAD ${worktreeHead?.slice(0, 12) ?? '(unresolved)'} is not what is measured`);
+    debug.log('release.light-rc', 'measured-commit-differs', { ref, measuredCommit, worktreeHead, cwd });
+  }
+  return { measuredCommit, worktreeHead };
+}
+
+function defaultCheckout(sha: string, repo: string, log: (line: string) => void): { dir: string; cleanup: () => void } {
+  const dir = mkdtempSync(join(tmpdir(), 'elanous-light-rc-'));
+  const run = (cmd: string, args: string[], cwd: string) => spawnSync(cmd, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  const cleanup = () => {
+    run('git', ['worktree', 'remove', '--force', dir], repo);
+    rmSync(dir, { recursive: true, force: true });
+    run('git', ['worktree', 'prune'], repo);
+  };
+  const add = run('git', ['worktree', 'add', '--detach', dir, sha], repo);
+  if (add.status !== 0) { cleanup(); throw new Error(`release light-rc: git worktree add ${sha.slice(0, 12)} failed: ${(add.stderr ?? '').trim()}`); }
+  log(`light-rc: detached checkout of ${sha.slice(0, 12)} at ${dir} — installing dependencies`);
+  for (const sub of ['.', 'apps/pwa']) {
+    if (!existsSync(join(dir, sub, 'package.json'))) continue;
+    const install = run('bun', ['install', '--frozen-lockfile'], join(dir, sub));
+    if (install.status !== 0) { cleanup(); throw new Error(`release light-rc: bun install (${sub}) failed in the checkout: ${(install.stderr ?? '').trim().slice(-400)}`); }
+  }
+  return { dir, cleanup };
+}
+
 function repoRoot(deps: LightRcDeps): string {
   if (deps.cwd) return deps.cwd;
   const top = defaultGit(['rev-parse', '--show-toplevel'], process.cwd());
@@ -110,23 +170,32 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   if (opts.remote !== undefined && !isValidGateHost(opts.remote)) throw new Error(`invalid --remote host: ${opts.remote}`);
   const log = opts.log ?? ((line: string) => process.stderr.write(`${line}\n`));
   const cwd = repoRoot(deps);
+  const { measuredCommit, worktreeHead } = resolveMeasuredCommit(cwd, opts.head, deps, log);
   const base = opts.base ?? previousCutBase(version, { ...deps, cwd, ledgerRoot: opts.ledgerRoot });
-  const listPath = join(cwd, LIGHT_RC_ALWAYS_FILE);
-  const listText = (deps.readFile ?? ((path: string) => existsSync(path) ? readFileSync(path, 'utf8') : undefined))(listPath);
-  if (listText === undefined) throw new Error(`release light-rc: ${LIGHT_RC_ALWAYS_FILE} not found`);
-  const alwaysInclude = parseAlwaysIncludeList(listText);
+  const readList = (dir: string) => {
+    const text = (deps.readFile ?? ((path: string) => existsSync(path) ? readFileSync(path, 'utf8') : undefined))(join(dir, LIGHT_RC_ALWAYS_FILE));
+    if (text === undefined) throw new Error(`release light-rc: ${LIGHT_RC_ALWAYS_FILE} not found`);
+    return parseAlwaysIncludeList(text);
+  };
+  let alwaysInclude = readList(cwd);
 
   let local: SelfGateCliResult | undefined;
   const runLocal = () => {
-    local = (deps.runGate ?? runSelfGateCli)(cwd, { base, shards, alwaysInclude });
+    // ① The gate scopes by its tree's HEAD — so a tree that is not at the measured commit runs in a detached checkout of it.
+    const checkout = worktreeHead === measuredCommit ? undefined : (deps.checkout ?? defaultCheckout)(measuredCommit, cwd, log);
+    try {
+      const dir = checkout?.dir ?? cwd;
+      if (checkout) alwaysInclude = readList(dir);
+      local = (deps.runGate ?? runSelfGateCli)(dir, { base, shards, alwaysInclude, includeImporterTests: true });
+    } finally { checkout?.cleanup(); }
     for (const line of local.lines) log(line);
     return local.exitCode;
   };
   const captured: Buffer[] = [];
   const rc = await (deps.dispatch ?? dispatchHeavyCheck)({
-    tool: 'self-gate', repo: cwd, installPwa: true, refs: [base], json: true,
+    tool: 'self-gate', repo: cwd, installPwa: true, refs: [base], json: true, commit: measuredCommit,
     // The host re-runs this command with --local (and ELANOUS_GATE_REMOTE_CHILD=1), so it never recurses.
-    remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--shards', String(shards), '--local', '--json'],
+    remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--head', measuredCommit, '--shards', String(shards), '--local', '--json'],
     flags: { remote: opts.local ? undefined : opts.remote ?? true, local: !!opts.local },
     runLocal,
   }, {
@@ -140,7 +209,8 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   let result: LightRcResult;
   if (local) {
     result = {
-      version, base,
+      version, base, measuredCommit, worktreeHead,
+      importerTests: local.importerTestsAdded ? local.importerTestsAdded.length : null,
       introduced: local.baseline?.introduced ?? null,
       preexisting: local.baseline?.preexisting ?? null,
       unclassified: local.baseline ? local.baseline.unknown + local.baseline.preconditionUnmet : null,
@@ -154,7 +224,8 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
     if (!remote) throw new Error(`release light-rc: remote gate returned no result (rc=${rc})`);
     const host = (remote as { host?: unknown }).host;
     result = {
-      version, base,
+      version, base, measuredCommit, worktreeHead,
+      importerTests: typeof remote.importerTests === 'number' ? remote.importerTests : null,
       introduced: typeof remote.introduced === 'number' ? remote.introduced : null,
       preexisting: typeof remote.preexisting === 'number' ? remote.preexisting : null,
       unclassified: typeof remote.unclassified === 'number' ? remote.unclassified : null,
@@ -170,14 +241,14 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   // Unmeasured (null) or unclassified failures are never green; policy-gate findings in the gate output are reported
   // (gate rc), not a regression.
   result.ok = result.introduced === 0 && result.unclassified === 0;
-  debug.log('release.light-rc', 'done', { version, base, introduced: result.introduced, preexisting: result.preexisting, unclassified: result.unclassified, shards, remote: result.remote, unmeasured: result.unmeasured });
+  debug.log('release.light-rc', 'done', { version, base, measuredCommit, worktreeHead, importerTests: result.importerTests, introduced: result.introduced, preexisting: result.preexisting, unclassified: result.unclassified, shards, remote: result.remote, unmeasured: result.unmeasured });
   return result;
 }
 
 export function formatLightRc(result: LightRcResult): string[] {
   return [
-    `${result.ok ? '✅' : '⛔'} light-rc ${result.version} · base ${result.base.slice(0, 12)} · ${result.remote ? `host ${result.remote}` : 'local'} · shards ${result.shards}`,
-    `  introduced ${result.introduced ?? '못 쟀다'} · preexisting ${result.preexisting ?? '못 쟀다'} · unclassified ${result.unclassified ?? '못 쟀다'} · always-include ${result.alwaysInclude}${result.alwaysIncludeMissing.length ? ` (missing: ${result.alwaysIncludeMissing.join(', ')})` : ''} · gate rc ${result.gateExitCode}`,
+    `${result.ok ? '✅' : '⛔'} light-rc ${result.version} · base ${result.base.slice(0, 12)} · measured ${result.measuredCommit.slice(0, 12)} · ${result.remote ? `host ${result.remote}` : 'local'} · shards ${result.shards}`,
+    `  introduced ${result.introduced ?? '못 쟀다'} · preexisting ${result.preexisting ?? '못 쟀다'} · unclassified ${result.unclassified ?? '못 쟀다'} · importer tests ${result.importerTests ?? '못 쟀다'} · always-include ${result.alwaysInclude}${result.alwaysIncludeMissing.length ? ` (missing: ${result.alwaysIncludeMissing.join(', ')})` : ''} · gate rc ${result.gateExitCode}`,
     ...(result.unmeasured !== null ? [`  shards: unmeasured (${result.unmeasured})`] : []),
   ];
 }

package/src/release-loop/merged-pr-checklist.ts

@@ -38,7 +38,18 @@ export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: st
   // The audit matcher owns explicit-label and evidence decisions on both PR surfaces.
   // The shared matcher only accepts a whole `칸: X` line. A designated label in the body (`칸: X — …` at a line head)
   // or in the title is restated as such a line; prose mentions are not (the audit command's contract is unchanged).
-  const designated = [...goalCells(pr.body ?? ''), ...titleCells(pr.title)];
+  // Goal-file ids join that set: `칸: X` lines plus `- 칸 id: A · B` declarations (not-declared excluded).
+  const fromBody = goalCells(pr.body ?? '');
+  const fromTitle = titleCells(pr.title);
+  const fromGoal = goal ? goalFileCells(goal) : new Set<string>();
+  const designated = [...new Set([...fromBody, ...fromTitle, ...fromGoal])];
+  for (const id of designated) {
+    log('release.checklist', 'merged-pr-cell-source', {
+      pr: number,
+      id,
+      source: fromBody.has(id) ? 'body' : fromTitle.has(id) ? 'title' : 'goal',
+    });
+  }
   // Only the restated labels go to the matcher — raw body text (quotes, fences, indented code) never does.
   const prForMatch = { ...merged, title: '', body: designated.map((id) => `칸: ${id}`).join('\n') };
   const matches = [...new Set(versions)].flatMap((version) => {
@@ -86,10 +97,14 @@ export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: st
   for (const id of missing) log('release.checklist', 'merged-pr-cell-not-found', { pr: number, id });
 }
 
-const LABEL_IDS = '([A-Za-z0-9_-]+(?:[ \\t]*,[ \\t]*[A-Za-z0-9_-]+)*)';
+const LABEL_IDS = '([A-Za-z0-9_-]+(?:[ \\t]*(?:,|·)[ \\t]*[A-Za-z0-9_-]+)*)';
 const LABEL_END = '(?=[ \\t]*$|[ \\t]+[—–·(-])';
 const DESIGNATION = new RegExp(`^ {0,3}(?:#{1,6}[ \\t]+|[-*][ \\t]+)?칸[ \\t]*:[ \\t]*${LABEL_IDS}${LABEL_END}`);
 
+function idsInLabel(captured: string): string[] {
+  return captured.split(/[,·]/).map((id) => id.trim()).filter(Boolean);
+}
+
 /** Lines of a Markdown document outside fenced code (closed only by the same marker, at least as long), 4-space
  *  indented code and `>` quotes — the only lines that may designate a cell or declare completion. */
 function proseLines(text: string): string[] {
@@ -109,13 +124,28 @@ function proseLines(text: string): string[] {
   return lines;
 }
 
-/** Cell ids a document designates on a line head: `칸: X[, Y]`, optionally after a heading or list marker. */
+/** Cell ids a document designates on a line head: `칸: X[, Y]` or `칸: X · Y`, optionally after a heading or list marker. */
 export function goalCells(goal: string): Set<string> {
   const ids = new Set<string>();
   for (const line of proseLines(goal)) {
     const label = DESIGNATION.exec(line);
     if (!label) continue;
-    for (const id of label[1]!.split(',')) ids.add(id.trim());
+    for (const id of idsInLabel(label[1]!)) ids.add(id);
+  }
+  return ids;
+}
+
+/** Goal-file designations: `칸:` lines plus `- 칸 id: A · B` declarations (same shape as goalChecklistIds). */
+function goalFileCells(goal: string): Set<string> {
+  const ids = goalCells(goal);
+  for (const line of proseLines(goal)) {
+    if (!line.startsWith('- 칸 id: ')) continue;
+    const declared = line.slice('- 칸 id: '.length).trim();
+    if (!declared || declared === 'not declared') continue;
+    for (const id of declared.split(' · ')) {
+      const trimmed = id.trim();
+      if (trimmed) ids.add(trimmed);
+    }
   }
   return ids;
 }
@@ -129,7 +159,7 @@ export function declaresCompletion(goal: string): boolean {
 export function titleCells(title: string): Set<string> {
   const ids = new Set<string>();
   for (const label of title.matchAll(new RegExp(`(?<![A-Za-z0-9가-힣])칸[ \\t]*:[ \\t]*${LABEL_IDS}${LABEL_END}`, 'g'))) {
-    for (const id of label[1]!.split(',')) ids.add(id.trim());
+    for (const id of idsInLabel(label[1]!)) ids.add(id);
   }
   return ids;
 }

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, listChecklist, ownerMatches, parseOwner, setItem, validateCeoLoad, type ChecklistItem } from './checklist.js';
+import { addItem, checklistHistory, 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';
@@ -406,9 +406,24 @@ export function rebalance(version: string, deps: PlacementDeps = {}): RebalanceR
   return result;
 }
 
+/** Reasons that justify a second forward rollover of the same cell (대표 10-10 «계속 이월되지 않게»). */
+const SECOND_ROLLOVER_REASON_PREFIXES: readonly string[] = ['쪼개기:', '닫기:', '\u{1F451}:'];
+
+/** Forward moves (to > from) already recorded for this cell across every release. */
+function priorForwardMoves(id: string): number {
+  return checklistHistory(id).filter((row) => row.field === 'move'
+    && typeof row.from === 'string' && typeof row.to === 'string'
+    && versionOrder(row.to, row.from) > 0).length;
+}
+
 /** A seat may defer its own cell one release, never pull another owner's cell forward. */
 export function seatMove(id: string, from: string, to: string, by: string, reason: string, deps: PlacementDeps = {}): void {
   if (!reason.trim()) throw new CliUserError('이동 이유가 필요하다');
+  const trimmed = reason.trim();
+  // A second rollover is only deliberate: split, closure, or a king's order.
+  if (versionOrder(to, from) > 0 && priorForwardMoves(id) >= 1
+    && !SECOND_ROLLOVER_REASON_PREFIXES.some((prefix) => trimmed.startsWith(prefix)))
+    throw new CliUserError(`${id}: 두 번째 이월은 «쪼개기:»·«닫기:»·«\u{1F451}:» 로 시작하는 이유만 허용한다 — 첫 이월 이후 계속 이월되지 않게`);
   const rows = [...(deps.schedules ?? listSchedules())].sort((a, b) => versionOrder(a.version, b.version));
   const backlog = deps.backlog ?? BACKLOG_VERSIONS;
   const next = rows.find((row) => versionOrder(row.version, from) > 0 && !backlog.includes(row.version));

package/src/release-loop/rehearsal.ts

@@ -290,7 +290,7 @@ export async function runRehearsalTick(opts: RehearsalOptions = {}, deps: Rehear
             stamp.sha = gitResult(git, ['rev-parse', 'HEAD'], checkout);
             if (!stamp.sha) throw new Error('git rev-parse HEAD returned no sha');
             const regressionFiles: string[] = [];
-            const result = await (deps.lightRc ?? ((version, cwd) => runLightRc(version, { ledgerRoot: root, log: (line) => {
+            const result = await (deps.lightRc ?? ((version, cwd) => runLightRc(version, { ledgerRoot: root, head: stamp.sha, log: (line) => {
               for (const entry of line.split(/\r?\n/)) {
                 const file = /^- introduced: (.+?)(?: > |$)/.exec(entry)?.[1];
                 if (file && regressionFiles.length < 3) regressionFiles.push(file);