elanous 0.2.27 → 0.2.29

package/src/pty-shell/registry.ts

@@ -371,6 +371,12 @@ export interface StartOpts {
   kind?: string;
   /** 휴먼 리더블 닉네임 — 고유 id 와 함께 같은 PTY 를 부르는 다른 이름(나중에 goto 로 기억·접근). */
   nickname?: string;
+  /** Explicit origin for a host-owned PTY when the host process has no origin marker. */
+  origin?: { originRoot: string; controller?: string };
+  /** Explicit purpose for a host-owned PTY with no worktree goal. */
+  purpose?: string;
+  /** Seat that owns this PTY; absent for callers without a seat. */
+  seat?: string;
   /** 접근 모드 초기값(관찰 read/인터랙션 write/자율 auto). 기본 'write'(미션 등 헤드리스 자율은 'auto' 지정). */
   accessMode?: PtyAccessMode;
   /** 전환 정책 초기값(전환불가 locked/전환허용 open). 기본 'open'. */
@@ -766,6 +772,9 @@ export function startPty(opts: StartOpts): PtyHandle {
       id, kind: handle.kind, cmd: handle.cmd, ptyPid: adapter.pid,
       ...(handle.nickname ? { nickname: handle.nickname } : {}),
       ...(handle.workdir ? { workdir: handle.workdir } : {}),
+      ...(opts.origin ? { origin: opts.origin } : {}),
+      ...(opts.purpose ? { purpose: opts.purpose } : {}),
+      ...(opts.seat ? { seat: opts.seat } : {}),
       startedAt: handle.startedAt, now: Date.now(),
       identity: {
         ...(childSpaceId === undefined ? {} : { spaceId: childSpaceId }),
@@ -887,8 +896,16 @@ export function listPty(): PtyHandle[] {
 /** 닉네임 부여/변경 — 나중에 goto 로 기억·접근 쉽게. 없는 id 면 false. */
 export function renamePty(id: string, nickname: string): boolean {
   const h = getPty(id);
-  if (!h) return false;
-  h.setNickname(nickname);
+  if (h) {
+    h.setNickname(nickname);
+    return true;
+  }
+  // ⭐ 자식이 아닌 제어 대상(맨 `elanous` TUI 의 `tui:<pid>` 행 등)은 PtyHandle 이 없다 —
+  //    별명은 manifest 행에만 산다. 여기서 받지 않으면 IPC rename 이 그 행에 `unknown-pty` 로 진다.
+  const target = controlTargets.get(id);
+  if (!target || !target.isAlive()) return false;
+  if (PTY_MANIFEST_ENABLED) updatePtyManifestNickname(id, nickname.trim() || undefined, Date.now());
+  debug.log('pty.rename', 'control-target-renamed', { ptyId: id, nickname: nickname.trim() });
   return true;
 }
 

package/src/pty-shell/tui-run-state.ts

@@ -0,0 +1,253 @@
+// ── TUI 실행 상태 — 턴(busy/idle) ⊕ 기동 판 ⊕ stale 판정 ──
+//
+// 바깥 제어자(`elanous pty state <ref>`)가 «지금 턴 중인가»와 «이 프로세스가 어느 판 코드로 도는가»를
+// 화면 글자 grep 없이 알게 한다(대표 TUI OP 도그푸드 결함 #13).
+//
+// ⛔ 화면 하단 `⌥ HEAD@<sha>` 는 «세션 cwd 트리»의 HEAD 다 — 프로세스가 실은 코드가 아니다.
+//    10-14 실측: 15:19 에 뜬 TUI 가 15:4x 설치 갱신(5c0f98f) 뒤에도 새 판처럼 보였다.
+//    ⇒ 기동 판은 «기동 때 한 번» 잡아 manifest 행에 적고, 비교 대상(설치본 · 체크아웃 HEAD)은 «읽을 때» 잰다.
+//
+// 기록(TUI 쪽): 행 등록 직후 `startTuiRunStateRecorder` 가 판 ⊕ idle 을 적고, 대시보드가 턴 시작·끝에
+//   `reportTuiTurn` 을 부른다. 기록 실패는 `debug.log('pty.tui-state', …)` — 조용히 삼키지 않는다.
+// 판독(CLI 쪽): `describePtyRunState` 가 행 ⊕ 설치본 기록 ⊕ (체크아웃이면) 그 뿌리의 HEAD 로 판정한다.
+
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { debug } from '../debug/log.js';
+import { runGitCommand } from '../git-fs/runner.js';
+import { codeRevision, packageVersion, readInstallMetadataCommit } from '../version/code-revision.js';
+import { versionedDashboardInstallDir } from '../dashboard/stale-install-check.js';
+import {
+  updatePtyManifestBuild, updatePtyManifestTurn,
+  type PtyBuildIdentity, type PtyManifestRow, type PtyTurnState,
+} from './pty-manifest.js';
+
+const CODE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+// ── 기동 판 ──
+
+export interface RunningBuildDeps {
+  readonly codeRoot?: string;
+  readonly installRoot?: string;
+  readonly versionDirOf?: (codeRoot: string, installRoot?: string) => string | undefined;
+  readonly readInstallCommit?: (metadataPath: string) => string | undefined;
+  /** 체크아웃 HEAD(설치본 판 폴더가 아닐 때만). */
+  readonly revision?: () => string | undefined;
+  readonly version?: () => string;
+}
+
+/** 이 프로세스가 실은 코드의 판. 설치본 판 폴더면 그 폴더의 install.json, 아니면 코드 뿌리의 git HEAD. */
+export function resolveRunningBuild(deps: RunningBuildDeps = {}): PtyBuildIdentity {
+  const codeRoot = deps.codeRoot ?? CODE_ROOT;
+  const version = (deps.version ?? packageVersion)();
+  const versionDir = (deps.versionDirOf ?? versionedDashboardInstallDir)(codeRoot, deps.installRoot);
+  if (versionDir) {
+    // 판 폴더의 install.json 만이 «실은 판»의 증거다 — 못 읽으면 다른 출처로 메우지 않고 모른다로 둔다.
+    const sha = (deps.readInstallCommit ?? readInstallMetadataCommit)(join(versionDir, 'install.json')) ?? '';
+    return { version, sha, source: sha ? 'installed' : 'unknown', codeRoot };
+  }
+  const sha = (deps.revision ?? codeRevision)() ?? '';
+  return { version, sha, source: sha ? 'checkout' : 'unknown', codeRoot };
+}
+
+let bootBuild: PtyBuildIdentity | undefined;
+/** 기동 판 — 처음 부른 순간 한 번 잡고 그대로 둔다(뒤에 트리 HEAD 가 움직여도 «실은 코드»는 그대로다). */
+export function runningBuild(): PtyBuildIdentity {
+  bootBuild ??= resolveRunningBuild();
+  return bootBuild;
+}
+
+// ── 설치본 기록 ──
+
+export interface InstalledRecord {
+  readonly sha?: string;
+  /** install.json `installedAt`(epoch ms) — 못 읽으면 undefined. */
+  readonly installedAt?: number;
+}
+
+export function defaultInstallRoot(): string {
+  return join(homedir(), '.local', 'share', 'elanous');
+}
+
+/** 지금 `current` 가 가리키는 설치본의 commit ⊕ 설치 시각. */
+export function readCurrentInstallRecord(installRoot = defaultInstallRoot()): InstalledRecord {
+  const path = join(installRoot, 'current', 'install.json');
+  const sha = readInstallMetadataCommit(path);
+  let installedAt: number | undefined;
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8')) as { installedAt?: unknown };
+    const t = typeof parsed.installedAt === 'string' ? Date.parse(parsed.installedAt) : NaN;
+    if (Number.isFinite(t)) installedAt = t;
+  } catch { /* 설치본 없음 */ }
+  return { ...(sha ? { sha } : {}), ...(installedAt !== undefined ? { installedAt } : {}) };
+}
+
+export function readCheckoutHead(codeRoot: string): string | undefined {
+  try {
+    const r = runGitCommand(codeRoot, ['rev-parse', 'HEAD'], { encoding: 'utf8' });
+    const sha = r.status === 0 ? String(r.stdout).trim() : '';
+    return sha || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// ── stale 판정 ──
+
+export type BuildStaleReason =
+  /** 설치본 판으로 떴고 지금 설치본과 같다. */
+  | 'same-as-installed'
+  /** 설치본 판으로 떴는데 그 뒤 설치본이 바뀌었다 — 재기동해야 새 판. */
+  | 'installed-moved'
+  /** 체크아웃에서 떴고 그 뿌리의 HEAD 가 같다. */
+  | 'same-as-checkout'
+  /** 체크아웃에서 떴는데 그 뿌리의 HEAD 가 움직였다. */
+  | 'checkout-moved'
+  /** 판 기록이 없는 옛 행인데 설치본이 그 행보다 늦게 깔렸다(추정 — 설치본으로 떴다면 낡았다). */
+  | 'started-before-install'
+  /** 비교할 값을 못 얻었다 — «안 낡았다»가 아니다. */
+  | 'unknown';
+
+export interface BuildStaleness {
+  /** null = 못 쟀다(⛔ false 로 접지 않는다). */
+  readonly stale: boolean | null;
+  readonly reason: BuildStaleReason;
+}
+
+export function judgeBuildStaleness(input: {
+  readonly build?: PtyBuildIdentity;
+  readonly installed: InstalledRecord;
+  readonly checkoutHead?: string;
+  readonly startedAt?: number;
+}): BuildStaleness {
+  const { build, installed } = input;
+  if (build?.sha && build.source === 'installed') {
+    if (!installed.sha) return { stale: null, reason: 'unknown' };
+    return installed.sha === build.sha ? { stale: false, reason: 'same-as-installed' } : { stale: true, reason: 'installed-moved' };
+  }
+  if (build?.sha && build.source === 'checkout') {
+    if (!input.checkoutHead) return { stale: null, reason: 'unknown' };
+    return input.checkoutHead === build.sha ? { stale: false, reason: 'same-as-checkout' } : { stale: true, reason: 'checkout-moved' };
+  }
+  if (!build && input.startedAt !== undefined && installed.installedAt !== undefined && installed.installedAt > input.startedAt) {
+    return { stale: true, reason: 'started-before-install' };
+  }
+  return { stale: null, reason: 'unknown' };
+}
+
+// ── 판독(CLI) ──
+
+export type PtyTurnView = PtyTurnState | 'unknown';
+
+export interface PtyRunStateView {
+  readonly turn: PtyTurnView;
+  readonly turnAt?: number;
+  readonly build: PtyBuildIdentity | null;
+  readonly installed: string | null;
+  readonly stale: boolean | null;
+  readonly staleReason: BuildStaleReason;
+}
+
+export interface DescribeRunStateDeps {
+  readonly readInstalled?: () => InstalledRecord;
+  readonly readCheckoutHead?: (codeRoot: string) => string | undefined;
+}
+
+/** manifest 행 하나의 턴 ⊕ 판 ⊕ stale. 행이 없거나 죽었으면 턴은 unknown. */
+export function describePtyRunState(
+  row: Pick<PtyManifestRow, 'alive' | 'startedAt' | 'kind' | 'turnState' | 'turnAt' | 'build'> | null,
+  deps: DescribeRunStateDeps = {},
+): PtyRunStateView {
+  let installed: InstalledRecord = {};
+  try { installed = (deps.readInstalled ?? readCurrentInstallRecord)(); } catch { /* unknown */ }
+  const build = row?.build;
+  let checkoutHead: string | undefined;
+  // 판독 예외는 «모른다»(stale=null)로 — 조회 명령 자체를 깨지 않는다.
+  try {
+    if (build?.source === 'checkout' && build.codeRoot) checkoutHead = (deps.readCheckoutHead ?? readCheckoutHead)(build.codeRoot);
+  } catch { checkoutHead = undefined; }
+  // 판 기록 없는 옛 행의 «설치 뒤에 떴나» 추정은 elanous TUI 행에만 건다(셸 PTY 는 판과 무관하다).
+  const staleness = judgeBuildStaleness({
+    ...(build ? { build } : {}),
+    installed,
+    ...(checkoutHead ? { checkoutHead } : {}),
+    ...(row && row.kind === 'tui' ? { startedAt: row.startedAt } : {}),
+  });
+  const turn: PtyTurnView = row?.alive && row.turnState ? row.turnState : 'unknown';
+  return {
+    turn,
+    ...(turn !== 'unknown' && row?.turnAt ? { turnAt: row.turnAt } : {}),
+    build: build ?? null,
+    installed: installed.sha ?? null,
+    stale: staleness.stale,
+    staleReason: staleness.reason,
+  };
+}
+
+export function shortSha(sha: string | null | undefined): string {
+  return sha ? sha.slice(0, 7) : '-';
+}
+
+// ── 기록(TUI) ──
+
+export interface TuiRunStateRecorderDeps {
+  readonly now?: () => number;
+  readonly build?: () => PtyBuildIdentity;
+  readonly writeBuild?: (id: string, build: PtyBuildIdentity) => boolean;
+  readonly writeTurn?: (id: string, turn: PtyTurnState, at: number) => boolean;
+  readonly log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+interface ActiveRecorder {
+  readonly surfaceId: string;
+  readonly now: () => number;
+  readonly writeTurn: (id: string, turn: PtyTurnState, at: number) => boolean;
+  readonly log: (event: string, data: Record<string, unknown>) => void;
+  last?: PtyTurnState;
+}
+
+let active: ActiveRecorder | null = null;
+
+const defaultLog = (event: string, data: Record<string, unknown>): void => { debug.log('pty.tui-state', event, data); };
+
+/** TUI 행 등록 직후 부른다 — 판을 적고 턴을 idle 로 연다. 이후 `reportTuiTurn` 이 이 행에 적는다. */
+export function startTuiRunStateRecorder(surfaceId: string, deps: TuiRunStateRecorderDeps = {}): () => void {
+  const now = deps.now ?? Date.now;
+  const log = deps.log ?? defaultLog;
+  const writeTurn = deps.writeTurn ?? updatePtyManifestTurn;
+  let build: PtyBuildIdentity | undefined;
+  try { build = (deps.build ?? runningBuild)(); } catch (error) {
+    log('build-resolve-failed', { ptyId: surfaceId, error: error instanceof Error ? error.message : String(error) });
+  }
+  if (build) {
+    const ok = (() => { try { return (deps.writeBuild ?? updatePtyManifestBuild)(surfaceId, build); } catch { return false; } })();
+    log(ok ? 'build-recorded' : 'build-write-failed', { ptyId: surfaceId, sha: build.sha, version: build.version, source: build.source });
+  }
+  const recorder: ActiveRecorder = { surfaceId, now, writeTurn, log };
+  active = recorder;
+  writeTurnState(recorder, 'idle');
+  return () => { if (active === recorder) active = null; };
+}
+
+/** 대시보드가 턴 시작(busy)·끝(idle)에 부른다. 녹음기가 없으면(자기보고 꺼짐) 아무것도 안 한다. */
+export function reportTuiTurn(turn: PtyTurnState): void {
+  if (!active || active.last === turn) return;
+  writeTurnState(active, turn);
+}
+
+function writeTurnState(recorder: ActiveRecorder, turn: PtyTurnState): void {
+  const at = recorder.now();
+  let ok = false;
+  try { ok = recorder.writeTurn(recorder.surfaceId, turn, at); } catch { ok = false; }
+  if (ok) recorder.last = turn;
+  // 실패는 관측으로 남긴다 — 바깥 제어자는 그 사이 «unknown/낡은 값»을 본다. 성공은 남기지 않는다(턴마다 두 줄은 소음).
+  else recorder.log('turn-write-failed', { ptyId: recorder.surfaceId, turn, at });
+}
+
+export function resetTuiRunStateForTesting(): void {
+  active = null;
+  bootBuild = undefined;
+}

package/src/release-loop/checklist.ts

@@ -299,9 +299,20 @@ 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; dispatchKind?: ChecklistDispatchKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean | null }, by: string): Checklist {
+  return setItemGuarded(v, id, patch, by);
+}
+
+/** Apply a measured verdict only while the release cell is still the snapshot that was judged. */
+export function setItemIfSnapshot(v: string, id: string, patch: Parameters<typeof setItem>[2], by: string, expected: Pick<ChecklistItem, 'title' | 'status' | 'evidence'>): Checklist {
+  return setItemGuarded(v, id, patch, by, expected);
+}
+
+function setItemGuarded(v: string, id: string, patch: Parameters<typeof setItem>[2], by: string, expected?: Pick<ChecklistItem, 'title' | 'status' | 'evidence'>): Checklist {
   return mutate(v, (data, otherItems) => {
     const item = data.items.find((i) => i.id === id);
     if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
+    if (expected && (item.title !== expected.title || item.status !== expected.status || item.evidence !== expected.evidence))
+      throw new CliUserError(`판정 중 칸 변경: ${id}`, '현재 칸으로 다시 측정한다');
     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');

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

@@ -11,6 +11,7 @@ import { runSelfGateCli, type SelfGateCliOptions, type SelfGateCliResult } from
 import { dispatchHeavyCheck, isValidGateHost, type DispatchDeps, type DispatchOptions } from '../self-implement/gate-remote.js';
 import { latestPublishedPreviousVersion } from '../../scripts/release-loop/unattended-release.js';
 import { baseVersion, isReleaseVersion } from '../../scripts/release-loop/release-version.js';
+import { executeTuiNodeCheck, type ExecutedTuiCheck } from '../../scripts/release-loop/tui-node-checks.js';
 
 export const LIGHT_RC_ALWAYS_FILE = 'release/light-rc-always.txt';
 export const LIGHT_RC_DEFAULT_SHARDS = 4;
@@ -31,6 +32,8 @@ export interface LightRcOptions {
   /** Release ledger root for the previous-version lookup (release run's deps.ledgerRoot). */
   ledgerRoot?: string;
   log?: (line: string) => void;
+  /** Rehearsal-only TUI screen check; other light-rc callers keep their current defaults. */
+  rehearsalTui?: boolean;
 }
 
 export interface LightRcResult {
@@ -57,6 +60,7 @@ export interface LightRcResult {
   /** LIGHT-RC-MEASURE ③ — why the gate produced no measurement (e.g. `shard-2`); null = it measured. Carried in the
    *  JSON so the reason reaches the caller even when the remote child's human lines (stderr) do not. */
   unmeasured: string | null;
+  rehearsalTui?: ExecutedTuiCheck;
 }
 
 export interface LightRcDeps {
@@ -68,6 +72,7 @@ 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'>;
+  tuiCheck?: typeof executeTuiNodeCheck;
   /** 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 };
@@ -180,13 +185,21 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   let alwaysInclude = readList(cwd);
 
   let local: SelfGateCliResult | undefined;
-  const runLocal = () => {
+  let localTui: ExecutedTuiCheck | undefined;
+  const runLocal = async () => {
     // ① 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 });
+      if (opts.rehearsalTui) {
+        const command = async (cmd: string, args: string[], tree: string, limitMs?: number) => {
+          const run = spawnSync(cmd, args, { cwd: tree, encoding: 'utf8', timeout: limitMs });
+          return { rc: run.status ?? 2, output: `${run.stdout ?? ''}\n${run.stderr ?? ''}` };
+        };
+        localTui = await (deps.tuiCheck ?? executeTuiNodeCheck)(measuredCommit, dir, command);
+      }
     } finally { checkout?.cleanup(); }
     for (const line of local.lines) log(line);
     return local.exitCode;
@@ -195,7 +208,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   const rc = await (deps.dispatch ?? dispatchHeavyCheck)({
     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), '--head', measuredCommit, '--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', ...(opts.rehearsalTui ? ['--rehearsal-tui'] : [])],
     flags: { remote: opts.local ? undefined : opts.remote ?? true, local: !!opts.local },
     runLocal,
   }, {
@@ -236,11 +249,22 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
       unmeasured: typeof remote.unmeasured === 'string' && remote.unmeasured
         ? remote.unmeasured
         : typeof remote.introduced === 'number' ? null : LIGHT_RC_REASON_NOT_REPORTED,
+      ...(remote.rehearsalTui ? { rehearsalTui: remote.rehearsalTui } : {}),
     };
   }
   // 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;
+  if (opts.rehearsalTui) {
+    if (local) {
+      result.rehearsalTui = localTui ?? { outcome: 'unmeasured', detail: 'local TUI screen result missing' };
+    } else {
+      const tui = result.rehearsalTui;
+      result.rehearsalTui = tui && ['ok', 'fail', 'unmeasured'].includes(tui.outcome) && typeof tui.detail === 'string' && tui.detail.length > 0
+        ? tui : { outcome: 'unmeasured', detail: 'remote TUI screen result missing' };
+    }
+  }
+  result.ok = result.introduced === 0 && result.unclassified === 0 && result.unmeasured === null
+    && (!opts.rehearsalTui || result.rehearsalTui?.outcome === 'ok');
   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;
 }
@@ -250,5 +274,6 @@ export function formatLightRc(result: LightRcResult): string[] {
     `${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})`] : []),
+    ...(result.rehearsalTui ? [`  TUI screens: ${result.rehearsalTui.outcome} (${result.rehearsalTui.detail})`] : []),
   ];
 }

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

@@ -7,21 +7,25 @@ import { listChecklist, setItem } from './checklist.js';
 import { judgeLandedCell } from './landed-to-green.js';
 import { evidencePlan, landedButYellow, type MergedChecklistPr } from './landed-but-yellow.js';
 import { assignedVersions, evidenceAdd } from './feature-store.js';
+import { boundMergedTaskCells, candidateMergedTaskCells, closeMergedTaskCard } from '../task-agent/postland-card.js';
 
 export interface MergedPrChecklistDeps {
-  readPr?: (number: number, cwd: string) => { state: string; baseRefName: string; title: string; body: string | null; mergedAt: string };
+  readPr?: (number: number, cwd: string) => { state: string; baseRefName: string; title: string; body: string | null; mergedAt: string; url?: string; headRefOid?: string; files?: Array<{ path: string }> };
   versions?: () => string[];
   checklist?: typeof listChecklist;
   addEvidence?: typeof evidenceAdd;
   setStatus?: typeof setItem;
   judgeLanded?: typeof judgeLandedCell;
+  closeTaskCard?: typeof closeMergedTaskCard;
+  boundTaskCells?: typeof boundMergedTaskCells;
+  candidateTaskCells?: typeof candidateMergedTaskCells;
   log?: typeof debug.log;
 }
 
 /** A confirmed main merge is the only entry. The existing checklist matcher owns PR-to-cell decisions. */
 export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: string, deps: MergedPrChecklistDeps = {}): void {
   const log = deps.log ?? debug.log.bind(debug);
-  const pr = (deps.readPr ?? ((n, dir) => JSON.parse(execFileSync('gh', ['pr', 'view', String(n), '--json', 'state,baseRefName,title,body,mergedAt'], { cwd: dir, encoding: 'utf8', timeout: 30_000 })) as ReturnType<NonNullable<MergedPrChecklistDeps['readPr']>>))(number, cwd);
+  const pr = (deps.readPr ?? ((n, dir) => JSON.parse(execFileSync('gh', ['pr', 'view', String(n), '--json', 'state,baseRefName,title,body,mergedAt,url,headRefOid,files'], { cwd: dir, encoding: 'utf8', timeout: 30_000 })) as ReturnType<NonNullable<MergedPrChecklistDeps['readPr']>>))(number, cwd);
   if (pr.state !== 'MERGED' || pr.baseRefName !== 'main') return;
   const merged: MergedChecklistPr = { number, title: pr.title, body: pr.body, mergedAt: pr.mergedAt };
   const versions = deps.versions?.() ?? (() => {
@@ -43,6 +47,21 @@ export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: st
   const fromTitle = titleCells(pr.title);
   const fromGoal = goal ? goalFileCells(goal) : new Set<string>();
   const designated = [...new Set([...fromBody, ...fromTitle, ...fromGoal])];
+  // A TA card's bound checklist criterion owns its postland verdict. A prose completion
+  // declaration cannot turn that cell green before the measured TA judgment runs.
+  let taClosedId: string | null = null;
+  let taBoundIds = new Set<string>();
+  let taBindingUnreadable = false;
+  try {
+    taBoundIds = new Set((deps.candidateTaskCells ?? candidateMergedTaskCells)(number));
+    if (pr.url && pr.headRefOid) for (const id of (deps.boundTaskCells ?? boundMergedTaskCells)({ number, url: pr.url })) taBoundIds.add(id);
+  } catch (error) { taBindingUnreadable = true; log('release.checklist', 'postland-binding-unreadable', { pr: number, error: String(error) }); }
+  if (pr.url && pr.headRefOid && !taBindingUnreadable) {
+    try {
+      taClosedId = (deps.closeTaskCard ?? closeMergedTaskCard)({ ...pr, number, url: pr.url, headRefOid: pr.headRefOid }, cwd, { versions: [...new Set(versions)] });
+      if (taClosedId) taBoundIds.add(taClosedId);
+    } catch (error) { log('release.checklist', 'postland-card-error', { pr: number, ids: [...taBoundIds], error: String(error) }); }
+  }
   for (const id of designated) {
     log('release.checklist', 'merged-pr-cell-source', {
       pr: number,
@@ -67,19 +86,19 @@ export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: st
   }
   for (const { version, snapshot, row } of matches) {
     if (counts.get(row.id) !== 1) continue;
-    for (const { id, ref } of evidencePlan([row])) {
+    for (const { id, ref } of taClosedId === row.id ? [] : evidencePlan([row])) {
       (deps.addEvidence ?? evidenceAdd)(id, version, ref, 'harness', snapshot.released, snapshot.dev);
       log('release.checklist', 'merged-pr-evidence-added', { version, id, pr: number, ref });
     }
     const cell = snapshot.items.find((item) => item.id === row.id)!;
-    if (cell.status !== 'green' && cell.status !== 'done') {
+    if (!taBindingUnreadable && !taBoundIds.has(row.id) && cell.status !== 'green' && cell.status !== 'done') {
       try {
         (deps.judgeLanded ?? judgeLandedCell)({ version, id: row.id, title: cell.title, pr: number }, { cwd });
       } catch (error) {
         try { log('release.checklist', 'landed-green-error', { version, id: row.id, pr: number, error: String(error) }); } catch { /* Judgment remains fail-soft. */ }
       }
     }
-    if (goal && declaresCompletion(goal)) {
+    if (!taBindingUnreadable && !taBoundIds.has(row.id) && goal && declaresCompletion(goal)) {
       if (!goalCells(goal).has(row.id)) {
         log('release.checklist', 'merged-pr-status-skipped', { version, id: row.id, pr: number, reason: 'goal-does-not-name-cell' });
         continue;

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, head: stamp.sha, log: (line) => {
+            const result = await (deps.lightRc ?? ((version, cwd) => runLightRc(version, { ledgerRoot: root, head: stamp.sha, rehearsalTui: true, log: (line) => {
               for (const entry of line.split(/\r?\n/)) {
                 const file = /^- introduced: (.+?)(?: > |$)/.exec(entry)?.[1];
                 if (file && regressionFiles.length < 3) regressionFiles.push(file);

package/src/release-loop/rubric.ts

@@ -99,6 +99,76 @@ export function rubricPriority(text: string): ReturnType<typeof rubricGrade> {
   return rubric ? rubricGrade(rubricScore(rubric)) : 'P2';
 }
 
+// Rubric v2 — first slice: the formula only (line parsing and v1/v2 output are later slots).
+
+/** v2 value axes (L U F O R T M, each 0..3); Z divides the total, X subtracts from it. */
+export const RUBRIC_V2_VALUE_AXES = ['L', 'U', 'F', 'O', 'R', 'T', 'M'] as const;
+export const RUBRIC_V2_Z_CHOICES: readonly number[] = [1, 2, 4, 8];
+const V2_AXIS_KEYS = new Set<string>([...RUBRIC_V2_VALUE_AXES, 'Z', 'X']);
+
+/** Rubric v2 values: L U F O R T M each 0..3, Z ∈ {1,2,4,8}, X 0..3. */
+export interface RubricV2 {
+  L: number;
+  U: number;
+  F: number;
+  O: number;
+  R: number;
+  T: number;
+  M: number;
+  Z: number;
+  X: number;
+}
+
+/** The F weight is 2 through 2026-10-28 and 1 from 2026-10-29 on; asOf must retain its original date text. */
+export const RUBRIC_V2_F_CUTOVER_DAY = '2026-10-29';
+
+export function rubricV2FWeight(asOf: string): 2 | 1 {
+  const invalid = () => new Error(`루브릭 v2 기준 날짜가 잘못되었다: ${String(asOf)}`);
+  // A Date may already have normalized an impossible calendar day before this call.
+  if (typeof asOf !== 'string') throw invalid();
+  const parts = /^(\d{4}|[1-9]\d{4,5}|[+-]\d{6})-(\d{2})-(\d{2})(?:$|T)/.exec(asOf);
+  if (!parts) throw invalid();
+  const year = Number(parts[1]);
+  const month = Number(parts[2]);
+  const day = Number(parts[3]);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const daysInMonth = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
+  if (!daysInMonth || day < 1 || day > daysInMonth) throw invalid();
+  const date = new Date(asOf);
+  if (Number.isNaN(date.getTime())) throw invalid();
+  return date.getTime() >= Date.parse(`${RUBRIC_V2_F_CUTOVER_DAY}T00:00:00.000Z`) ? 1 : 2;
+}
+
+/** V = 2L + 2U + wF + 1.5O + 1.5R + 1.5T + M (w = rubricV2FWeight), 점수 = V / Z − 0.5X. */
+export function rubricScoreV2(values: RubricV2, asOf: string): number {
+  if (values === null || typeof values !== 'object' || Array.isArray(values)) throw new Error('루브릭 v2 값이 축 객체가 아니다');
+  const given = values as unknown as Record<string, unknown>;
+  for (const key of Object.keys(given)) {
+    if (!V2_AXIS_KEYS.has(key)) throw new Error(`루브릭 v2 알 수 없는 축: ${key}`);
+  }
+  const readAxis = (axis: (typeof RUBRIC_V2_VALUE_AXES)[number]): number => {
+    const value = given[axis];
+    if (typeof value !== 'number' || !Number.isFinite(value)) throw new Error(`루브릭 v2 축 ${axis} 값이 없다`);
+    if (value < 0 || value > 3) throw new Error(`루브릭 v2 축 ${axis} 값이 0~3 밖이다: ${value}`);
+    return value;
+  };
+  const L = readAxis('L');
+  const U = readAxis('U');
+  const F = readAxis('F');
+  const O = readAxis('O');
+  const R = readAxis('R');
+  const T = readAxis('T');
+  const M = readAxis('M');
+  const Z = given.Z;
+  if (typeof Z !== 'number' || !Number.isFinite(Z)) throw new Error('루브릭 v2 크기 Z 값이 없다');
+  if (!RUBRIC_V2_Z_CHOICES.includes(Z)) throw new Error(`루브릭 v2 크기 Z 값이 1·2·4·8 밖이다: ${Z}`);
+  const X = given.X;
+  if (typeof X !== 'number' || !Number.isFinite(X)) throw new Error('루브릭 v2 위험 X 값이 없다');
+  if (X < 0 || X > 3) throw new Error(`루브릭 v2 위험 X 값이 0~3 밖이다: ${X}`);
+  const w = rubricV2FWeight(asOf);
+  return (2 * L + 2 * U + w * F + 1.5 * O + 1.5 * R + 1.5 * T + M) / Z - 0.5 * X;
+}
+
 /** Inspect an existing checklist without initializing, importing, or migrating its ledger. */
 export function readRubricItems(version: string, ledgerRoot: string): Pick<ChecklistItem, 'id' | 'title' | 'evidence' | 'priority'>[] {
   const dbPath = join(ledgerRoot, 'release', 'features.sqlite');

package/src/render.ts

@@ -572,6 +572,10 @@ function parseAndRenderTable(lines: string[]): string {
  * Render a tool call header like Claude Code:
  * ⏺ ToolName(description)
  */
+export function singleLineToolHeaderText(text: string): string {
+  return text.replace(/[ \t]*(?:\r\n|\r|\n|\u2028|\u2029)[ \t]*/g, ' ↵ ');
+}
+
 export function toolHeader(
   toolName: string,
   description: string,
@@ -585,7 +589,7 @@ export function toolHeader(
     case 'error':   icon = applyColor(circle, 'error'); break;
   }
   const name = chalk.bold(toolName);
-  const desc = description ? chalk.dim(`(${description})`) : '';
+  const desc = description ? chalk.dim(`(${singleLineToolHeaderText(description)})`) : '';
   return `${icon} ${name}${desc}`;
 }