elanous 0.2.24 → 0.2.25

package/src/preview/terminal.ts

@@ -19,7 +19,6 @@
 // just its mental model (active vs alternate buffer, viewport,
 // cursor, cell attrs).
 
-import type { IPty } from 'node-pty';
 import * as fs from 'node:fs';
 import { StringDecoder } from 'node:string_decoder';
 import { Terminal } from '@xterm/headless';
@@ -104,6 +103,17 @@ export interface PreviewTerminalOpts {
   onRawOutput?: (chunk: string) => void;
 }
 
+// ⛔ `import type { IPty } from 'node-pty'` 도 두지 않는다 — PWA `next build` 가 이 파일까지 타입 검사하는데,
+//   node-pty 는 optionalDependency 라 리눅스(WSL)·게이트 Pod 설치에서 빠지면 «Cannot find module 'node-pty'»
+//   로 빌드가 죽고 self-update 가 매번 실패한다(LINUX-SELF-UPDATE-NODEPTY · 10-11). 이 파일이 실제로 쓰는 면만 둔다.
+/** node-pty `IPty` 중 이 파일이 부르는 면(pid · resize · kill · onExit). master fd 는 resolveMasterFd 가 비공개 칸에서 읽는다. */
+export interface NodePtyHandle {
+  readonly pid: number;
+  resize(cols: number, rows: number): void;
+  kill(signal?: string): void;
+  onExit(listener: (e: { exitCode: number | null; signal?: number }) => void): unknown;
+}
+
 /** Shared so tests can override (fake pty) — the default is node-pty. */
 export type SpawnFn = (shell: string, args: string[], opts: {
   name: string;
@@ -111,7 +121,7 @@ export type SpawnFn = (shell: string, args: string[], opts: {
   rows: number;
   cwd: string;
   env: Record<string, string>;
-}) => IPty;
+}) => NodePtyHandle;
 
 // ⛔⭐ `node-pty` 를 «최상위»에서 싣지 않는다 — 이 모듈은 dashboard·shell-runner 등 다섯 곳이
 //   정적으로 끌어오므로, 최상위 import 면 ***PTY 를 안 쓰는 명령(`--version`)까지*** 네이티브 바인딩을
@@ -124,7 +134,7 @@ export type SpawnFn = (shell: string, args: string[], opts: {
 const defaultSpawn: SpawnFn = (shell, args, o) => {
   // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any
   const pty: any = require('node-pty');
-  return pty.spawn(shell, args, o as any) as IPty;
+  return pty.spawn(shell, args, o as any) as NodePtyHandle;
 };
 
 /** node-pty 네이티브 `resize(fd, cols, rows)` 를 임의의 master fd(우리 dup)에 부른다. 'ok' 또는 실패 사유. */
@@ -163,7 +173,7 @@ export interface PreviewRegistryDeps {
 }
 
 export class PreviewTerminal {
-  private pty: IPty | null = null;
+  private pty: NodePtyHandle | null = null;
   private dupFd: number = -1;
   /** ★ P0b-2 — useRegistry 모드일 때 공유 버스 핸들(dup-fd 대신). null=dup-fd 경로(기본). */
   private registryHandle: PtyHandle | null = null;
@@ -470,7 +480,7 @@ export class PreviewTerminal {
   /** node-pty doesn't publish its master fd as a stable field; dig
    *  through the plausible private slots in order of most-to-least
    *  likely so a minor library revision doesn't bite us. */
-  private resolveMasterFd(p: IPty): number | null {
+  private resolveMasterFd(p: NodePtyHandle): number | null {
     const any = p as any;
     const fd = any._fd
       ?? any._socket?._handle?.fd

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

@@ -102,6 +102,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));
@@ -244,6 +252,7 @@ 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 };
@@ -254,7 +263,7 @@ export function addItem(v: string, input: { id: string; title: string; refs?: st
 }
 
 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) => {
+  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}`);
@@ -262,6 +271,7 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
     if (patch.kind !== undefined && !CHECKLIST_KINDS.includes(patch.kind)) throw new CliUserError(`잘못된 종류: ${patch.kind}`, 'screen|postpub');
     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);

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

package/src/seat-loop/duty-ledger.ts

@@ -0,0 +1,64 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export const DUTY_STATUSES = ['standing', 'done', 'missed'] as const;
+export type DutyStatus = (typeof DUTY_STATUSES)[number];
+
+export type DutyRow = {
+  at: string;
+  seat: string;
+  duty: string;
+  source: string;
+  status: DutyStatus;
+  ref?: string;
+};
+
+export type DutyInput = Omit<DutyRow, 'at' | 'status'> & { at?: string; status?: DutyStatus };
+
+const DUTY_KEYS: ReadonlySet<string> = new Set(['at', 'seat', 'duty', 'source', 'status', 'ref']);
+const SEAT_PATTERN = /^(?:MK|UX|TC|OP|role:\S+)$/;
+
+const dutyLedgerPath = (root: string): string => join(root, 'seat-duties', 'duties.jsonl');
+
+function nonEmpty(row: Record<string, unknown>, key: string): string {
+  const value = row[key];
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`duty ${key} must be a non-empty string`);
+  return value;
+}
+
+function validate(input: Record<string, unknown>, now: () => Date): DutyRow {
+  for (const key of Object.keys(input)) {
+    if (!DUTY_KEYS.has(key)) throw new Error(`unknown duty key: ${key}`);
+  }
+  const seat = nonEmpty(input, 'seat');
+  if (!SEAT_PATTERN.test(seat)) throw new Error(`invalid duty seat: ${seat} (use MK|UX|TC|OP|role:<name>)`);
+  const status = input.status === undefined ? 'standing' : input.status;
+  if (!DUTY_STATUSES.includes(status as DutyStatus)) throw new Error(`invalid duty status: ${String(status)}`);
+  const at = input.at === undefined ? now().toISOString() : nonEmpty(input, 'at');
+  if (Number.isNaN(Date.parse(at))) throw new Error(`invalid duty at: ${at}`);
+  const row: DutyRow = { at, seat, duty: nonEmpty(input, 'duty'), source: nonEmpty(input, 'source'), status: status as DutyStatus };
+  if (input.ref !== undefined) row.ref = nonEmpty(input, 'ref');
+  return row;
+}
+
+/** Appends one validated row; a rejected row never reaches the file. */
+export function appendDuty(root: string, input: DutyInput, now: () => Date = () => new Date()): DutyRow {
+  const row = validate(input as Record<string, unknown>, now);
+  const path = dutyLedgerPath(root);
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(row)}\n`);
+  try { debug.log('seat-loop.duty', 'appended', { seat: row.seat, duty: row.duty }); } catch { /* observation cannot change a write */ }
+  return row;
+}
+
+export function listDuties(root: string, filters: { seat?: string } = {}): DutyRow[] {
+  const path = dutyLedgerPath(root);
+  if (!existsSync(path)) return [];
+  const rows = readFileSync(path, 'utf8').split('\n').filter((line) => line.trim())
+    .map((line) => JSON.parse(line) as DutyRow)
+    .filter((row) => filters.seat === undefined || row.seat === filters.seat);
+  return rows.map((row, index) => ({ row, index }))
+    .sort((a, b) => Date.parse(a.row.at) - Date.parse(b.row.at) || a.index - b.index)
+    .map(({ row }) => row);
+}

package/src/self-dev/decompose.ts

@@ -14,8 +14,12 @@
  *
  * Cf. PLAN-parallel-self-dev-orchestrator-2026-07-21 §6 (S2).
  */
-import { tierModel } from '../llm/model-defaults.js';
 import { debug } from '../debug/log.js';
+import {
+  resolveRoleModel,
+  type ModelResolutionSource,
+  type UserConfig,
+} from '../user-config.js';
 import {
   gradePhaseCompletability,
   type CompletabilitySizeSignals,
@@ -598,9 +602,39 @@ export async function decomposeSelfDevGoal(
   return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
 }
 
+/** Where the decompose model came from — `'explicit'` is the caller's `model` argument layer. */
+export type DecomposeModelSource = 'explicit' | ModelResolutionSource;
+
+export interface DecomposeModelResolution {
+  model: string;
+  source: DecomposeModelSource;
+}
+
+export interface DecomposeModelDeps {
+  /** Config handed to the planning-role default; omitted uses the user config. */
+  config?: UserConfig;
+}
+
+/**
+ * ROLE-RELAY-SPLIT — the decompose model selector (pure).
+ *
+ * An explicit `model` argument wins; the default is the existing planning-role
+ * resolver `resolveRoleModel('planning')` (env `ELANOUS_SKILL_PLAN_MODEL` ·
+ * `roleLlm.planning` · tier `best` — the same tier the old default used), NOT
+ * the review env `ELANOUS_PR_REVIEW_MODEL`: changing the review model must
+ * not drag the decompose model along.
+ */
+export function decomposeModel(explicit?: string, deps: DecomposeModelDeps = {}): DecomposeModelResolution {
+  const pinned = explicit?.trim();
+  if (pinned) return { model: pinned, source: 'explicit' };
+  const resolved = resolveRoleModel('planning', deps.config);
+  return { model: resolved.model, source: resolved.source };
+}
+
 /** Default LLM seam — lazy `streamLLM` wire (kept out of the test path). */
 async function defaultDecomposeLlm(model?: string): Promise<SelfDevDecomposeLlm> {
   const { streamLLM } = await import('../llm.js');
-  const m = model || process.env.ELANOUS_PR_REVIEW_MODEL || tierModel('best');
-  return (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, { model: m, reasoningEffort: 'low' });
+  const { model: resolved, source } = decomposeModel(model);
+  debug.log('self-dev.decompose', 'model', { model: resolved, source });
+  return (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, { model: resolved, reasoningEffort: 'low' });
 }