elanous 0.2.13 → 0.2.15

package/src/release-loop/checklist.ts

@@ -13,6 +13,11 @@ export interface ChecklistItem {
   title: string;
   status: ChecklistStatus;
   owner?: string;
+  priority?: 'P0' | 'P1' | 'P2';
+  predecessors?: string[];
+  deadlineVersion?: string;
+  ceoMinutes?: number;
+  ceoDate?: string;
   evidence?: string;
   disposition?: ChecklistDisposition;
   kind?: ChecklistKind;
@@ -93,11 +98,20 @@ function change(data: Checklist, id: string, field: string, from: unknown, to: u
   debug.log('release-loop.checklist', 'change', { version: data.version, id, field, from: from ?? null, to: to ?? null, by });
 }
 
-export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind }, options: { allowDuplicateId?: boolean } = {}): Checklist {
+export function validateCeoLoad(input: { ceoMinutes?: number; ceoDate?: string }): void {
+  if (input.ceoMinutes !== undefined && (!Number.isSafeInteger(input.ceoMinutes) || input.ceoMinutes < 0)) throw new CliUserError('대표 손 분량은 0 이상의 정수 분이어야 한다');
+  if (input.ceoDate !== undefined && (!/^\d{4}-\d{2}-\d{2}$/.test(input.ceoDate) || !Number.isFinite(Date.parse(`${input.ceoDate}T00:00:00Z`)) || new Date(`${input.ceoDate}T00:00:00Z`).toISOString().slice(0, 10) !== input.ceoDate)) throw new CliUserError('대표 손 날짜는 YYYY-MM-DD 이어야 한다');
+}
+
+export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string }, 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.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('잘못된 선행 칸');
+  if (input.deadlineVersion !== undefined) store.validateVersion(input.deadlineVersion);
+  validateCeoLoad(input);
   return mutate(v, (data, otherItems) => {
     if (data.items.some((item) => item.id === input.id)) throw new CliUserError(`이미 있는 칸: ${input.id}`, 'set <id> 로 고친다');
     const collisions = otherItems(input.id);
@@ -108,27 +122,31 @@ export function addItem(v: string, input: { id: string; title: string; owner?: s
     }
     const by = process.env.ELANOUS_TRACK || 'cli';
     const at = new Date().toISOString();
-    const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), updatedAt: at, updatedBy: by };
+    const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), ...(input.priority !== undefined ? { priority: input.priority } : {}), ...(input.predecessors !== undefined ? { predecessors: input.predecessors } : {}), ...(input.deadlineVersion !== undefined ? { deadlineVersion: input.deadlineVersion } : {}), ...(input.ceoMinutes !== undefined ? { ceoMinutes: input.ceoMinutes } : {}), ...(input.ceoDate !== undefined ? { ceoDate: input.ceoDate } : {}), updatedAt: at, updatedBy: by };
     data.items.push(item);
     change(data, item.id, 'add', null, item, by, at);
     return true;
   });
 }
 
-export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind }, by: string): Checklist {
+export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string }, by: string): Checklist {
   return mutate(v, (data) => {
     const item = data.items.find((i) => i.id === id);
     if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
     if (patch.status !== undefined && !['green', 'yellow', 'red', 'done'].includes(patch.status)) throw new CliUserError(`잘못된 상태: ${patch.status}`);
     if (patch.disposition !== undefined && !['move', 'known-issue', 'block'].includes(patch.disposition)) throw new CliUserError(`잘못된 처분: ${patch.disposition}`);
     if (patch.kind !== undefined && patch.kind !== 'screen') throw new CliUserError(`잘못된 종류: ${patch.kind}`, 'screen');
+    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);
+    validateCeoLoad(patch);
     if (patch.owner !== undefined) {
       parseOwner(patch.owner);
       if (item.owner && patch.owner !== item.owner) {
         throw new CliUserError(`지금 주인: ${item.owner} — --force 로만 바꾼다`, 'release checklist claim <id> --by <자리> --force');
       }
     }
-    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind'] as const).filter((field) => patch[field] !== undefined && patch[field] !== item[field]);
+    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate'] as const).filter((field) => patch[field] !== undefined && JSON.stringify(patch[field]) !== JSON.stringify(item[field]));
     if (fields.length === 0) return false;
     const at = new Date().toISOString();
     for (const field of fields) {

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,24 +60,35 @@ 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)');
+    // 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; }
 }
 
-export interface ScheduleRow { version: string; cutAt: string; landBy: string | null; updatedAt: string; updatedBy: string }
-type StoredSchedule = { version: string; cut_at: string; land_by: string | null; updated_at: string; updated_by: string };
+export interface ScheduleRow { version: string; cutAt: string; landBy: string | null; freezeFrom?: string | null; freezeUntil?: string | null; updatedAt: string; updatedBy: string }
+type StoredSchedule = { version: string; cut_at: string; land_by: string | null; freeze_from: string | null; freeze_until: string | null; updated_at: string; updated_by: string };
 function scheduleRow(row: StoredSchedule): ScheduleRow {
-  return { version: row.version, cutAt: row.cut_at, landBy: row.land_by, updatedAt: row.updated_at, updatedBy: row.updated_by };
+  return { version: row.version, cutAt: row.cut_at, landBy: row.land_by, ...(row.freeze_from ? { freezeFrom: row.freeze_from } : {}), ...(row.freeze_until ? { freezeUntil: row.freeze_until } : {}), updatedAt: row.updated_at, updatedBy: row.updated_by };
 }
 
 export function readSchedule(version: string, root?: string): ScheduleRow | null {
@@ -84,7 +107,15 @@ export function readSchedules(root?: string): ScheduleRow[] {
   finally { db.close(); }
 }
 
-export function writeSchedule(version: string, patch: { cutAt?: string; landBy?: string }, by: string, root?: string): ScheduleRow {
+/** 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);
   try {
@@ -93,13 +124,17 @@ export function writeSchedule(version: string, patch: { cutAt?: string; landBy?:
       const cutAt = patch.cutAt ?? previous?.cut_at;
       if (!cutAt) throw new CliUserError('새 판에는 --cut-at 이 필요하다');
       const landBy = patch.landBy ?? previous?.land_by ?? null;
-      if (previous && previous.cut_at === cutAt && previous.land_by === landBy) return scheduleRow(previous);
+      const freezeFrom = patch.freezeFrom ?? previous?.freeze_from ?? null;
+      const freezeUntil = patch.freezeUntil ?? previous?.freeze_until ?? null;
+      if (Boolean(freezeFrom) !== Boolean(freezeUntil) || (freezeFrom && freezeUntil && Date.parse(freezeFrom) >= Date.parse(freezeUntil))) throw new CliUserError('동결 시작·끝은 함께 주고 시작이 끝보다 앞서야 한다');
+      if (previous && previous.cut_at === cutAt && previous.land_by === landBy && previous.freeze_from === freezeFrom && previous.freeze_until === freezeUntil) return scheduleRow(previous);
       const at = new Date().toISOString();
-      db.query(`INSERT INTO release_schedules (version, cut_at, land_by, updated_at, updated_by) VALUES (?, ?, ?, ?, ?)
-        ON CONFLICT(version) DO UPDATE SET cut_at=excluded.cut_at, land_by=excluded.land_by, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
-        .run(version, cutAt, landBy, at, by);
+      db.query(`INSERT INTO release_schedules (version, cut_at, land_by, freeze_from, freeze_until, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(version) DO UPDATE SET cut_at=excluded.cut_at, land_by=excluded.land_by, freeze_from=excluded.freeze_from, freeze_until=excluded.freeze_until, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
+        .run(version, cutAt, landBy, freezeFrom, freezeUntil, at, by);
       for (const [field, from, to] of [
         ['cut_at', previous?.cut_at ?? null, cutAt], ['land_by', previous?.land_by ?? null, landBy],
+        ['freeze_from', previous?.freeze_from ?? null, freezeFrom], ['freeze_until', previous?.freeze_until ?? null, freezeUntil],
       ] as const) {
         if (from !== to) record(db, version, { at, by, id: '@version', field, from, to, released: releasedVersion(root), dev: devVersion() });
       }
@@ -134,14 +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.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'] } : {}),
+    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 {
@@ -153,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, 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, 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.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'); }
 
@@ -196,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, 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.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);
@@ -224,12 +262,12 @@ 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'] 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'
       ? (!preserveRefs && current.evidence !== item.evidence)
-      : current[field] !== item[field]);
+      : JSON.stringify(current[field]) !== JSON.stringify(item[field]));
     if (!differs) continue;
     if (!(Date.parse(item.updatedAt) > Date.parse(current.updatedAt))) {
       ledgerWonIds.push(item.id);
@@ -369,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();
@@ -383,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/landing-freeze.ts

@@ -0,0 +1,121 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+
+export interface LandingFreeze {
+  reason: string;
+  startedAt: string;
+  until: string | null;
+  by: string;
+}
+
+export function landingFreezePath(root = effectiveInstanceRoot()): string {
+  return join(root, 'landing-freeze.json');
+}
+
+export function readLandingFreeze(root = effectiveInstanceRoot(), now = new Date()): LandingFreeze | null {
+  const path = landingFreezePath(root);
+  let text: string;
+  // Read without an existence pre-check: a concurrent `freeze off` between the two would surface as ENOENT.
+  try { text = readFileSync(path, 'utf8'); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null; throw error; }
+  const record: unknown = JSON.parse(text);
+  if (!record || typeof record !== 'object' || Array.isArray(record)) throw new Error(`invalid landing freeze: ${path}`);
+  const freeze = record as Partial<LandingFreeze>;
+  if (typeof freeze.reason !== 'string' || typeof freeze.by !== 'string' ||
+      typeof freeze.startedAt !== 'string' || !Number.isFinite(Date.parse(freeze.startedAt)) ||
+      !(freeze.until === null || (typeof freeze.until === 'string' && Number.isFinite(Date.parse(freeze.until))))) {
+    throw new Error(`invalid landing freeze: ${path}`);
+  }
+  // An expired freeze reads as «off». The file is left alone: deleting it here could race a concurrent `freeze on`
+  // that just wrote a new one (only `freeze off` removes it; the next `freeze on` overwrites it).
+  if (freeze.until && Date.parse(freeze.until) <= now.getTime()) return null;
+  return freeze as LandingFreeze;
+}
+
+export function enableLandingFreeze(opts: { reason?: string; until?: string; by?: string }, root = effectiveInstanceRoot(), now = new Date()): LandingFreeze {
+  const until = opts.until === undefined ? null : opts.until;
+  if (until !== null && (!/^\d{4}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d+)?)?(?:Z|[+-]\d\d:\d\d)$/.test(until) || !Number.isFinite(Date.parse(until)) || Date.parse(until) <= now.getTime())) {
+    throw new Error('--until must be a future ISO timestamp with timezone');
+  }
+  const freeze: LandingFreeze = { reason: opts.reason?.trim() || 'operator freeze', startedAt: now.toISOString(), until: until === null ? null : new Date(until).toISOString(), by: opts.by?.trim() || process.env.ELANOUS_TRACK || process.env.USER || 'cli' };
+  const path = landingFreezePath(root);
+  mkdirSync(root, { recursive: true });
+  const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    writeFileSync(tmp, `${JSON.stringify(freeze, null, 2)}\n`, { mode: 0o600 });
+    renameSync(tmp, path);
+  } finally { rmSync(tmp, { force: true }); }
+  return freeze;
+}
+
+export function disableLandingFreeze(root = effectiveInstanceRoot()): void {
+  rmSync(landingFreezePath(root), { force: true });
+}
+
+/** In-flight merge markers: a merger writes its marker «before» reading the freeze file, and `freeze on` writes the
+ *  freeze file «before» counting markers — so either the merger sees the freeze or the freeze waits for the merger. */
+function mergesDir(root: string): string { return join(root, 'landing-merges'); }
+
+export interface LandingMergeGuard { frozen: LandingFreeze | null; end: () => void }
+
+export function beginLandingMerge(root = effectiveInstanceRoot(), now = new Date()): LandingMergeGuard {
+  const dir = mergesDir(root);
+  mkdirSync(dir, { recursive: true });
+  const marker = join(dir, `${process.pid}-${randomUUID()}.json`);
+  writeFileSync(marker, `${JSON.stringify({ pid: process.pid, startedAt: now.toISOString() })}\n`, { mode: 0o600 });
+  const end = () => { rmSync(marker, { force: true }); };
+  let frozen: LandingFreeze | null;
+  try { frozen = readLandingFreeze(root, now); } catch (error) { end(); throw error; }
+  if (frozen) { end(); return { frozen, end: () => {} }; }
+  return { frozen: null, end };
+}
+
+/** Live in-flight merges; markers of dead processes are removed. */
+export function inFlightLandingMerges(root = effectiveInstanceRoot()): number {
+  const dir = mergesDir(root);
+  let names: string[];
+  try { names = readdirSync(dir); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return 0; throw error; }
+  let live = 0;
+  for (const name of names) {
+    const pid = Number(name.split('-')[0]);
+    let alive = false;
+    if (Number.isSafeInteger(pid) && pid > 0) {
+      try { process.kill(pid, 0); alive = true; } catch (error) { alive = (error as NodeJS.ErrnoException).code === 'EPERM'; }
+    }
+    if (alive) live++; else rmSync(join(dir, name), { force: true });
+  }
+  return live;
+}
+
+/** `freeze on` completes only after merges that passed their freeze check have finished (or the wait runs out). */
+export async function awaitLandingMergesDrained(
+  root = effectiveInstanceRoot(),
+  opts: { timeoutMs?: number; pollMs?: number; sleep?: (ms: number) => Promise<void> } = {},
+): Promise<{ drained: boolean; pending: number }> {
+  const timeoutMs = opts.timeoutMs ?? 600_000, pollMs = opts.pollMs ?? 1_000;
+  const sleep = opts.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const pending = inFlightLandingMerges(root);
+    if (pending === 0) return { drained: true, pending: 0 };
+    if (Date.now() >= deadline) return { drained: false, pending };
+    await sleep(pollMs);
+  }
+}
+
+/** Thrown where a release run stops for a freeze, so the scheduled `--if-ready` path can defer instead of failing. */
+export class LandingFrozenError extends Error {
+  constructor(readonly freeze: LandingFreeze) { super(landingFreezeMessage(freeze)); this.name = 'LandingFrozenError'; }
+}
+
+const FREEZE_MESSAGE_HEAD = '동결 중 · ';
+
+/** True when a node's recorded output or error is the freeze refusal written by {@link landingFreezeMessage}. */
+export function isLandingFreezeRefusal(text: string): boolean { return text.includes(FREEZE_MESSAGE_HEAD); }
+
+export function landingFreezeMessage(freeze: LandingFreeze): string {
+  return `${FREEZE_MESSAGE_HEAD}${freeze.reason} · 끝 시각 ${freeze.until ?? '미지정'}`;
+}

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;
+}