elanous 0.2.24 → 0.2.27

package/src/project/project-store.ts

@@ -10,9 +10,11 @@ export interface Project {
   name: string;
   primaryFolder?: string;
   createdAt: string;
+  relations?: Array<{ type: 'dependsOn' | 'derivedFrom' | 'partOf' | 'deploysTo'; target: string }>;
 }
 
 const PROJECT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const RELATION_TYPES = new Set(['dependsOn', 'derivedFrom', 'partOf', 'deploysTo']);
 
 function validId(id: unknown): id is string {
   return typeof id === 'string' && PROJECT_ID.test(id);
@@ -26,9 +28,27 @@ function validateProject(value: unknown): Project {
     || (item.primaryFolder !== undefined && (typeof item.primaryFolder !== 'string' || !isAbsolute(item.primaryFolder)))) {
     throw new Error('invalid project record');
   }
+  if (item.relations !== undefined) {
+    if (!Array.isArray(item.relations)) throw new Error('invalid project record');
+    const seen = new Set<string>();
+    for (const rel of item.relations) {
+      if (!rel || typeof rel !== 'object' || Array.isArray(rel)) throw new Error('invalid project record');
+      const edge = rel as Record<string, unknown>;
+      if (!RELATION_TYPES.has(edge.type as string) || !validId(edge.target) || edge.target === item.id) {
+        throw new Error('invalid project record');
+      }
+      const key = `${edge.type}\0${edge.target}`;
+      if (seen.has(key)) throw new Error('invalid project record');
+      seen.add(key);
+    }
+  }
   return value as Project;
 }
 
+export function relationsOf(project: Project): Array<{ type: 'dependsOn' | 'derivedFrom' | 'partOf' | 'deploysTo'; target: string }> {
+  return project.relations ?? [];
+}
+
 export class ProjectStore {
   readonly dir: string;
 

package/src/prompt-enhance/enhance.ts

@@ -393,6 +393,8 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
   let complication: string | undefined;
   let decisionSignal: EnhanceResult['decisionSignal'];
   let enhancedBy: 'llm' | 'fallback' = 'llm';
+  let fallbackReason: 'llm-error' | 'empty-reply' | 'unparsed' | 'none' = 'none';
+  let replyChars = 0;
   const groundedFacts = opts.groundedFacts ?? [];
   const wantsScqa = groundedFacts.length > 0;
 
@@ -439,6 +441,10 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
         try { opts.onUsage?.(usage); } catch { /* usage observation must not change enhancement */ }
       },
     });
+    replyChars = rawOut.length;
+    if (rawOut.trim().length === 0) {
+      fallbackReason = 'empty-reply';
+    }
     const parsed = parseEnhanceJson(rawOut);
     if (parsed) {
       goal = parsed.goal;
@@ -449,9 +455,11 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
       complication = parsed.complication;
       decisionSignal = parsed.decisionSignal;
     } else {
+      fallbackReason = fallbackReason === 'empty-reply' ? 'empty-reply' : 'unparsed';
       enhancedBy = 'fallback';
     }
   } catch (e) {
+    fallbackReason = 'llm-error';
     debug.log('prompt-enhance', 'llm-error', { error: String((e as { message?: string })?.message ?? e).slice(0, 160) }, { level: 'error' });
     enhancedBy = 'fallback';
   }
@@ -461,6 +469,7 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
     checklist = extractChecklistFallback(original);
     checklistProvenance = checklist.map(() => 'unknown');
     enhancedBy = 'fallback';
+    if (fallbackReason === 'none') fallbackReason = 'unparsed';
   }
   if (!constraints.length) {
     constraints = [
@@ -515,6 +524,8 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
     enhancedChars: enhanced.length,
     checklist: checklist.length,
     enhancedBy,
+    fallbackReason,
+    replyChars,
     model,
     verbatimPreserved,
     // ⭐ 관측 — 「요약을 요구했나 / 받았나 / 옮겨 적어 버렸나」를 «다른 값»으로 남긴다.

package/src/release-loop/auto-start.ts

@@ -1,3 +1,4 @@
+import { debug } from '../debug/log.js';
 import { releaseLedgerRoot } from '../instance/resolve.js';
 import { releaseReadiness, type ReleaseReadiness } from '../../scripts/release-loop/release-readiness.js';
 import { listSchedules, type ReleaseSchedule } from './release-schedule.js';
@@ -21,7 +22,7 @@ export type AutoStartResult =
   | { status: 'no-cut' }
   | { status: 'planned'; version: string; cutAt: string }
   | { status: 'skipped'; version: string; reason: AutoStartDeferral['reason'] }
-  | { status: 'started'; version: string; cutAt: string };
+  | { status: 'started'; version: string; cutAt: string; publishAt?: string };
 
 export interface AutoStartOptions {
   windowMinutes: number;
@@ -30,7 +31,7 @@ export interface AutoStartOptions {
   ledgerRoot?: string;
   schedules?: (root: string) => ReleaseSchedule[];
   readiness?: (version: string, ledgerRoot: string, now: Date) => ReleaseReadiness;
-  launch?: (version: string) => void | AutoStartDeferral | Promise<void | AutoStartDeferral>;
+  launch?: (version: string, launchOptions?: { publishAt?: string }) => void | AutoStartDeferral | Promise<void | AutoStartDeferral>;
 }
 
 /** Select from the release schedule; the existing `release run --if-ready` owns the launch-time lock and guards. */
@@ -40,12 +41,13 @@ export async function autoStartScheduledRelease(options: AutoStartOptions): Prom
   // Validate the window even when the ledger has no rows.
   const schedule = selectScheduledCut((options.schedules ?? listSchedules)(root), now, options.windowMinutes);
   if (!schedule) return { status: 'no-cut' };
-  const { version, cutAt } = schedule;
+  const { version, cutAt, publishAt } = schedule;
   if (!options.apply) return { status: 'planned', version, cutAt };
   const readiness = (options.readiness ?? ((v, ledgerRoot, at) => releaseReadiness(v, { ledgerRoot, now: () => at })))(version, root, now);
   if (!readiness.ready) return { status: 'skipped', version, reason: readiness.reason };
   if (!options.launch) throw new Error('auto-start apply requires a launch callback');
-  const launched = await options.launch(version);
+  const launched = await options.launch(version, publishAt != null ? { publishAt: publishAt } : {});
   if (launched?.deferred) return { status: 'skipped', version, reason: launched.reason };
-  return { status: 'started', version, cutAt };
+  debug.log('release.schedule', 'auto-start', { version, cutAt, publishAt: publishAt ?? null });
+  return { status: 'started', version, cutAt, ...(publishAt != null ? { publishAt: publishAt } : {}) };
 }

package/src/release-loop/checklist.ts

@@ -10,6 +10,8 @@ export type ChecklistDisposition = 'move' | 'known-issue' | 'block';
 /** `screen` = a five-surface feature cell — its evidence carries a `짝:` line (MANUAL-five-surface-parity §A). `postpub` = measured after publication, outside the pre-publication gate. */
 export type ChecklistKind = 'screen' | 'postpub';
 const CHECKLIST_KINDS: readonly ChecklistKind[] = ['screen', 'postpub'];
+export type ChecklistDispatchKind = 'code' | 'ops' | 'measure' | 'decision' | 'umbrella';
+const CHECKLIST_DISPATCH_KINDS: readonly ChecklistDispatchKind[] = ['code', 'ops', 'measure', 'decision', 'umbrella'];
 export interface ChecklistItem {
   id: string;
   title: string;
@@ -27,6 +29,8 @@ export interface ChecklistItem {
   evidence?: string;
   disposition?: ChecklistDisposition;
   kind?: ChecklistKind;
+  /** Whether the seat dispatcher should launch a coding task. Missing in old rows means code. */
+  dispatchKind?: ChecklistDispatchKind;
   updatedAt: string;
   updatedBy: string;
 }
@@ -102,6 +106,14 @@ export function statusChangesSince(history: readonly ChecklistHistory[], sinceIs
   return history.filter((entry) => entry.field === 'status' && Date.parse(entry.at) >= since);
 }
 
+/** CELL-DEPENDS-ID: a predecessor must name a cell that exists in SOME version — this one (data.items) or any other (otherItems). */
+function assertPredecessorsExist(predecessors: readonly string[] | undefined, data: Checklist, otherItems: (id: string) => store.ChecklistCollision[]): void {
+  for (const id of predecessors ?? []) {
+    if (data.items.some((item) => item.id === id) || otherItems(id).length) continue;
+    throw new CliUserError(`없는 선행 칸: ${JSON.stringify(id).slice(1, -1)}`, '어느 판에도 없는 id 다 — release checklist status --json 으로 칸 id 를 확인한다');
+  }
+}
+
 function mutate(v: string, apply: (data: Checklist, otherItems: (id: string) => store.ChecklistCollision[]) => boolean): Checklist {
   // addItem/setItem/claimItem/removeItem/seedFromRoadmap reach the generation-fenced ledger write here.
   return decodeClaimHistory(store.mutate(v, store.releasedVersion(), devVersion(), apply));
@@ -114,6 +126,37 @@ function change(data: Checklist, id: string, field: string, from: unknown, to: u
 
 const REPO_ROOT = join(import.meta.dir, '..', '..');
 
+const PATH_TOKEN = /(?:^|[^A-Za-z0-9_.\/-])((?:(?:[A-Za-z0-9_.-]+\/)+)?[A-Za-z0-9_.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|yaml|yml|sh|py|css|html|toml|sql|rs|swift))(?![A-Za-z0-9_.\/-])/g;
+function mentionedPaths(text: string): string[] {
+  return [...text.matchAll(PATH_TOKEN)].map((match) => match[1]!).filter((path) => !path.split('/').includes('..'));
+}
+
+/** Shadow check at checklist authorship. Callers supply the origin/main file probe and merged-PR file reader. */
+export function inspectChecklistTargetPaths(input: {
+  title: string; evidence?: string; refs?: readonly string[]; dispatchKind?: ChecklistDispatchKind;
+}, deps: { existsAtMain: (path: string) => boolean; mergedPrFiles?: (number: number) => readonly string[] }): {
+  targets: string[]; warnings: string[]; candidates: string[];
+} {
+  const lines = input.title.split(/\r?\n/);
+  const first = /^대상 경로:\s*(.*)$/.exec(lines[0] ?? '');
+  const targets = first ? [...new Set(mentionedPaths(first[1]!))] : [];
+  const newFileDeclared = /^신설:\s*/.test(lines[1] ?? '');
+  const warnings: string[] = [];
+  if ((input.dispatchKind ?? 'code') === 'code') {
+    if (!first || !first[1]!.trim() || targets.length === 0) warnings.push('첫 줄 대상 경로가 없다');
+    for (const path of targets) if (!deps.existsAtMain(path) && !newFileDeclared) warnings.push(`${path}: origin/main에 없는 파일 · 신설: 둘째 줄 선언 필요`);
+  }
+  if (!warnings.length) return { targets, warnings, candidates: [] };
+  const sources = [input.title, input.evidence ?? '', ...(input.refs ?? [])].join('\n');
+  const candidates = [...new Set(mentionedPaths(sources).filter(deps.existsAtMain))];
+  for (const match of sources.matchAll(/(?:^|[^\d])#(\d{2,8})\b/g)) {
+    for (const path of deps.mergedPrFiles?.(Number(match[1])) ?? []) {
+      if (deps.existsAtMain(path) && !candidates.includes(path)) candidates.push(path);
+    }
+  }
+  return { targets, warnings, candidates };
+}
+
 /** `--ref` 문서를 찾는 뿌리들 — 이 코드의 트리 ⊕ 지금 작업 디렉토리의 git 뿌리.
  *  ⭐ 설치본(`~/.local/share/elanous/current`)에는 `docs/` 가 없다 — 저장소 안에서 부른 설치본도 저장소 문서를 인용할 수 있게. */
 export function refRoots(cwd = process.cwd()): string[] {
@@ -225,10 +268,11 @@ export function validateCeoLoad(input: { ceoMinutes?: number; ceoDate?: string }
   if (input.ceoDate !== undefined && (!/^\d{4}-\d{2}-\d{2}$/.test(input.ceoDate) || !Number.isFinite(Date.parse(`${input.ceoDate}T00:00:00Z`)) || new Date(`${input.ceoDate}T00:00:00Z`).toISOString().slice(0, 10) !== input.ceoDate)) throw new CliUserError('대표 손 날짜는 YYYY-MM-DD 이어야 한다');
 }
 
-export function addItem(v: string, input: { id: string; title: string; refs?: string[]; owner?: string; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean }, options: { allowDuplicateId?: boolean } = {}): Checklist {
+export function addItem(v: string, input: { id: string; title: string; refs?: string[]; owner?: string; kind?: ChecklistKind; dispatchKind?: ChecklistDispatchKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean }, options: { allowDuplicateId?: boolean } = {}): Checklist {
   if (!input.id.trim()) throw new CliUserError('칸 id 가 비었다');
   if (!input.title.trim()) throw new CliUserError('칸 제목이 비었다');
   if (input.kind !== undefined && !CHECKLIST_KINDS.includes(input.kind)) throw new CliUserError(`잘못된 종류: ${input.kind}`, 'screen|postpub');
+  if (input.dispatchKind !== undefined && !CHECKLIST_DISPATCH_KINDS.includes(input.dispatchKind)) throw new CliUserError(`잘못된 발사 종류: ${input.dispatchKind}`, 'code|ops|measure|decision|umbrella');
   if (input.owner !== undefined) parseOwner(input.owner);
   if (input.priority !== undefined && !['P0', 'P1', 'P2'].includes(input.priority)) throw new CliUserError(`잘못된 우선순위: ${input.priority}`);
   if (input.predecessors !== undefined && (!Array.isArray(input.predecessors) || input.predecessors.some((p) => typeof p !== 'string' || !p.trim() || p === input.id))) throw new CliUserError('잘못된 선행 칸');
@@ -244,24 +288,27 @@ export function addItem(v: string, input: { id: string; title: string; refs?: st
       console.error(`⚠ 중복 id: ${displayedId} — ${collisions.map((item) => `${item.version} · 담당 ${JSON.stringify(item.owner ?? '-').slice(1, -1)} · ${item.title.replace(/\s+/g, ' ').slice(0, 40)}`).join(' / ')}`);
       if (!options.allowDuplicateId) throw new CliUserError(`다른 판에 이미 있는 칸: ${displayedId}`, '--allow-duplicate-id 로 허용');
     }
+    assertPredecessorsExist(input.predecessors, data, otherItems);
     const by = process.env.ELANOUS_TRACK || 'cli';
     const at = new Date().toISOString();
-    const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), ...(input.priority !== undefined ? { priority: input.priority } : {}), ...(input.predecessors !== undefined ? { predecessors: input.predecessors } : {}), ...(input.deadlineVersion !== undefined ? { deadlineVersion: input.deadlineVersion } : {}), ...(input.ceoMinutes !== undefined ? { ceoMinutes: input.ceoMinutes } : {}), ...(input.ceoDate !== undefined ? { ceoDate: input.ceoDate } : {}), ...(input.accelerator === true ? { accelerator: true as const } : {}), ...(refs ? { refs } : {}), updatedAt: at, updatedBy: by };
+    const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), ...(input.dispatchKind !== undefined ? { dispatchKind: input.dispatchKind } : {}), ...(input.priority !== undefined ? { priority: input.priority } : {}), ...(input.predecessors !== undefined ? { predecessors: input.predecessors } : {}), ...(input.deadlineVersion !== undefined ? { deadlineVersion: input.deadlineVersion } : {}), ...(input.ceoMinutes !== undefined ? { ceoMinutes: input.ceoMinutes } : {}), ...(input.ceoDate !== undefined ? { ceoDate: input.ceoDate } : {}), ...(input.accelerator === true ? { accelerator: true as const } : {}), ...(refs ? { refs } : {}), updatedAt: at, updatedBy: by };
     data.items.push(item);
     change(data, item.id, 'add', null, item, by, at);
     return true;
   });
 }
 
-export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; refs?: string[]; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean | null }, by: string): Checklist {
-  return mutate(v, (data) => {
+export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; refs?: string[]; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind; dispatchKind?: ChecklistDispatchKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean | null }, by: string): Checklist {
+  return mutate(v, (data, otherItems) => {
     const item = data.items.find((i) => i.id === id);
     if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
     if (patch.status !== undefined && !['green', 'yellow', 'red', 'done'].includes(patch.status)) throw new CliUserError(`잘못된 상태: ${patch.status}`);
     if (patch.disposition !== undefined && !['move', 'known-issue', 'block'].includes(patch.disposition)) throw new CliUserError(`잘못된 처분: ${patch.disposition}`);
     if (patch.kind !== undefined && !CHECKLIST_KINDS.includes(patch.kind)) throw new CliUserError(`잘못된 종류: ${patch.kind}`, 'screen|postpub');
+    if (patch.dispatchKind !== undefined && !CHECKLIST_DISPATCH_KINDS.includes(patch.dispatchKind)) throw new CliUserError(`잘못된 발사 종류: ${patch.dispatchKind}`, 'code|ops|measure|decision|umbrella');
     if (patch.priority !== undefined && !['P0', 'P1', 'P2'].includes(patch.priority)) throw new CliUserError(`잘못된 우선순위: ${patch.priority}`);
     if (patch.predecessors !== undefined && (!Array.isArray(patch.predecessors) || patch.predecessors.some((p) => typeof p !== 'string' || !p.trim() || p === id))) throw new CliUserError('잘못된 선행 칸');
+    assertPredecessorsExist(patch.predecessors, data, otherItems);
     if (patch.deadlineVersion !== undefined) store.validateVersion(patch.deadlineVersion);
     if (patch.accelerator !== undefined && patch.accelerator !== true && patch.accelerator !== null) throw new CliUserError('가속 등급은 true(부여) 또는 null(해제)이다');
     validateCeoLoad(patch);
@@ -273,7 +320,7 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
         throw new CliUserError(`지금 주인: ${item.owner} — --force 로만 바꾼다`, 'release checklist claim <id> --by <자리> --force');
       }
     }
-    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const).filter((field) => patch[field] !== undefined && JSON.stringify(patch[field]) !== JSON.stringify(item[field] ?? null));
+    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind', 'dispatchKind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const).filter((field) => patch[field] !== undefined && JSON.stringify(patch[field]) !== JSON.stringify(item[field] ?? null));
     if (fields.length === 0) return false;
     const at = new Date().toISOString();
     for (const field of fields) {

package/src/release-loop/feature-store.ts

@@ -36,7 +36,7 @@ const walWait = new Int32Array(new SharedArrayBuffer(4));
 const SCHEMA_COLUMNS: Record<string, readonly string[]> = {
   imported_versions: ['json_hash', 'imported_at'],
   events: ['reason', 'generation'],
-  assignments: ['priority', 'predecessors', 'deadline_version', 'ceo_minutes', 'ceo_date', 'accelerator', 'refs'],
+  assignments: ['priority', 'predecessors', 'deadline_version', 'ceo_minutes', 'ceo_date', 'accelerator', 'refs', 'dispatch_kind'],
   release_schedules: ['freeze_from', 'freeze_until', 'publish_at'],
 };
 function schemaCurrent(db: Database): boolean {
@@ -81,7 +81,7 @@ function open(root = releaseLedgerRoot()): Database {
       if (!eventColumns.some((column) => column.name === 'generation')) db.exec('ALTER TABLE events ADD COLUMN generation INTEGER');
       db.exec('CREATE TABLE IF NOT EXISTS release_schedules (version TEXT PRIMARY KEY, cut_at TEXT NOT NULL, land_by TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL)');
       const assignmentColumns = db.query('PRAGMA table_info(assignments)').all() as Array<{ name: string }>;
-      for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT'], ['ceo_minutes', 'INTEGER'], ['ceo_date', 'TEXT'], ['accelerator', 'INTEGER'], ['refs', 'TEXT']] as const) {
+      for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT'], ['ceo_minutes', 'INTEGER'], ['ceo_date', 'TEXT'], ['accelerator', 'INTEGER'], ['refs', 'TEXT'], ['dispatch_kind', 'TEXT']] as const) {
         if (!assignmentColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE assignments ADD COLUMN ${name} ${sql}`);
       }
       const scheduleColumns = db.query('PRAGMA table_info(release_schedules)').all() as Array<{ name: string }>;
@@ -178,12 +178,13 @@ function evidenceRefs(db: Database, version: string, id: string): string[] {
   return (db.query('SELECT ref FROM evidence WHERE feature_id = ? AND version = ? ORDER BY rowid').all(id, version) as Array<{ ref: string }>).map((row) => row.ref);
 }
 function items(db: Database, version: string): ChecklistItem[] {
-  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.priority, a.predecessors, a.deadline_version, a.ceo_minutes, a.ceo_date, a.accelerator, a.refs, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
+  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.dispatch_kind, a.priority, a.predecessors, a.deadline_version, a.ceo_minutes, a.ceo_date, a.accelerator, a.refs, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
     FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.version = ? ORDER BY a.rowid`).all(version) as Array<Record<string, string | number | null>>;
   return rows.map((r) => {
     const evidence = [r.evidence, ...evidenceRefs(db, version, r.id as string)].filter((value) => value !== null).join('\n');
     return { id: r.id as string, title: r.title as string, status: r.status as ChecklistItem['status'],
       ...(r.owner !== null ? { owner: r.owner as string } : {}), ...(r.kind !== null ? { kind: r.kind as ChecklistItem['kind'] } : {}),
+      ...(r.dispatch_kind !== null ? { dispatchKind: r.dispatch_kind as ChecklistItem['dispatchKind'] } : {}),
       ...(r.priority !== null ? { priority: r.priority as ChecklistItem['priority'] } : {}), ...(r.predecessors !== null ? { predecessors: JSON.parse(r.predecessors as string) as string[] } : {}),
       ...(r.deadline_version !== null ? { deadlineVersion: r.deadline_version as string } : {}),
       ...(r.ceo_minutes !== null ? { ceoMinutes: r.ceo_minutes as number } : {}), ...(r.ceo_date !== null ? { ceoDate: r.ceo_date as string } : {}),
@@ -202,9 +203,9 @@ function putItem(db: Database, version: string, item: ChecklistItem): void {
   if (!feature) db.query('INSERT INTO features (id, title, owner, kind, created_at) VALUES (?, ?, ?, ?, ?)').run(item.id, item.title, item.owner ?? null, item.kind ?? null, item.updatedAt);
   // features.owner/kind follow the latest assignment so details() and the checklist never disagree after a set.
   else if (item.owner !== undefined || item.kind !== undefined) db.query('UPDATE features SET owner = COALESCE(?, owner), kind = COALESCE(?, kind) WHERE id = ?').run(item.owner ?? null, item.kind ?? null, item.id);
-  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, ceo_minutes=excluded.ceo_minutes, ceo_date=excluded.ceo_date, accelerator=excluded.accelerator, refs=excluded.refs, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
-    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
+  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, dispatch_kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, dispatch_kind=excluded.dispatch_kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, ceo_minutes=excluded.ceo_minutes, ceo_date=excluded.ceo_date, accelerator=excluded.accelerator, refs=excluded.refs, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
+    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.dispatchKind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
 }
 function jsonHash(contents: string | Buffer): string { return createHash('sha256').update(contents).digest('hex'); }
 
@@ -245,8 +246,8 @@ function importOnDb(db: Database, version: string): boolean {
       // Keep a legacy per-version title until an explicit retitle unifies the feature identity.
       if (!existing) putItem(db, version, item);
       else {
-        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
+        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, dispatch_kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.dispatchKind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
       }
     }
     for (const entry of data.history) record(db, version, entry);
@@ -273,7 +274,7 @@ function importOnDb(db: Database, version: string): boolean {
       record(db, version, { at: new Date().toISOString(), by: item.updatedBy, id: item.id, field: 'reimport', from: null, to: item, released: data.released, dev: data.dev });
       continue;
     }
-    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const;
+    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind', 'dispatchKind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const;
     const baseEvidence = (db.query('SELECT evidence FROM assignments WHERE feature_id = ? AND version = ?').get(item.id, version) as { evidence: string | null }).evidence ?? undefined;
     const preserveRefs = item.evidence === baseEvidence || item.evidence === current.evidence;
     const differs = fields.some((field) => field === 'evidence'

package/src/release-loop/gate-shards.ts

@@ -21,6 +21,8 @@ export interface GateShard {
   waitReason?: string;
   /** 계획 분 — 남은 시간 추정의 재료. */
   plannedMin?: number;
+  /** GATE-MULTI-HOST — 이 조각(가장 최근 시도)이 놓인 풀 멤버(kubectl 컨텍스트). 놓이기 전엔 없다. */
+  host?: string;
 }
 
 /** 게이트 노드의 판정 결과 — 끝난 조각의 rc≠0 을 «새로 생긴 실패»와 «기존 실패»로 가른 수. */
@@ -58,11 +60,13 @@ function shardOf(value: unknown): GateShard | null {
   const rc = num(raw.rc);
   const waitReason = str(raw.waitReason);
   const plannedMin = num(raw.plannedMin);
+  const host = str(raw.host, 120);
   return {
     id, state,
     ...(startedAt ? { startedAt } : {}), ...(endedAt ? { endedAt } : {}),
     ...(installSec !== undefined ? { installSec } : {}), ...(rc !== undefined ? { rc } : {}),
     ...(waitReason ? { waitReason } : {}), ...(plannedMin !== undefined ? { plannedMin } : {}),
+    ...(host ? { host } : {}),
   };
 }
 

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