elanous 0.2.14 → 0.2.15

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

@@ -30,6 +30,18 @@ export function releasedVersion(ledgerRoot = releaseLedgerRoot()): string {
     })[0] ?? '';
 }
 const walWait = new Int32Array(new SharedArrayBuffer(4));
+const SCHEMA_COLUMNS: Record<string, readonly string[]> = {
+  imported_versions: ['json_hash', 'imported_at'],
+  events: ['reason'],
+  assignments: ['priority', 'predecessors', 'deadline_version', 'ceo_minutes', 'ceo_date'],
+  release_schedules: ['freeze_from', 'freeze_until'],
+};
+function schemaCurrent(db: Database): boolean {
+  return Object.entries(SCHEMA_COLUMNS).every(([table, names]) => {
+    const columns = new Set((db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>).map((column) => column.name));
+    return names.every((name) => columns.has(name));
+  });
+}
 function open(root = releaseLedgerRoot()): Database {
   const path = join(root, 'release', 'features.sqlite');
   mkdirSync(dirname(path), { recursive: true });
@@ -48,22 +60,27 @@ function open(root = releaseLedgerRoot()): Database {
       }
     }
     db.exec('PRAGMA foreign_keys = ON');
-    if (!db.query("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'imported_versions'").get()) db.exec(`CREATE TABLE IF NOT EXISTS features (id TEXT PRIMARY KEY, title TEXT NOT NULL, owner TEXT, kind TEXT, created_at TEXT NOT NULL);
-    CREATE TABLE IF NOT EXISTS assignments (feature_id TEXT NOT NULL REFERENCES features(id), version TEXT NOT NULL, status TEXT NOT NULL, disposition TEXT, evidence TEXT, title_override TEXT, owner TEXT, kind TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL, PRIMARY KEY(feature_id, version));
-    CREATE TABLE IF NOT EXISTS events (seq INTEGER PRIMARY KEY AUTOINCREMENT, at TEXT NOT NULL, by TEXT NOT NULL, feature_id TEXT NOT NULL, version TEXT NOT NULL, field TEXT NOT NULL, "from" TEXT, "to" TEXT, released TEXT NOT NULL, dev TEXT NOT NULL, reason TEXT);
-    CREATE TABLE IF NOT EXISTS evidence (feature_id TEXT NOT NULL, version TEXT NOT NULL, ref TEXT NOT NULL, at TEXT NOT NULL, by TEXT NOT NULL);
-    CREATE TABLE IF NOT EXISTS imported_versions (version TEXT PRIMARY KEY, json_hash TEXT, imported_at TEXT);`);
-    const columns = db.query('PRAGMA table_info(imported_versions)').all() as Array<{ name: string }>;
-    if (!columns.some((column) => column.name === 'json_hash')) db.exec('ALTER TABLE imported_versions ADD COLUMN json_hash TEXT');
-    if (!columns.some((column) => column.name === 'imported_at')) db.exec('ALTER TABLE imported_versions ADD COLUMN imported_at TEXT');
-    if (!(db.query('PRAGMA table_info(events)').all() as Array<{ name: string }>).some((column) => column.name === 'reason')) db.exec('ALTER TABLE events ADD COLUMN reason TEXT');
-    db.exec('CREATE TABLE IF NOT EXISTS release_schedules (version TEXT PRIMARY KEY, cut_at TEXT NOT NULL, land_by TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL)');
-    const assignmentColumns = db.query('PRAGMA table_info(assignments)').all() as Array<{ name: string }>;
-    for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT']] as const) {
-      if (!assignmentColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE assignments ADD COLUMN ${name} ${sql}`);
-    }
-    const scheduleColumns = db.query('PRAGMA table_info(release_schedules)').all() as Array<{ name: string }>;
-    for (const name of ['freeze_from', 'freeze_until']) if (!scheduleColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE release_schedules ADD COLUMN ${name} TEXT`);
+    // Two processes opening a fresh ledger both saw a missing column and both ran ALTER TABLE ("duplicate column name").
+    // BEGIN IMMEDIATE serializes the schema check and the migration, so the second writer re-reads the migrated schema.
+    // An up-to-date ledger skips the write lock so readers don't queue behind each other.
+    if (!schemaCurrent(db)) db.transaction(() => {
+      if (!db.query("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'imported_versions'").get()) db.exec(`CREATE TABLE IF NOT EXISTS features (id TEXT PRIMARY KEY, title TEXT NOT NULL, owner TEXT, kind TEXT, created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS assignments (feature_id TEXT NOT NULL REFERENCES features(id), version TEXT NOT NULL, status TEXT NOT NULL, disposition TEXT, evidence TEXT, title_override TEXT, owner TEXT, kind TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL, PRIMARY KEY(feature_id, version));
+      CREATE TABLE IF NOT EXISTS events (seq INTEGER PRIMARY KEY AUTOINCREMENT, at TEXT NOT NULL, by TEXT NOT NULL, feature_id TEXT NOT NULL, version TEXT NOT NULL, field TEXT NOT NULL, "from" TEXT, "to" TEXT, released TEXT NOT NULL, dev TEXT NOT NULL, reason TEXT);
+      CREATE TABLE IF NOT EXISTS evidence (feature_id TEXT NOT NULL, version TEXT NOT NULL, ref TEXT NOT NULL, at TEXT NOT NULL, by TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS imported_versions (version TEXT PRIMARY KEY, json_hash TEXT, imported_at TEXT);`);
+      const columns = db.query('PRAGMA table_info(imported_versions)').all() as Array<{ name: string }>;
+      if (!columns.some((column) => column.name === 'json_hash')) db.exec('ALTER TABLE imported_versions ADD COLUMN json_hash TEXT');
+      if (!columns.some((column) => column.name === 'imported_at')) db.exec('ALTER TABLE imported_versions ADD COLUMN imported_at TEXT');
+      if (!(db.query('PRAGMA table_info(events)').all() as Array<{ name: string }>).some((column) => column.name === 'reason')) db.exec('ALTER TABLE events ADD COLUMN reason TEXT');
+      db.exec('CREATE TABLE IF NOT EXISTS release_schedules (version TEXT PRIMARY KEY, cut_at TEXT NOT NULL, land_by TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL)');
+      const assignmentColumns = db.query('PRAGMA table_info(assignments)').all() as Array<{ name: string }>;
+      for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT'], ['ceo_minutes', 'INTEGER'], ['ceo_date', 'TEXT']] as const) {
+        if (!assignmentColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE assignments ADD COLUMN ${name} ${sql}`);
+      }
+      const scheduleColumns = db.query('PRAGMA table_info(release_schedules)').all() as Array<{ name: string }>;
+      for (const name of ['freeze_from', 'freeze_until']) if (!scheduleColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE release_schedules ADD COLUMN ${name} TEXT`);
+    }).immediate();
     return db;
   } catch (error) { db.close(); throw error; }
 }
@@ -90,6 +107,14 @@ export function readSchedules(root?: string): ScheduleRow[] {
   finally { db.close(); }
 }
 
+/** Versions with checklist assignments, including SQLite-only releases without a schedule or legacy JSON. */
+export function assignedVersions(root = releaseLedgerRoot()): string[] {
+  if (!existsSync(join(root, 'release', 'features.sqlite'))) return [];
+  const db = open(root);
+  try { return (db.query('SELECT DISTINCT version FROM assignments ORDER BY version').all() as Array<{ version: string }>).map(({ version }) => version); }
+  finally { db.close(); }
+}
+
 export function writeSchedule(version: string, patch: { cutAt?: string; landBy?: string; freezeFrom?: string; freezeUntil?: string }, by: string, root?: string): ScheduleRow {
   validateVersion(version);
   const db = open(root);
@@ -144,16 +169,17 @@ function evidenceRefs(db: Database, version: string, id: string): string[] {
   return (db.query('SELECT ref FROM evidence WHERE feature_id = ? AND version = ? ORDER BY rowid').all(id, version) as Array<{ ref: string }>).map((row) => row.ref);
 }
 function items(db: Database, version: string): ChecklistItem[] {
-  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.priority, a.predecessors, a.deadline_version, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
-    FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.version = ? ORDER BY a.rowid`).all(version) as Array<Record<string, string | null>>;
+  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.priority, a.predecessors, a.deadline_version, a.ceo_minutes, a.ceo_date, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
+    FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.version = ? ORDER BY a.rowid`).all(version) as Array<Record<string, string | number | null>>;
   return rows.map((r) => {
-    const evidence = [r.evidence, ...evidenceRefs(db, version, r.id!)].filter((value) => value !== null).join('\n');
-    return { id: r.id!, title: r.title!, status: r.status as ChecklistItem['status'],
-      ...(r.owner !== null ? { owner: r.owner! } : {}), ...(r.kind !== null ? { kind: r.kind as ChecklistItem['kind'] } : {}),
-      ...(r.priority !== null ? { priority: r.priority as ChecklistItem['priority'] } : {}), ...(r.predecessors !== null ? { predecessors: JSON.parse(r.predecessors!) as string[] } : {}),
-      ...(r.deadline_version !== null ? { deadlineVersion: r.deadline_version! } : {}),
+    const evidence = [r.evidence, ...evidenceRefs(db, version, r.id as string)].filter((value) => value !== null).join('\n');
+    return { id: r.id as string, title: r.title as string, status: r.status as ChecklistItem['status'],
+      ...(r.owner !== null ? { owner: r.owner as string } : {}), ...(r.kind !== null ? { kind: r.kind as ChecklistItem['kind'] } : {}),
+      ...(r.priority !== null ? { priority: r.priority as ChecklistItem['priority'] } : {}), ...(r.predecessors !== null ? { predecessors: JSON.parse(r.predecessors as string) as string[] } : {}),
+      ...(r.deadline_version !== null ? { deadlineVersion: r.deadline_version as string } : {}),
+      ...(r.ceo_minutes !== null ? { ceoMinutes: r.ceo_minutes as number } : {}), ...(r.ceo_date !== null ? { ceoDate: r.ceo_date as string } : {}),
       ...(r.evidence !== null || evidence ? { evidence } : {}), ...(r.disposition !== null ? { disposition: r.disposition as ChecklistItem['disposition'] } : {}),
-      updatedAt: r.updated_at!, updatedBy: r.updated_by! };
+      updatedAt: r.updated_at as string, updatedBy: r.updated_by as string };
   });
 }
 function snapshot(db: Database, version: string, released: string, dev: string): Checklist {
@@ -165,9 +191,9 @@ function putItem(db: Database, version: string, item: ChecklistItem): void {
   if (!feature) db.query('INSERT INTO features (id, title, owner, kind, created_at) VALUES (?, ?, ?, ?, ?)').run(item.id, item.title, item.owner ?? null, item.kind ?? null, item.updatedAt);
   // features.owner/kind follow the latest assignment so details() and the checklist never disagree after a set.
   else if (item.owner !== undefined || item.kind !== undefined) db.query('UPDATE features SET owner = COALESCE(?, owner), kind = COALESCE(?, kind) WHERE id = ?').run(item.owner ?? null, item.kind ?? null, item.id);
-  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
-    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.updatedAt, item.updatedBy);
+  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, ceo_minutes=excluded.ceo_minutes, ceo_date=excluded.ceo_date, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
+    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.updatedAt, item.updatedBy);
 }
 function jsonHash(contents: string | Buffer): string { return createHash('sha256').update(contents).digest('hex'); }
 
@@ -208,8 +234,8 @@ function importOnDb(db: Database, version: string): boolean {
       // Keep a legacy per-version title until an explicit retitle unifies the feature identity.
       if (!existing) putItem(db, version, item);
       else {
-        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.updatedAt, item.updatedBy);
+        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.updatedAt, item.updatedBy);
       }
     }
     for (const entry of data.history) record(db, version, entry);
@@ -236,7 +262,7 @@ function importOnDb(db: Database, version: string): boolean {
       record(db, version, { at: new Date().toISOString(), by: item.updatedBy, id: item.id, field: 'reimport', from: null, to: item, released: data.released, dev: data.dev });
       continue;
     }
-    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion'] as const;
+    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate'] as const;
     const baseEvidence = (db.query('SELECT evidence FROM assignments WHERE feature_id = ? AND version = ?').get(item.id, version) as { evidence: string | null }).evidence ?? undefined;
     const preserveRefs = item.evidence === baseEvidence || item.evidence === current.evidence;
     const differs = fields.some((field) => field === 'evidence'
@@ -381,7 +407,7 @@ export function remove(version: string, id: string, by: string, released = relea
     return true;
   });
 }
-export function move(id: string, from: string, to: string, by: string, released = releasedVersion(), dev = devVersion(), reason?: string): Checklist {
+export function move(id: string, from: string, to: string, by: string, released = releasedVersion(), dev = devVersion(), reason?: string, options: { clearDisposition?: boolean } = {}): Checklist {
   validateVersion(from); validateVersion(to);
   if (from === to) throw new CliUserError('같은 판으로 옮길 수 없다');
   const db = open();
@@ -395,6 +421,7 @@ export function move(id: string, from: string, to: string, by: string, released
       if (collision) throw new CliUserError(`이미 있는 칸: ${JSON.stringify(id).slice(1, -1)} — ${to} · 담당 ${JSON.stringify(collision.owner ?? '-').slice(1, -1)} · ${collision.title.replace(/\s+/g, ' ').slice(0, 40)}`);
       const at = new Date().toISOString();
       db.query('UPDATE assignments SET version = ?, updated_at = ?, updated_by = ? WHERE feature_id = ? AND version = ?').run(to, at, by, id, from);
+      if (options.clearDisposition) db.query('UPDATE assignments SET disposition = NULL WHERE feature_id = ? AND version = ?').run(id, to);
       db.query('UPDATE evidence SET version = ? WHERE feature_id = ? AND version = ?').run(to, id, from);
       record(db, to, { at, by, id, field: 'move', from, to, released, dev, ...(reason !== undefined ? { reason } : {}) });
       return snapshot(db, to, released, dev);

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

@@ -0,0 +1,125 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { debug } from '../debug/log.js';
+import { listChecklist, setItem } from './checklist.js';
+import { evidencePlan, landedButYellow, type MergedChecklistPr } from './landed-but-yellow.js';
+import { assignedVersions, evidenceAdd } from './feature-store.js';
+
+export interface MergedPrChecklistDeps {
+  readPr?: (number: number, cwd: string) => { state: string; baseRefName: string; title: string; body: string | null; mergedAt: string };
+  versions?: () => string[];
+  checklist?: typeof listChecklist;
+  addEvidence?: typeof evidenceAdd;
+  setStatus?: typeof setItem;
+  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);
+  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?.() ?? (() => {
+    let recorded: string[] = [];
+    try { recorded = readdirSync(join(releaseLedgerRoot(), 'release')).filter((version) => /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(version)); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+    return [...new Set([...assignedVersions(), ...recorded])];
+  })();
+  let goal: string | undefined;
+  if (goalFile) {
+    try { goal = readFileSync(goalFile, 'utf8'); }
+    catch (error) { log('release.checklist', 'merged-pr-goal-unreadable', { pr: number, goalFile, error: String(error) }); }
+  }
+  // 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)];
+  // 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) => {
+    const snapshot = (deps.checklist ?? listChecklist)(version);
+    // The audit excludes green/done; evidence still applies to already-green cells.
+    const candidates = snapshot.items.map((item) => ({ ...item, status: 'yellow' as const }));
+    return landedButYellow(candidates, [prForMatch])
+      .filter((row) => row.prs.some((p) => p.basis === 'cell-line'))
+      .map((row) => ({ version, snapshot, row }));
+  });
+  const counts = new Map<string, number>();
+  for (const { row } of matches) counts.set(row.id, (counts.get(row.id) ?? 0) + 1);
+  for (const [id, count] of counts) {
+    if (count > 1) log('release.checklist', 'merged-pr-cell-ambiguous', { pr: number, id, versions: matches.filter((match) => match.row.id === id).map((match) => match.version) });
+  }
+  for (const { version, snapshot, row } of matches) {
+    if (counts.get(row.id) !== 1) continue;
+    for (const { id, ref } of 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 });
+    }
+    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' });
+        continue;
+      }
+      const from = snapshot.items.find((item) => item.id === row.id)!.status;
+      if (from !== 'green' && from !== 'done') {
+        (deps.setStatus ?? setItem)(version, row.id, { status: 'green' }, 'harness');
+        log('release.checklist', 'merged-pr-status-green', { version, id: row.id, pr: number, from, to: 'green' });
+      }
+    }
+  }
+  const found = new Set(matches.map(({ row }) => row.id));
+  const missing = [...new Set(designated)].filter((id) => !found.has(id));
+  if (!designated.length) log('release.checklist', 'merged-pr-cell-not-found', { pr: number });
+  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_END = '(?=[ \\t]*$|[ \\t]+[—–·(-])';
+const DESIGNATION = new RegExp(`^ {0,3}(?:#{1,6}[ \\t]+|[-*][ \\t]+)?칸[ \\t]*:[ \\t]*${LABEL_IDS}${LABEL_END}`);
+
+/** 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[] {
+  const lines: string[] = [];
+  let fence: { char: string; length: number } | null = null;
+  for (const raw of text.split('\n')) {
+    const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+    const marker = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+    if (fence) {
+      if (marker && marker[1]![0] === fence.char && marker[1]!.length >= fence.length && line.trim() === marker[1]) fence = null;
+      continue;
+    }
+    if (marker) { fence = { char: marker[1]![0]!, length: marker[1]!.length }; continue; }
+    if (/^( {4}|\t)/.test(line) || /^ {0,3}>/.test(line)) continue;
+    lines.push(line);
+  }
+  return lines;
+}
+
+/** Cell ids a document designates on a line head: `칸: 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());
+  }
+  return ids;
+}
+
+/** `이 칸 완료` counts only as a standalone prose line, not inside code or a quote. */
+export function declaresCompletion(goal: string): boolean {
+  return proseLines(goal).some((line) => /^\s*이 칸 완료\s*$/.test(line));
+}
+
+/** A PR title is one authored line: `칸: X — …` may follow a short prefix such as `[TC]` or 「…」. */
+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());
+  }
+  return ids;
+}

package/src/release-loop/placement.ts

@@ -5,18 +5,23 @@ import { CliUserError } from '../cli/cli-user-error.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { userConfigPath } from '../user-config.js';
-import { addItem, listChecklist, ownerMatches, parseOwner, setItem, type ChecklistItem } from './checklist.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';
 
 export type PlacementPriority = 'P0' | 'P1' | 'P2';
-export interface PlacementCell { id: string; title: string; owner: string; priority: PlacementPriority; predecessors: string[]; deadlineVersion?: string }
+export interface PlacementCell { id: string; title: string; owner: string; priority: PlacementPriority; predecessors: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string }
 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[];
+  blocked: Array<{ id: string; from: string; to: string; reason: string }>;
+}
 export interface PlacementDeps {
   now?: Date;
   schedules?: ReleaseSchedule[];
   merged24h?: number;
   seatCap?: Record<string, number>;
+  ceoDailyCap?: number;
   checklist?: typeof listChecklist;
   released?: string;
   dryRun?: boolean;
@@ -47,11 +52,38 @@ 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;
 }
 
-export function placementSeatCap(): Record<string, number> {
+function placementConfig(): { seatCap?: Record<string, number>; ceoDailyCap?: number } {
   const path = getElanousConfigDirOverride() ? join(effectiveInstanceRoot(), 'config.json') : userConfigPath();
   if (!existsSync(path)) return {};
-  const raw = JSON.parse(readFileSync(path, 'utf8')) as { release?: { placement?: { seatCap?: Record<string, number> } } };
-  return raw.release?.placement?.seatCap ?? {};
+  const raw = JSON.parse(readFileSync(path, 'utf8')) as { release?: { placement?: { seatCap?: Record<string, number>; ceoDailyCap?: number } } };
+  return raw.release?.placement ?? {};
+}
+
+export function placementSeatCap(): Record<string, number> { return placementConfig().seatCap ?? {}; }
+function validCeoCap(cap: number): number {
+  if (!Number.isSafeInteger(cap) || cap < 0) throw new CliUserError('잘못된 대표 하루 상한: release.placement.ceoDailyCap');
+  return cap;
+}
+
+export function placementCeoDailyCap(): number { return validCeoCap(placementConfig().ceoDailyCap ?? 30); }
+
+/** 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);
+}
+
+type CeoWork = Pick<ChecklistItem, 'id' | 'ceoMinutes' | 'ceoDate'>;
+function ceoOverload(item: CeoWork, row: ReleaseSchedule, snapshots: Map<string, { items: CeoWork[] }>, schedules: ReleaseSchedule[], cap: number): string | null {
+  if (!item.ceoMinutes) return null;
+  const day = ceoDay(item, row);
+  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}분 — 늦추기(다음 날짜/판) · 자리 대행(대표 분량 축소) · 묶기(촬영·승인 합산 분량 축소)를 제안`;
 }
 
 function dependencyViolation(
@@ -87,6 +119,7 @@ function available(row: ReleaseSchedule, now: number, backlog: readonly string[]
 export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): PlacementDecision {
   if (!input.id.trim() || !input.title.trim()) throw new CliUserError('칸 id 와 제목이 필요하다');
   if (!Array.isArray(input.predecessors) || input.predecessors.some((id) => typeof id !== 'string' || !id.trim() || id === input.id)) throw new CliUserError('선행 칸 id 가 잘못됐다');
+  validateCeoLoad(input);
   const seat = parseOwner(input.owner).seat;
   if (!['P0', 'P1', 'P2'].includes(input.priority)) throw new CliUserError(`잘못된 우선순위: ${input.priority}`);
   const now = (deps.now ?? new Date()).getTime();
@@ -109,6 +142,8 @@ export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): Place
   if (from && released && versionOrder(from, released) <= 0) throw new CliUserError(`이미 발행된 판의 칸은 배치하지 않는다: ${input.id}`);
   if (existing?.status === 'done') throw new CliUserError(`끝난 칸은 배치하지 않는다: ${input.id}`);
   if (existing && (existing.title !== input.title || existing.owner !== input.owner)) throw new CliUserError(`기존 칸 제목·담당 불일치: ${input.id}`);
+  const load = { id: input.id, ceoMinutes: input.ceoMinutes ?? existing?.ceoMinutes, ceoDate: input.ceoDate ?? existing?.ceoDate };
+  const ceoCap = validCeoCap(deps.ceoDailyCap ?? placementCeoDailyCap());
   const predecessors = input.predecessors.map((id) => {
     const version = locations.get(id);
     if (!version) throw new CliUserError(`없는 선행 칸: ${id}`);
@@ -133,46 +168,63 @@ export function placeCell(input: PlacementCell, deps: PlacementDeps = {}): Place
   const capacity = (row: ReleaseSchedule) => Math.floor(rate * (Date.parse(row.landBy!) - now) / 86_400_000 * 0.7);
   const displaced: PlacementDecision['displaced'] = [];
   let chosen: ReleaseSchedule | undefined;
-  for (const row of candidates) {
+  let loadIssue: string | null = null;
+  const feasible = candidates.filter((row) => !dependencyViolation(snapshots, locations, new Map([[input.id, row.version]]), input));
+  for (const row of feasible) {
     const placement = new Map([[input.id, row.version]]);
-    if (dependencyViolation(snapshots, locations, placement, input)) continue;
     const items = occupied(row.version);
     const seatItems = items.filter((item) => ownerMatches(item.owner, seat));
-    if (items.length < capacity(row) && seatItems.length < seatLimit) { chosen = row; break; }
-    if (input.priority !== 'P1' || from === row.version) continue;
+    const directIssue = ceoOverload(load, row, snapshots, schedules, ceoCap);
+    if (items.length < capacity(row) && seatItems.length < seatLimit) {
+      if (directIssue) { loadIssue ??= directIssue; continue; }
+      chosen = row;
+      break;
+    }
+    if (input.priority !== 'P1' || from === row.version) { loadIssue ??= directIssue; continue; }
     const next = open.find((later) => versionOrder(later.version, row.version) > 0);
-    if (!next || items.length - 1 >= capacity(row)) continue;
+    if (!next || items.length - 1 >= capacity(row)) { loadIssue ??= directIssue; continue; }
     const p2 = [...items].reverse().find((item) => {
       if (item.priority !== 'P2' || dependencyViolation(snapshots, locations, new Map([...placement, [item.id, next.version]]), input)) return false;
       if (item.deadlineVersion && versionOrder(next.version, item.deadlineVersion) > 0) return false;
       if (items.length < capacity(row) && !(seatItems.length >= seatLimit && ownerMatches(item.owner, seat))) return false;
       if (!item.owner) return false;
       const shiftedSeat = parseOwner(item.owner).seat;
-      return occupied(next.version).length < capacity(next) && occupied(next.version).filter((other) => ownerMatches(other.owner, shiftedSeat)).length < (caps[shiftedSeat] ?? Infinity);
+      if (occupied(next.version).length >= capacity(next) || occupied(next.version).filter((other) => ownerMatches(other.owner, shiftedSeat)).length >= (caps[shiftedSeat] ?? Infinity)) return false;
+      if (!(seatItems.length < seatLimit || (ownerMatches(item.owner, seat) && seatItems.length - 1 < seatLimit))) return false;
+
+      // Evaluate both changed cells against the same post-placement state, before either ledger write.
+      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);
+      if (issue) { loadIssue ??= issue; return false; }
+      return true;
     });
-    if (p2 && (seatItems.length < seatLimit || (ownerMatches(p2.owner, seat) && seatItems.length - 1 < seatLimit))) {
+    if (p2) {
       displaced.push({ id: p2.id, from: row.version, to: next.version, reason: `P1 ${input.id} 마감 판 ${row.version} 용량 확보를 위해 P2 이월` });
       chosen = row;
       break;
     }
+    loadIssue ??= directIssue;
   }
-  if (!chosen) throw new CliUserError(`${input.id} 배치할 판이 없다 — 용량·선행·마감·동결을 확인하라`);
+  if (!chosen) throw new CliUserError(loadIssue ?? `${input.id} 배치할 판이 없다 — 용량·선행·마감·동결을 확인하라`);
   const reason = `${input.priority} ${input.priority === 'P0' ? '사고·회귀·발행 막음: 다음 판' : input.priority === 'P1' ? `지시·행사 마감 판 ${deadlineVersion}` : '착지 마감 내 가장 이른 여유 판'} · 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';
     for (const shifted of displaced) move(shifted.id, shifted.from, shifted.to, by, undefined, undefined, shifted.reason);
     if (from && from !== chosen.version) move(input.id, from, chosen.version, by, undefined, undefined, reason);
-    if (from && (existing?.priority !== input.priority || JSON.stringify(existing.predecessors ?? []) !== JSON.stringify(input.predecessors) || (input.deadlineVersion !== undefined && existing.deadlineVersion !== input.deadlineVersion)))
-      setItem(chosen.version, input.id, { priority: input.priority, predecessors: input.predecessors, ...(input.deadlineVersion ? { deadlineVersion: input.deadlineVersion } : {}) }, by);
-    if (!from) addItem(chosen.version, { id: input.id, title: input.title, owner: input.owner, priority: input.priority, predecessors: input.predecessors, deadlineVersion });
+    if (from && (existing?.priority !== input.priority || JSON.stringify(existing.predecessors ?? []) !== JSON.stringify(input.predecessors) || (input.deadlineVersion !== undefined && existing.deadlineVersion !== input.deadlineVersion) || (input.ceoMinutes !== undefined && existing.ceoMinutes !== input.ceoMinutes) || (input.ceoDate !== undefined && existing.ceoDate !== input.ceoDate)))
+      setItem(chosen.version, input.id, { priority: input.priority, predecessors: input.predecessors, ...(input.deadlineVersion ? { deadlineVersion: input.deadlineVersion } : {}), ...(input.ceoMinutes !== undefined ? { ceoMinutes: input.ceoMinutes } : {}), ...(input.ceoDate !== undefined ? { ceoDate: input.ceoDate } : {}) }, by);
+    if (!from) addItem(chosen.version, { id: input.id, title: input.title, owner: input.owner, priority: input.priority, predecessors: input.predecessors, deadlineVersion, ...(load.ceoMinutes !== undefined ? { ceoMinutes: load.ceoMinutes } : {}), ...(load.ceoDate !== undefined ? { ceoDate: load.ceoDate } : {}) });
   }
   return decision;
 }
 
 function moveConstraint(
   item: ChecklistItem, to: ReleaseSchedule, backlog: readonly string[],
-  snapshots: Map<string, ChecklistItem[]>, now: number, rate: number, caps: Record<string, number>,
+  snapshots: Map<string, ChecklistItem[]>, now: number, rate: number, caps: Record<string, number>, rows: ReleaseSchedule[], ceoCap: number,
 ): string | null {
   if (!to.landBy || !available(to, now, backlog)) return '착지 마감이 지났거나 백로그 판이라 이동 불가';
   if (item.deadlineVersion && versionOrder(to.version, item.deadlineVersion) > 0) return '마감 판 뒤로 이월 불가';
@@ -181,6 +233,9 @@ 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);
+  if (loadIssue) return loadIssue;
   const locations = new Map<string, string>();
   for (const [version, items] of snapshots) for (const cell of items) {
     if (locations.has(cell.id)) return `여러 판의 같은 칸: ${cell.id}`;
@@ -198,30 +253,35 @@ function moveConstraint(
 }
 
 /** Only unstarted cells inside the two-hour pre-deadline window move; a dry run never writes. */
-export function rebalance(version: string, deps: PlacementDeps = {}): PlacementDecision[] {
+export function rebalance(version: string, deps: PlacementDeps = {}): RebalanceResult {
   const rows = [...(deps.schedules ?? listSchedules())].sort((a, b) => versionOrder(a.version, b.version));
   const current = rows.find((row) => row.version === version);
   if (!current?.landBy) throw new CliUserError(`착지 마감이 없는 판: ${version}`);
   const now = (deps.now ?? new Date()).getTime();
-  if (Date.parse(current.landBy) - now > 7_200_000 || Date.parse(current.landBy) <= now) return [];
+  if (Date.parse(current.landBy) - now > 7_200_000 || Date.parse(current.landBy) <= now) return { decisions: [], blocked: [] };
   const backlog = deps.backlog ?? BACKLOG_VERSIONS;
   const next = rows.find((row) => versionOrder(row.version, version) > 0 && !backlog.includes(row.version));
   const snapshots = new Map(rows.map((row) => [row.version, [...(deps.checklist ?? listChecklist)(row.version).items]]));
   const unstarted = snapshots.get(version)!.filter((item) => item.status === 'yellow' && !item.evidence);
   if (unstarted.length && !next) throw new CliUserError(`${version} 다음 판이 없다`);
-  if (!unstarted.length) return [];
+  if (!unstarted.length) return { decisions: [], blocked: [] };
   const rate = deps.merged24h ?? mergedPrsLast24h(new Date(now));
   const caps = deps.seatCap ?? placementSeatCap();
-  const decisions: PlacementDecision[] = [];
+  const ceoCap = validCeoCap(deps.ceoDailyCap ?? placementCeoDailyCap());
+  const result: RebalanceResult = { decisions: [], blocked: [] };
   for (const item of unstarted) {
-    if (moveConstraint(item, next!, backlog, snapshots, now, rate, caps)) continue;
+    const violation = moveConstraint(item, next!, backlog, snapshots, now, rate, caps, rows, ceoCap);
+    if (violation) {
+      result.blocked.push({ id: item.id, from: version, to: next!.version, reason: violation });
+      continue;
+    }
     const reason = `${version} 착지 마감 2시간 전 미시작 칸 이월`;
-    decisions.push({ id: item.id, from: version, version: next!.version, reason, displaced: [] });
+    result.decisions.push({ id: item.id, from: version, version: next!.version, reason, displaced: [] });
     snapshots.set(version, snapshots.get(version)!.filter((cell) => cell.id !== item.id));
     snapshots.get(next!.version)!.push(item);
   }
-  if (!deps.dryRun) for (const decision of decisions) move(decision.id, version, decision.version, deps.by ?? 'OP', undefined, undefined, decision.reason);
-  return decisions;
+  if (!deps.dryRun) for (const decision of result.decisions) move(decision.id, version, decision.version, deps.by ?? 'OP', undefined, undefined, decision.reason);
+  return result;
 }
 
 /** A seat may defer its own cell one release, never pull another owner's cell forward. */
@@ -236,7 +296,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());
+  const violation = moveConstraint(item, next, backlog, snapshots, now, rate, deps.seatCap ?? placementSeatCap(), rows, validCeoCap(deps.ceoDailyCap ?? placementCeoDailyCap()));
   if (violation) throw new CliUserError(`${id}: ${violation}`);
   if (!deps.dryRun) move(id, from, to, by, undefined, undefined, reason);
 }

package/src/seat-dispatch/seat-request-eligibility.ts

@@ -0,0 +1,19 @@
+export const DEFAULT_MAX_REQUEST_AGE_HOURS = 48;
+
+export type SeatRequestEligibility =
+  | { eligible: true }
+  | { eligible: false; reason: 'empty-body' | 'too-old' | 'slot-closed' };
+
+/** Unknown/unreadable slot status does not establish that a slot has closed. */
+export function seatRequestEligibility(
+  request: { text: string; queuedAt: string },
+  options: { now: Date; maxRequestAgeHours?: number; slotStatus?: string | null },
+): SeatRequestEligibility {
+  if (!request.text.trim()) return { eligible: false, reason: 'empty-body' };
+  const maxAgeHours = options.maxRequestAgeHours ?? DEFAULT_MAX_REQUEST_AGE_HOURS;
+  if (!Number.isFinite(maxAgeHours) || maxAgeHours < 0) throw new Error('invalid seat request max age hours');
+  const age = options.now.getTime() - Date.parse(request.queuedAt);
+  if (!Number.isFinite(age) || age > maxAgeHours * 60 * 60_000) return { eligible: false, reason: 'too-old' };
+  if (options.slotStatus === 'green' || options.slotStatus === 'done') return { eligible: false, reason: 'slot-closed' };
+  return { eligible: true };
+}