elanous 0.2.22 → 0.2.23

package/src/release-loop/checklist.ts

@@ -7,8 +7,9 @@ import { CliUserError } from '../cli/cli-user-error.js';
 
 export type ChecklistStatus = 'green' | 'yellow' | 'red' | 'done';
 export type ChecklistDisposition = 'move' | 'known-issue' | 'block';
-/** `screen` = a five-surface feature cell — its evidence carries a `짝:` line (MANUAL-five-surface-parity §A). */
-export type ChecklistKind = 'screen';
+/** `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 interface ChecklistItem {
   id: string;
   title: string;
@@ -227,7 +228,7 @@ export function validateCeoLoad(input: { ceoMinutes?: number; ceoDate?: string }
 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 {
   if (!input.id.trim()) throw new CliUserError('칸 id 가 비었다');
   if (!input.title.trim()) throw new CliUserError('칸 제목이 비었다');
-  if (input.kind !== undefined && input.kind !== 'screen') throw new CliUserError(`잘못된 종류: ${input.kind}`, 'screen');
+  if (input.kind !== undefined && !CHECKLIST_KINDS.includes(input.kind)) throw new CliUserError(`잘못된 종류: ${input.kind}`, 'screen|postpub');
   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('잘못된 선행 칸');
@@ -258,7 +259,7 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
     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 && patch.kind !== 'screen') throw new CliUserError(`잘못된 종류: ${patch.kind}`, 'screen');
+    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('잘못된 선행 칸');
     if (patch.deadlineVersion !== undefined) store.validateVersion(patch.deadlineVersion);
@@ -357,6 +358,8 @@ export interface ChecklistGate {
   blocked: string[];
   moved: string[];
   knownIssues: Array<{ id: string; title: string; evidence: string }>;
+  /** Post-publication cells excluded from the pre-publication judgement. */
+  postpub?: string[];
   /** Screen cells whose `짝:` line is missing or has an untracked ⏳ — a warning; it never changes `ok`. */
   parity?: Array<{ id: string; why: string }>;
 }
@@ -374,8 +377,9 @@ export function parityGap(evidence: string | undefined): string | null {
 }
 
 export function checklistGate(v: string): ChecklistGate {
-  const result: ChecklistGate = { ok: true, red: [], undecided: [], blocked: [], moved: [], knownIssues: [], parity: [] };
+  const result: ChecklistGate = { ok: true, red: [], undecided: [], blocked: [], moved: [], knownIssues: [], postpub: [], parity: [] };
   for (const item of listChecklist(v).items) {
+    if (item.kind === 'postpub') { result.postpub!.push(item.id); continue; }
     if (item.kind === 'screen') {
       const why = parityGap(item.evidence);
       if (why) result.parity!.push({ id: item.id, why });
@@ -388,16 +392,27 @@ export function checklistGate(v: string): ChecklistGate {
     else result.undecided.push(item.id);
   }
   result.ok = result.red.length === 0 && result.undecided.length === 0 && result.blocked.length === 0;
+  if (result.postpub!.length) debug.log('release-loop.checklist', 'gate-postpub-excluded', { version: v, ids: result.postpub });
   return result;
 }
 
 /** GATE-ENTRY-ALIGN: the cut-time judgement shared by `release run`'s entry check and the checklist-gate node —
- *  past the landing deadline a non-P0 yellow without a disposition is carried (moved), and a P0 yellow always blocks. */
+ *  past the landing deadline a non-P0 yellow without a disposition is carried (moved); P0 yellow blocks unless OP recorded known-issue. */
 export function cutChecklistGate(v: string, landBy: string | null | undefined, now: Date = new Date()): ChecklistGate & { autoMoved: string[] } {
-  const items = listChecklist(v).items;
+  const { items, history } = listChecklist(v);
   const overdue = landBy !== null && landBy !== undefined && now.getTime() > Date.parse(landBy);
-  const autoMoved = overdue ? items.filter((item) => item.status === 'yellow' && item.priority !== 'P0' && item.disposition === undefined).map((item) => item.id) : [];
-  const p0 = items.filter((item) => item.status === 'yellow' && item.priority === 'P0').map((item) => item.id);
+  const autoMoved = overdue ? items.filter((item) => item.kind !== 'postpub' && item.status === 'yellow' && item.priority !== 'P0' && item.disposition === undefined).map((item) => item.id) : [];
+  const p0 = items.filter((item) => {
+    if (item.kind === 'postpub' || item.status !== 'yellow' || item.priority !== 'P0') return false;
+    if (item.disposition === 'known-issue') {
+      const decision = [...history].reverse().find((entry) => entry.id === item.id && entry.field === 'disposition' && entry.to === 'known-issue');
+      if (decision?.by === 'OP') {
+        debug.log('release-loop.checklist', 'p0-known-issue-allowed', { version: v, id: item.id, by: decision.by, at: decision.at });
+        return false;
+      }
+    }
+    return true;
+  }).map((item) => item.id);
   const gate = checklistGate(v);
   gate.undecided = gate.undecided.filter((id) => !autoMoved.includes(id) && !p0.includes(id));
   gate.moved = gate.moved.filter((id) => !p0.includes(id)).concat(autoMoved);

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

@@ -3,6 +3,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { Database } from 'bun:sqlite';
 import { releaseLedgerRoot } from '../instance/resolve.js';
+import { assertNotTestWritingOps } from '../instance/test-write-guard.js';
 import { CliUserError } from '../cli/cli-user-error.js';
 import { debug } from '../debug/log.js';
 import { getUserConfig } from '../user-config.js';
@@ -46,6 +47,7 @@ function schemaCurrent(db: Database): boolean {
 }
 function open(root = releaseLedgerRoot()): Database {
   const path = join(root, 'release', 'features.sqlite');
+  assertNotTestWritingOps(path, 'open the checklist ledger');
   mkdirSync(dirname(path), { recursive: true });
   const db = new Database(path, { create: true, strict: true });
   try {
@@ -546,6 +548,7 @@ export function details(id: string): { id: string; title: string; owner: string
 export function exportJson(version: string, released = releasedVersion(), dev = devVersion()): Checklist {
   const data = list(version, released, dev);
   const path = jsonPath(version);
+  assertNotTestWritingOps(path, 'export the checklist ledger');
   mkdirSync(dirname(path), { recursive: true });
   const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
   const contents = `${JSON.stringify(data, null, 2)}\n`;

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

@@ -23,11 +23,19 @@ export interface GateShard {
   plannedMin?: number;
 }
 
+/** 게이트 노드의 판정 결과 — 끝난 조각의 rc≠0 을 «새로 생긴 실패»와 «기존 실패»로 가른 수. */
+export interface GateShardsVerdict {
+  introduced: number;
+  preexisting: number;
+}
+
 export interface GateShardsFile {
   v: 1;
   version: string;
   updatedAt: string;
   shards: GateShard[];
+  /** 판정이 나기 전에는 없다. 옛 파일(필드 없음)도 그대로 읽는다 — `v` 를 올리지 않는다. */
+  verdict?: GateShardsVerdict;
 }
 
 export function gateShardsPath(version: string, root: string = releaseLedgerRoot()): string {
@@ -58,7 +66,15 @@ function shardOf(value: unknown): GateShard | null {
   };
 }
 
-/** 파일이 없거나 깨졌으면 null. 알 수 없는 상태값의 조각은 버리되 파일 전체는 살린다. */
+function verdictOf(value: unknown): GateShardsVerdict | undefined {
+  if (!value || typeof value !== 'object') return undefined;
+  const raw = value as Record<string, unknown>;
+  const introduced = num(raw.introduced);
+  const preexisting = num(raw.preexisting);
+  return introduced !== undefined && preexisting !== undefined ? { introduced, preexisting } : undefined;
+}
+
+/** 파일이 없거나 깨졌으면 null. 알 수 없는 상태값의 조각은 버리되 파일 전체는 살린다(깨진 verdict 도 필드만 버린다). */
 export function readGateShards(path: string): GateShardsFile | null {
   let parsed: unknown;
   try { parsed = JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
@@ -68,7 +84,11 @@ export function readGateShards(path: string): GateShardsFile | null {
   const version = str(raw.version, 40);
   const updatedAt = str(raw.updatedAt, 40);
   if (!version || !updatedAt) return null;
-  return { v: 1, version, updatedAt, shards: raw.shards.map(shardOf).filter((s): s is GateShard => s !== null) };
+  const verdict = verdictOf(raw.verdict);
+  return {
+    v: 1, version, updatedAt, shards: raw.shards.map(shardOf).filter((s): s is GateShard => s !== null),
+    ...(verdict ? { verdict } : {}),
+  };
 }
 
 /** tmp → rename — 읽는 쪽이 반쯤 쓴 파일을 보지 않게. */
@@ -79,6 +99,17 @@ export function writeGateShards(path: string, file: GateShardsFile): void {
   renameSync(tmp, path);
 }
 
+/**
+ * GATE-LIVE-OBS-RC-WORDING ⓒ — the gate node writes its verdict into the board it already keeps, after judging.
+ * No board (a local, non-Pod gate) ⇒ false and nothing is written: a verdict never creates a board out of thin air.
+ */
+export function recordGateShardsVerdict(path: string, verdict: GateShardsVerdict, now: Date = new Date()): boolean {
+  const file = readGateShards(path);
+  if (!file) return false;
+  writeGateShards(path, { ...file, updatedAt: now.toISOString(), verdict });
+  return true;
+}
+
 export interface GateShardsSummary {
   total: number;
   counts: Record<ShardState, number>;
@@ -89,6 +120,9 @@ export interface GateShardsSummary {
   /** 끝났지만 rc≠0 인 조각 수 — 쓰는 쪽의 `done` 은 «조각 끝»일 뿐 «통과»가 아니다(판정은 게이트 노드가 기존/새로 가른다).
    *  0.2.20 컷 실측: 끝난 넷이 모두 rc 1 인데 화면이 «통과»로 읽었다. */
   doneWithFailures: number;
+  /** 게이트 노드의 판정(기존/새로). null = «판정 전» — 「새 실패 0」과 다른 값이다.
+   *  `summarizeShards` 는 늘 채운다(선택 필드인 것은 이 요약을 손으로 만드는 픽스처·읽는 쪽을 깨지 않으려는 것). */
+  verdict?: GateShardsVerdict | null;
   /** 도는 조각 중 계획 분을 가장 많이 넘긴 분(없으면 0). 넘겼으면 etaMin 은 «하한»일 뿐이라 화면이 그렇게 말한다
    *  — canary 10-07 실측: 계획 0.1분 · 실제 22분 → 넘김을 안 보이면 내내 «남은 약 0분». */
   overrunMin: number;
@@ -134,6 +168,7 @@ export function summarizeShards(file: GateShardsFile, now: number = Date.now()):
     counts,
     waitReasons: [...reasons].map(([reason, count]) => ({ reason, count })).sort((a, b) => b.count - a.count),
     doneWithFailures: file.shards.filter((s) => s.state === 'done' && s.rc !== undefined && s.rc !== 0).length,
+    verdict: file.verdict ?? null,
     etaMin: estimate(file.shards, now),
     overrunMin: Math.floor(overrun),
     staleMin: stale === null ? null : Math.floor(stale),
@@ -144,7 +179,16 @@ export const SHARD_WORD: Record<ShardState, string> = {
   pending: '대기', running: '돌기', done: '끝', retry: '재시도', timeout: '잘림', failed: '실패',
 };
 
-/** 외출 알림·/release 한 줄 — «조각 24 · 돌기 5 · 대기 8(CPU 부족 8) · 잘림 2 · 통과 9 · 남은 약 40분». */
+/**
+ * `끝` 꼬리. 기존 실패가 있는 판에선 조각 전부가 rc 1 로 끝난다(0.2.21 컷: 24/24) — 그래서 판정 전엔 rc≠0 을 «실패»라 부르지 않고,
+ * 판정 뒤엔 새로 생긴 실패만 싣는다(기존 실패 수는 줄에 안 싣는다).
+ */
+function doneTail(summary: GateShardsSummary): string {
+  if (summary.verdict) return summary.verdict.introduced > 0 ? `(새 실패 ${summary.verdict.introduced})` : '';
+  return summary.doneWithFailures ? `(rc≠0 ${summary.doneWithFailures} · 기존 실패 포함 · 판정 전)` : '';
+}
+
+/** 외출 알림·/release 한 줄 — «조각 24 · 돌기 5 · 대기 8(CPU 부족 8) · 잘림 2 · 끝 9(rc≠0 3 · 기존 실패 포함 · 판정 전) · 남은 약 40분». */
 export function shardsLine(summary: GateShardsSummary): string {
   const order: ShardState[] = ['running', 'pending', 'retry', 'timeout', 'failed', 'done'];
   const parts = [`조각 ${summary.total}`];
@@ -153,7 +197,7 @@ export function shardsLine(summary: GateShardsSummary): string {
     if (!n) continue;
     const why = state === 'pending' && summary.waitReasons.length
       ? `(${summary.waitReasons.slice(0, 2).map((w) => `${w.reason} ${w.count}`).join(' · ')})` : '';
-    const reported = state === 'done' && summary.doneWithFailures ? `(실패 보고 ${summary.doneWithFailures})` : '';
+    const reported = state === 'done' ? doneTail(summary) : '';
     parts.push(`${SHARD_WORD[state]} ${n}${why}${reported}`);
   }
   if (summary.overrunMin >= 1) parts.push(`계획보다 ${summary.overrunMin}분 넘게 도는 중 — 남은 시간 추정 불가`);

package/src/release-loop/landed-to-green.ts

@@ -0,0 +1,81 @@
+import { spawnSync } from 'node:child_process';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+
+export interface JudgeSignal { condition: string | null; observe: string | null; expect: string | null }
+export type ClassifiedSignal = { kind: 'measurable'; argv: string[] } | { kind: 'unmeasurable'; reason: string };
+export type GreenVerdict = 'proposed' | 'unmeasurable' | 'not-passed';
+export interface LandedCell { version: string; id: string; title: string; pr: number }
+export interface LandedGreenDeps {
+  cwd?: string;
+  ledgerRoot?: string;
+  run?: (argv: string[], cwd: string) => number;
+  log?: typeof debug.log;
+}
+
+/** Only a field label after a semicolon starts a new field; unknown tails stay attached to the observation. */
+export function parseJudgeSignals(text: string): JudgeSignal[] {
+  return text.split(/\r?\n/).flatMap((line) => {
+    const match = /^\s*판정 신호:\s*(.*)$/.exec(line);
+    if (!match) return [];
+    const signal: JudgeSignal = { condition: null, observe: null, expect: null };
+    const body = match[1]!;
+    const fields = [...body.matchAll(/(?:^|;)\s*(조건|관측|기대)\s*=/g)];
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i]!;
+      const value = body.slice(field.index! + field[0].length, fields[i + 1]?.index ?? body.length).trim();
+      const key = ({ 조건: 'condition', 관측: 'observe', 기대: 'expect' } as const)[field[1] as '조건' | '관측' | '기대'];
+      signal[key] = value || null;
+    }
+    return [signal];
+  });
+}
+
+export function classifySignal(signal: JudgeSignal): ClassifiedSignal {
+  const observe = signal.observe?.trim();
+  if (!observe || /[;|&$`<>]/.test(observe)) return { kind: 'unmeasurable', reason: 'missing observation or shell metacharacter' };
+  const argv = observe.split(/\s+/);
+  if (argv.length < 3 || argv[0] !== 'bun' || argv[1] !== 'test' || argv.slice(2).some((path) => !path.endsWith('.test.ts') || path.startsWith('-'))) {
+    return { kind: 'unmeasurable', reason: 'observation is not bun test with .test.ts paths' };
+  }
+  return { kind: 'measurable', argv };
+}
+
+function runTest(argv: string[], cwd: string): number {
+  const result = spawnSync(argv[0]!, argv.slice(1), { cwd, shell: false, timeout: 120_000, stdio: 'ignore' });
+  if (result.error) throw result.error;
+  return result.status ?? 1;
+}
+
+/** Proposals are evidence, never a checklist status transition. All I/O errors are observed and swallowed. */
+export function judgeLandedCell({ version, id, title, pr }: LandedCell, deps: LandedGreenDeps = {}): GreenVerdict | undefined {
+  const log = deps.log ?? debug.log.bind(debug);
+  try {
+    const signals = parseJudgeSignals(title);
+    const classified = signals.map(classifySignal);
+    let verdict: GreenVerdict;
+    let reason: string | undefined;
+    if (!signals.length || classified.some((signal) => signal.kind === 'unmeasurable')) {
+      verdict = 'unmeasurable';
+      reason = !signals.length ? 'no judge signals' : classified.find((signal) => signal.kind === 'unmeasurable')!.reason;
+    } else {
+      verdict = 'proposed';
+      for (const signal of classified) {
+        if (signal.kind !== 'measurable' || (deps.run ?? runTest)(signal.argv, deps.cwd ?? process.cwd()) !== 0) {
+          verdict = 'not-passed';
+          break;
+        }
+      }
+    }
+    const dir = join(deps.ledgerRoot ?? releaseLedgerRoot(), 'release', version);
+    mkdirSync(dir, { recursive: true });
+    appendFileSync(join(dir, 'green-proposals.jsonl'), JSON.stringify({ at: new Date().toISOString(), version, id, pr, verdict, signals, ...(reason ? { reason } : {}) }) + '\n');
+    log('release.checklist', `landed-green-${verdict}`, { version, id, pr, verdict, signals, ...(reason ? { reason } : {}) });
+    return verdict;
+  } catch (error) {
+    try { log('release.checklist', 'landed-green-error', { version, id, pr, error: String(error) }); } catch { /* Logging must not break the merge path. */ }
+    return undefined;
+  }
+}

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

@@ -42,6 +42,9 @@ export interface LightRcResult {
   remote: string | null;
   gateExitCode: number;
   ok: boolean;
+  /** 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;
 }
 
 export interface LightRcDeps {
@@ -57,6 +60,8 @@ export interface LightRcDeps {
 
 /** Shown when the gate ran remotely but the host name did not come back. */
 export const LIGHT_RC_UNKNOWN_HOST = '(remote · host unknown)';
+/** No measurement came back and the gate named no reason (an older gate, or a result without the field). */
+export const LIGHT_RC_REASON_NOT_REPORTED = 'reason not reported';
 
 const defaultGit = (args: string[], cwd: string) => {
   const run = spawnSync('git', args, { cwd, encoding: 'utf8' });
@@ -142,6 +147,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
       alwaysInclude: alwaysInclude.length,
       alwaysIncludeMissing: [...local.alwaysIncludeMissing],
       shards, remote: null, gateExitCode: local.exitCode, ok: false,
+      unmeasured: local.unmeasuredReason ?? (local.baseline ? null : LIGHT_RC_REASON_NOT_REPORTED),
     };
   } else {
     const remote = parseRemoteResult(Buffer.concat(captured).toString('utf8'));
@@ -156,12 +162,15 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
       alwaysIncludeMissing: Array.isArray(remote.alwaysIncludeMissing) ? remote.alwaysIncludeMissing.map(String) : [],
       shards, remote: typeof host === 'string' && host ? host : opts.remote ?? LIGHT_RC_UNKNOWN_HOST,
       gateExitCode: typeof remote.gateExitCode === 'number' ? remote.gateExitCode : rc, ok: false,
+      unmeasured: typeof remote.unmeasured === 'string' && remote.unmeasured
+        ? remote.unmeasured
+        : typeof remote.introduced === 'number' ? null : LIGHT_RC_REASON_NOT_REPORTED,
     };
   }
   // 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 });
+  debug.log('release.light-rc', 'done', { version, base, introduced: result.introduced, preexisting: result.preexisting, unclassified: result.unclassified, shards, remote: result.remote, unmeasured: result.unmeasured });
   return result;
 }
 
@@ -169,5 +178,6 @@ 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.unmeasured !== null ? [`  shards: unmeasured (${result.unmeasured})`] : []),
   ];
 }

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

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { releaseLedgerRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
 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';
 
@@ -13,6 +14,7 @@ export interface MergedPrChecklistDeps {
   checklist?: typeof listChecklist;
   addEvidence?: typeof evidenceAdd;
   setStatus?: typeof setItem;
+  judgeLanded?: typeof judgeLandedCell;
   log?: typeof debug.log;
 }
 
@@ -58,6 +60,14 @@ export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: st
       (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') {
+      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 (!goalCells(goal).has(row.id)) {
         log('release.checklist', 'merged-pr-status-skipped', { version, id: row.id, pr: number, reason: 'goal-does-not-name-cell' });

package/src/release-loop/placement.ts

@@ -7,12 +7,13 @@ import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { userConfigPath } from '../user-config.js';
 import { addItem, listChecklist, ownerMatches, parseOwner, setItem, validateCeoLoad, type ChecklistItem } from './checklist.js';
-import { move, releasedVersion } from './feature-store.js';
-import { listSchedules, type ReleaseSchedule } from './release-schedule.js';
-import { parseRubric, rubricScore } from './rubric.js';
+import { assignedVersions, move, releasedVersion } from './feature-store.js';
+import { debug } from '../debug/log.js';
+import { kstDay, listSchedules, type ReleaseSchedule } from './release-schedule.js';
+import { parseRubric, rubricScore, type rubricGrade } from './rubric.js';
 
 export type PlacementPriority = 'P0' | 'P1' | 'P2';
-export interface PlacementCell { id: string; title: string; owner: string; priority: PlacementPriority; predecessors: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean }
+export interface PlacementCell { id: string; title: string; owner: string; priority: PlacementPriority; grade?: ReturnType<typeof rubricGrade>; predecessors: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean }
 export interface PlacementDecision { id: string; from: string | null; version: string; reason: string; displaced: Array<{ id: string; from: string; to: string; reason: string }> }
 export interface RebalanceResult {
   decisions: PlacementDecision[];
@@ -24,6 +25,7 @@ export interface PlacementDeps {
   merged24h?: number;
   seatCap?: Record<string, number>;
   ceoDailyCap?: number;
+  ceoCalendar?: CeoCalendar;
   checklist?: typeof listChecklist;
   released?: string;
   dryRun?: boolean;
@@ -85,10 +87,18 @@ export function mergedPrsLast24h(now = new Date()): number {
   return rows.filter((row) => Date.parse(row.mergedAt) >= Date.parse(since) && Date.parse(row.mergedAt) <= now.getTime()).length;
 }
 
-function placementConfig(): { seatCap?: Record<string, number>; ceoDailyCap?: number } {
-  const path = getElanousConfigDirOverride() ? join(effectiveInstanceRoot(), 'config.json') : userConfigPath();
+export interface CeoCalendar {
+  /** KST inclusive term ranges. A term cap can tighten the normal daily budget. */
+  terms?: Array<{ from: string; to: string; dailyCap: number }>;
+  /** KST event days explicitly override the term/normal cap, including exceptions with extra time. */
+  events?: Record<string, number>;
+}
+
+function placementConfig(root?: string): { seatCap?: Record<string, number>; ceoDailyCap?: number; ceoCalendar?: CeoCalendar } {
+  const path = root !== undefined ? join(root, 'config.json')
+    : getElanousConfigDirOverride() ? join(effectiveInstanceRoot(), 'config.json') : userConfigPath();
   if (!existsSync(path)) return {};
-  const raw = JSON.parse(readFileSync(path, 'utf8')) as { release?: { placement?: { seatCap?: Record<string, number>; ceoDailyCap?: number } } };
+  const raw = JSON.parse(readFileSync(path, 'utf8')) as { release?: { placement?: { seatCap?: Record<string, number>; ceoDailyCap?: number; ceoCalendar?: CeoCalendar } } };
   return raw.release?.placement ?? {};
 }
 
@@ -100,23 +110,69 @@ function validCeoCap(cap: number): number {
 
 export function placementCeoDailyCap(): number { return validCeoCap(placementConfig().ceoDailyCap ?? 30); }
 
+function validDay(day: string): boolean {
+  return typeof day === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(day) && Number.isFinite(Date.parse(`${day}T00:00:00Z`))
+    && new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) === day;
+}
+
+function calendarCap(day: string, cap: number, calendar: CeoCalendar): number {
+  if (!calendar || (calendar.terms !== undefined && !Array.isArray(calendar.terms))
+    || (calendar.events !== undefined && (!calendar.events || typeof calendar.events !== 'object' || Array.isArray(calendar.events))))
+    throw new CliUserError('잘못된 대표 달력: release.placement.ceoCalendar');
+  let effective = cap;
+  for (const term of calendar.terms ?? []) {
+    if (!term || typeof term !== 'object') throw new CliUserError('잘못된 대표 학기 달력: release.placement.ceoCalendar.terms');
+    if (!validDay(term.from) || !validDay(term.to) || term.from > term.to) throw new CliUserError('잘못된 대표 학기 달력 날짜: release.placement.ceoCalendar.terms');
+    validCeoCap(term.dailyCap);
+    if (term.from <= day && day <= term.to) effective = Math.min(effective, term.dailyCap);
+  }
+  for (const [date, eventCap] of Object.entries(calendar.events ?? {})) {
+    if (!validDay(date)) throw new CliUserError('잘못된 대표 행사 달력 날짜: release.placement.ceoCalendar.events');
+    validCeoCap(eventCap);
+  }
+  return calendar.events?.[day] ?? effective;
+}
+
 /** Explicit day wins; otherwise a cell uses the target release's landing day in KST. */
 function ceoDay(item: { ceoDate?: string }, row: ReleaseSchedule): string {
-  return item.ceoDate ?? new Date(Date.parse(row.landBy!) + 9 * 3_600_000).toISOString().slice(0, 10);
+  return item.ceoDate ?? kstDay(row.landBy!);
 }
 
 type CeoWork = Pick<ChecklistItem, 'id' | 'ceoMinutes' | 'ceoDate'>;
-function ceoOverload(item: CeoWork, row: ReleaseSchedule, snapshots: Map<string, { items: CeoWork[] }>, schedules: ReleaseSchedule[], cap: number): string | null {
+function ceoOverload(item: CeoWork, row: ReleaseSchedule, snapshots: Map<string, { items: CeoWork[] }>, schedules: ReleaseSchedule[], cap: number, calendar: CeoCalendar = {}): string | null {
   if (!item.ceoMinutes) return null;
   const day = ceoDay(item, row);
+  const limit = calendarCap(day, cap, calendar);
   const peers = [...snapshots].flatMap(([version, snapshot]) => {
     const schedule = schedules.find((candidate) => candidate.version === version);
     return snapshot.items.filter((other) => other.id !== item.id && other.ceoMinutes
       && (other.ceoDate === day || (!other.ceoDate && schedule?.landBy && ceoDay(other, schedule) === day)));
   });
   const total = item.ceoMinutes + peers.reduce((sum, other) => sum + other.ceoMinutes!, 0);
-  if (total <= cap) return null;
-  return `대표 손 과부하 ${day} KST: ${[...peers.map((peer) => `${peer.id} ${peer.ceoMinutes}분`), `${item.id} ${item.ceoMinutes}분`].join(' + ')} = ${total}분 > 하루 상한 ${cap}분 — 늦추기(다음 날짜/판) · 자리 대행(대표 분량 축소) · 묶기(촬영·승인 합산 분량 축소)를 제안`;
+  if (total <= limit) return null;
+  const reason = `대표 손 과부하 ${day} KST: ${[...peers.map((peer) => `${peer.id} ${peer.ceoMinutes}분`), `${item.id} ${item.ceoMinutes}분`].join(' + ')} = ${total}분 > 하루 상한 ${limit}분 — 늦추기(다음 날짜/판) · 자리 대행(대표 분량 축소) · 묶기(촬영·승인 합산 분량 축소)를 제안`;
+  debug.log('release.placement', 'ceo-overload', { day, id: item.id, total, cap: limit, reason });
+  return reason;
+}
+
+/** Called by setSchedule before a landing-day change can overload an already placed cell. */
+export function checkScheduleCeoLoad(version: string, landBy: string, root?: string): void {
+  const schedules = listSchedules(root);
+  const proposed = schedules.some((row) => row.version === version)
+    ? schedules.map((row) => row.version === version ? { ...row, landBy } : row)
+    : [...schedules, { version, cutAt: landBy, landBy, updatedAt: '', updatedBy: '' }];
+  const target = proposed.find((row) => row.version === version)!;
+  const targetItems = listChecklist(version, root).items;
+  const changed = targetItems.filter((item) => item.ceoMinutes && !item.ceoDate);
+  if (!changed.length) return;
+  const versions = [...new Set([...proposed.map((row) => row.version), ...assignedVersions(root)])];
+  const snapshots = new Map(versions.map((v) => [v, { items: v === version ? targetItems : listChecklist(v, root).items }]));
+  const config = placementConfig(root);
+  const cap = validCeoCap(config.ceoDailyCap ?? 30);
+  for (const item of changed) {
+    const issue = ceoOverload(item, target, snapshots, proposed, cap, config.ceoCalendar);
+    if (issue) throw new CliUserError(issue);
+  }
 }
 
 function dependencyViolation(
@@ -161,6 +217,7 @@ export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): Place
   validateCeoLoad(input);
   const seat = parseOwner(input.owner).seat;
   if (!['P0', 'P1', 'P2'].includes(input.priority)) throw new CliUserError(`잘못된 우선순위: ${input.priority}`);
+  if (input.grade !== undefined && !['P1', 'P2', 'P3', 'P4'].includes(input.grade)) throw new CliUserError(`잘못된 루브릭 등급: ${input.grade}`);
   if (input.accelerator !== undefined && input.accelerator !== true && input.accelerator !== false) throw new CliUserError('가속 등급은 true 이거나 생략한다');
   const now = (deps.now ?? new Date()).getTime();
   const schedules = [...(deps.schedules ?? listSchedules())].sort((a, b) => versionOrder(a.version, b.version));
@@ -171,6 +228,9 @@ export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): Place
   const snapshots = new Map(sources.map((version) => [version, (deps.checklist ?? listChecklist)(version)]));
   const { locations, conflict } = cellLocations([...snapshots].map(([version, snapshot]) => [version, snapshot.items] as [string, readonly { id: string }[]]), released, backlog);
   if (conflict) throw new CliUserError(`여러 판의 같은 칸: ${conflict}`);
+  if (input.ceoMinutes || [...snapshots.values()].some((snapshot) => snapshot.items.some((item) => item.id === input.id && item.ceoMinutes))) {
+    for (const version of assignedVersions()) if (!snapshots.has(version)) snapshots.set(version, (deps.checklist ?? listChecklist)(version));
+  }
   // A backlog copy never outranks a scheduled cell with the same id.
   for (const version of backlog) for (const item of snapshots.get(version)?.items ?? []) if (!locations.has(item.id)) locations.set(item.id, version);
   const from = locations.get(input.id) ?? null;
@@ -181,6 +241,7 @@ export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): Place
   const accelerator = input.accelerator === true || (input.accelerator === undefined && existing?.accelerator === true);
   const load = { id: input.id, ceoMinutes: input.ceoMinutes ?? existing?.ceoMinutes, ceoDate: input.ceoDate ?? existing?.ceoDate };
   const ceoCap = validCeoCap(deps.ceoDailyCap ?? placementCeoDailyCap());
+  const ceoCalendar = deps.ceoCalendar ?? placementConfig().ceoCalendar ?? {};
   const predecessors = input.predecessors.map((id) => {
     const version = locations.get(id);
     if (!version) throw new CliUserError(`없는 선행 칸: ${id}`);
@@ -197,9 +258,12 @@ export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): Place
   if (input.priority === 'P1' && !deadlineVersion) throw new CliUserError(`P1 칸의 마감 판이 없다: ${input.id}`);
   if (input.priority !== 'P0' && deadlineVersion && !schedules.some((row) => row.version === deadlineVersion)) throw new CliUserError(`없는 마감 판: ${deadlineVersion}`);
   const eligible = open.filter((row) => predecessors.every((v) => versionOrder(row.version, v) > 0));
+  // Rubric grades rank discretionary placement, not incident/deadline priority. A P4 needs a separate merge/drop decision.
+  if (input.priority === 'P2' && input.grade === 'P4') throw new CliUserError(`${input.id} 배치할 판이 없다 — 루브릭 P4 칸은 합치거나 빼야 한다`);
+  const discretionary = eligible.filter((row) => !deadlineVersion || versionOrder(row.version, deadlineVersion) <= 0);
   const candidates = input.priority === 'P0' ? eligible.filter((row) => row.version === first?.version)
     : input.priority === 'P1' ? eligible.filter((row) => row.version === deadlineVersion)
-      : eligible.filter((row) => !deadlineVersion || versionOrder(row.version, deadlineVersion) <= 0);
+      : input.grade === 'P3' ? discretionary.reverse() : discretionary;
 
   const occupied = (version: string) => snapshots.get(version)!.items.filter((item) => item.status !== 'done' && item.id !== input.id);
   const capacity = (row: ReleaseSchedule) => Math.floor(rate * (Date.parse(row.landBy!) - now) / 86_400_000 * 0.7);
@@ -207,12 +271,13 @@ export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): Place
   let chosen: ReleaseSchedule | undefined;
   let loadIssue: string | null = null;
   const feasible = candidates.filter((row) => !dependencyViolation(snapshots, locations, new Map([[input.id, row.version]]), input, released));
-  // 판은 «마감 안 가장 이른 판»부터 본다(기존 불변식). 가속 등급은 그 판이 찼을 때 같은 우선순위 비가속 칸을 밀 수 있게만 한다.
+  // Without a deferral grade, keep the earliest eligible release; P3 starts at the latest eligible release.
+  // Accelerator displacement still only affects an otherwise full candidate.
   for (const row of feasible) {
     const placement = new Map([[input.id, row.version]]);
     const items = occupied(row.version);
     const seatItems = items.filter((item) => ownerMatches(item.owner, seat));
-    const directIssue = ceoOverload(load, row, snapshots, schedules, ceoCap);
+    const directIssue = ceoOverload(load, row, snapshots, schedules, ceoCap, ceoCalendar);
     if (items.length < capacity(row) && seatItems.length < seatLimit) {
       if (directIssue) { loadIssue ??= directIssue; continue; }
       chosen = row;
@@ -238,8 +303,8 @@ export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): Place
       const proposed = new Map<string, { items: CeoWork[] }>([...snapshots].map(([version, snapshot]) => [version, { items: snapshot.items.filter((cell) => cell.id !== input.id && cell.id !== item.id) }]));
       proposed.get(row.version)!.items.push(load);
       proposed.get(next.version)!.items.push(item);
-      const issue = ceoOverload(load, row, proposed, schedules, ceoCap)
-        ?? ceoOverload(item, next, proposed, schedules, ceoCap);
+      const issue = ceoOverload(load, row, proposed, schedules, ceoCap, ceoCalendar)
+        ?? ceoOverload(item, next, proposed, schedules, ceoCap, ceoCalendar);
       if (issue) { loadIssue ??= issue; return false; }
       return true;
     });
@@ -253,7 +318,7 @@ export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): Place
     loadIssue ??= directIssue;
   }
   if (!chosen) throw new CliUserError(loadIssue ?? `${input.id} 배치할 판이 없다 — 용량·선행·마감·동결을 확인하라`);
-  const reason = `${accelerator ? '가속 등급 · ' : ''}${input.priority} ${input.priority === 'P0' ? '사고·회귀·발행 막음: 다음 판' : input.priority === 'P1' ? `지시·행사 마감 판 ${deadlineVersion}` : '착지 마감 내 가장 이른 여유 판'}${accelerator ? ' · 같은 우선순위 안에서 가속 등급을 먼저' : ''} · PR/24h ${rate} · 용량 ${capacity(chosen)} · 자리 ${seatLimit}`;
+  const reason = `${accelerator ? '가속 등급 · ' : ''}${input.priority} ${input.priority === 'P0' ? '사고·회귀·발행 막음: 다음 판' : input.priority === 'P1' ? `지시·행사 마감 판 ${deadlineVersion}` : input.grade === 'P3' ? '루브릭 P3: 착지 마감 내 가장 늦은 여유 판부터' : '착지 마감 내 가장 이른 여유 판'}${accelerator ? ' · 같은 우선순위 안에서 가속 등급을 먼저' : ''} · PR/24h ${rate} · 용량 ${capacity(chosen)} · 자리 ${seatLimit}`;
   const decision = { id: input.id, from, version: chosen.version, reason, displaced };
   if (!deps.dryRun) {
     const by = deps.by ?? 'OP';
@@ -268,7 +333,7 @@ export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): Place
 
 function moveConstraint(
   item: ChecklistItem, to: ReleaseSchedule, backlog: readonly string[],
-  snapshots: Map<string, ChecklistItem[]>, now: number, rate: number, caps: Record<string, number>, rows: ReleaseSchedule[], ceoCap: number,
+  snapshots: Map<string, ChecklistItem[]>, now: number, rate: number, caps: Record<string, number>, rows: ReleaseSchedule[], ceoCap: number, calendar: CeoCalendar,
   released: string | null | undefined,
 ): string | null {
   if (!to.landBy || !available(to, now, backlog)) return '착지 마감이 지났거나 백로그 판이라 이동 불가';
@@ -278,8 +343,11 @@ function moveConstraint(
   const destination = snapshots.get(to.version) ?? [];
   if (destination.filter((cell) => cell.status !== 'done').length >= Math.floor(rate * (Date.parse(to.landBy) - now) / 86_400_000 * 0.7)) return '다음 판 PR 용량 초과';
   if (destination.filter((cell) => cell.status !== 'done' && ownerMatches(cell.owner, seat)).length >= (caps[seat] ?? Infinity)) return '다음 판 자리 용량 초과';
-  const loadIssue = ceoOverload(item, to, new Map([...snapshots].map(([version, items]) => [version, { items }])),
-    rows, ceoCap);
+  const ceoSnapshots = new Map([...snapshots].map(([version, items]) => [version, { items }]));
+  if (item.ceoMinutes) for (const version of assignedVersions()) {
+    if (!ceoSnapshots.has(version)) ceoSnapshots.set(version, { items: listChecklist(version).items });
+  }
+  const loadIssue = ceoOverload(item, to, ceoSnapshots, rows, ceoCap, calendar);
   if (loadIssue) return loadIssue;
   const { locations, conflict } = cellLocations(snapshots, released);
   if (conflict) return `여러 판의 같은 칸: ${conflict}`;
@@ -321,9 +389,10 @@ export function rebalance(version: string, deps: PlacementDeps = {}): RebalanceR
   const rate = deps.merged24h ?? mergedPrsLast24h(new Date(now));
   const caps = deps.seatCap ?? placementSeatCap();
   const ceoCap = validCeoCap(deps.ceoDailyCap ?? placementCeoDailyCap());
+  const ceoCalendar = deps.ceoCalendar ?? placementConfig().ceoCalendar ?? {};
   const result: RebalanceResult = { decisions: [], blocked: [] };
   for (const { item, score } of unstarted) {
-    const violation = moveConstraint(item, next!, backlog, snapshots, now, rate, caps, rows, ceoCap, deps.released ?? releasedVersion());
+    const violation = moveConstraint(item, next!, backlog, snapshots, now, rate, caps, rows, ceoCap, ceoCalendar, deps.released ?? releasedVersion());
     if (violation) {
       result.blocked.push({ id: item.id, from: version, to: next!.version, reason: violation });
       continue;
@@ -349,7 +418,7 @@ export function seatMove(id: string, from: string, to: string, by: string, reaso
   if (!ownerMatches(item.owner, parseOwner(by).seat) || next?.version !== to) throw new CliUserError('남의 칸 당기기 거부 — COO 에 요청');
   const now = (deps.now ?? new Date()).getTime();
   const rate = deps.merged24h ?? mergedPrsLast24h(new Date(now));
-  const violation = moveConstraint(item, next, backlog, snapshots, now, rate, deps.seatCap ?? placementSeatCap(), rows, validCeoCap(deps.ceoDailyCap ?? placementCeoDailyCap()), deps.released ?? releasedVersion());
+  const violation = moveConstraint(item, next, backlog, snapshots, now, rate, deps.seatCap ?? placementSeatCap(), rows, validCeoCap(deps.ceoDailyCap ?? placementCeoDailyCap()), deps.ceoCalendar ?? placementConfig().ceoCalendar ?? {}, deps.released ?? releasedVersion());
   if (violation) throw new CliUserError(`${id}: ${violation}`);
   if (!deps.dryRun) move(id, from, to, by, undefined, undefined, reason);
 }